collisionWorld.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vantageTerrainImplementation/osgToBullet.h>
#include <vantageTerrainImplementation/vantageTerrainConsoleCommands.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/vantageTerrainImplementation.h>
#include <list>
#include <vlutil/vlSmartPointers.h>
#include <geometry/intersectionRecord.h>
#include <tbb/spin_rw_mutex.h>
#include <features/proj.h>
#include <set>
#include <unordered_map>

#include <BulletCollision/CollisionShapes/btTriangleCallback.h>
#include <atomic>
#include <vantageTerrainImplementation/collisionShapeManager.h>

class DtChord;
class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;
class DtSphere;

class DtBulletTriangleCallback;
class DtTriangleMeshWithSoil;

class DT_DLL_vantageTerrainImplementation DtCollisionWorld
{
public:
   class DT_DLL_vantageTerrainImplementation DtFidListMonitor
   {
   public:
      DtFidListMonitor();
      virtual ~DtFidListMonitor() = 0;

      bool check() const;
      bool checkAndReset();
   protected:
      std::atomic<bool> myChanged;
   };

protected:
   class DT_DLL_vantageTerrainImplementation DtFidListMonitorImpl : public DtFidListMonitor
   {
   public:
      DtFidListMonitorImpl();
      virtual ~DtFidListMonitorImpl() override;

      void setChanged();
   };

private:

   DtCollisionWorld(const DtCollisionWorld&) = delete;
   DtCollisionWorld& operator=(const DtCollisionWorld&) = delete;
public:
   DtCollisionWorld();
   virtual ~DtCollisionWorld();

   virtual void initialize();

   virtual unsigned collisionObjectCount();

   virtual unsigned collisionMeshCount();

   virtual unsigned int uniqueTriangleCount();

   virtual void addCollisionObjectToWorld(
      const std::shared_ptr<btCollisionObject>& object,
      short int objectGroup = btBroadphaseProxy::DefaultFilter);

   virtual void addCollisionObjectsToWorld(
      const DtCollisionObjectList& object,
      short int objectGroup = btBroadphaseProxy::DefaultFilter);

   virtual unsigned int removeCollisionObjectFromWorld(
      const std::shared_ptr<btCollisionObject>& collisionObject);

   virtual unsigned int removeCollisionObjectsFromWorld(const DtCollisionObjectList&);

   virtual void removeCollisionObjectFromWorld(const std::set<long long>& OsmFidList);

   virtual void enableHiddenCollisionObjectInWorld();

   virtual void enableHiddenCollisionObjectInWorld(const std::set<long long>& OsmFidList);

   virtual bool chordIntersect(const DtChord& chord,
      DtVrfChordIntersectionRecord& record,
      bool& dataAvailable,
      DtIntersectionRecord::DtIntersectionType irtFlag,
      short int filterMask ) const;

   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      bool& dataAvailable,
      DtIntersectionRecord::DtIntersectionType irtFlag,
      short int filterMask) const;

   virtual bool updateWorldTransform(btCollisionObject* obj, const btTransform&);

   virtual void setCoordinateSystem(const Coordinate_System* cs);
   virtual const Coordinate_System* coordinateSystem();

   virtual void processTrianglesInArea(DtBulletTriangleCallback&);

   virtual void processTrianglesForGeometry(DtBulletTriangleCallback& calllback, DtTerrainGeometryId geometryId);

   virtual long numberOfUnloadableTerrainTriangles() const;
   virtual void setNumberOfUnloadableTerrainTriangles(long value);

   virtual std::shared_ptr<DtFidListMonitor> getFidListMonitor();

   virtual void setFidHideFunction(std::function<bool(const long long)> fcn);

   struct DT_DLL_vantageTerrainImplementation CollisionMetric
   {
      int myMetricAddCollisionObjectToWorld;
      int myMetricRemoveCollisionObjectToWorld;
      unsigned int myChordIntersect;
      unsigned int myAllIntersectsAlongChord;
   };

   virtual void enableMetrics(bool value);

   virtual void getMetrics(CollisionMetric& collisionMetrics) ;

protected:
   virtual btCollisionWorld* bulletCollisionWorld();

   virtual void deleteInternalMemberVariables();

   virtual void notifyFidListMonitors();

   virtual bool isFidHidden(const long long fid);

   virtual void calculateMeshAndTriangleCount();

   //Bullet intersection members.
 
   typedef std::set< std::shared_ptr<btCollisionObject> > CollisionObjectSet;
   CollisionObjectSet myCollisionObjects;

   const Coordinate_System* myCoordinateSystem;
   btCollisionWorld* myCollisionWorld;

   btCollisionConfiguration* myCollisionConfiguration;
   btBroadphaseInterface* myBroadphaseInterface;
   btCollisionDispatcher* myCollisionDispatcher;
   long myNumberOfUnloadableTerrainTriangles;

   typedef std::unordered_multimap<long long, std::shared_ptr<btCollisionObject>> FidToCollisionOjectMap;
   FidToCollisionOjectMap myFidToCollisionOjectMap;
   std::list<std::weak_ptr<DtFidListMonitorImpl> > myFidListMonitorList;

   using Mutex = tbb::spin_rw_mutex;
   mutable Mutex myMutex;
   std::function<bool(const long long)> myHiddenFidFcn;

   virtual void resetMetrics();

   bool myRecordMetrics;

   unsigned int myNumCollisionShapes;
   unsigned int myNumTrianglesOfAllShapes;
   bool myNumCollisionShapesDirty;
   
   CollisionMetric myCollisionMetrics;

   DtCollisionShapeManager myCollisionShapeManager;
};

class DT_DLL_vantageTerrainImplementation DtBulletTriangleCallback : public btTriangleCallback
{
public:
   DtBulletTriangleCallback(DtTriangleOutputInterface& output, const DtTerrainProcessPolygonsBox& box, DtTerrainCategoryMask terrainCategoryMask);
   virtual ~DtBulletTriangleCallback() override;
   virtual const DtTerrainProcessPolygonsBox& box() const;
   virtual DtTriangleOutputInterface& outputInterface();
   virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) override;
   virtual void setTransform(btTransform* transform);
   virtual void setMesh(const DtTriangleMeshWithSoil* mesh);
   virtual void setCollisionObject(const DtCollisionObjectInterface* obj);
   virtual int  terrainCategoryMask() const;

protected:
   btVector3 translatePoint(const btVector3& v);

protected:
   DtTriangleOutputInterface& myOutput;
   btTransform* myTransform;
   const DtTerrainProcessPolygonsBox* myBox;
   const DtCollisionObjectInterface* myCollisionObject;
   const DtTriangleMeshWithSoil* myMesh;
   void* myVrfUsr;
   DtTerrainCategoryMask myTerrainCategoryMask;
};