osgToBullet.h

Go to the documentation of this file.

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



#pragma once

#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationUtil.h>
#include <vantageTerrainImplementation/surfaceCharacteristicsMap.h>
#include <vantageTerrainImplementation/bvhTriangleMeshShape.h>
#include <vrfutil/vrfPrint.h>
#include <btBulletCollisionCommon.h>
#include <btBulletDynamicsCommon.h>
#include <memory>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlFilename.h>
#include <geometry/surface.h>
#include <terrainInterface/terrainProcessPolygonsBox.h>

#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/TextureBuffer>

#include <osgEarth/DrawInstanced>

#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtSceneRoot.h>
#include <vrvOsg/DtDynamicTerrainStateManipulatorFactory.h>
#include <vrvCore/DtDynamicTerrainWorld.h>

#include <osgEarth/MetadataNode>

#include <vlutil/vlSmartPointers.h>

#include <memory>

#include <boost/regex.hpp>

class btTriangleMesh;
class Coordinate_System;
class DtVantageTerrainEngine;

namespace osg 
{
   class Node;
   class LOD;
}

typedef std::vector<osg::Drawable*> DrawablesList;

class ConvertToBulletVisitor
   : public osg::NodeVisitor
   , public makVrv::DtDynamicTerrainStateManipulatorFactory
{
public:
   enum ConvertToBulletFlags
   {
      TreatPagedLODAsLOD = 0x00000001,
      CheckGeodesForSurfaces = 0x00000002,
      UseQuantization = 0x00000004,
      BuildBvhNow = 0x00000008,
      FilterTransparentPolygons = 0x00000010,
      DefaultConversion = UseQuantization
   };

   ConvertToBulletVisitor(DtVantageTerrainEngine* terrainEngine,
      osg::NodeVisitor::VisitorType visitorType = NodeVisitor::INTERSECTION_VISITOR,
      osg::NodeVisitor::TraversalMode traverseMode = TRAVERSE_ALL_CHILDREN);

   virtual ~ConvertToBulletVisitor() override;

   void setLoadOnlyActiveSwitchState(bool value);
   void setDefaultSoiltype(const std::string& defaultSoiltype);
   bool loadOnlyActiveSwitchState() const;
   bool hasFlags(ConvertToBulletFlags flags) const;
   void setFlagsFor(ConvertToBulletFlags flags, bool val);
   void setIgnoreSurfacesMatching(const std::vector<std::string>& ignoreSurfacesMatching);
   void setSurfaceCharMap(makVrf::DtSurfaceCharacteristicMapConstPtr surfCharMap);
   void setDefaultSurface(const DtSurface& surface);
   const osg::Matrix& matrix() const;
   void setMatrix(const osg::Matrix& matrix);
   ConvertToBulletVisitor::ConvertToBulletFlags conversionFlags() const;
   void setConversionFlags(ConvertToBulletVisitor::ConvertToBulletFlags f);
   void processModelsEncodedInUserdata(osg::Node& node);
   virtual DtSurface getCurrentSurfaceFromSMCFID(osg::Node& node, bool& hasValidSurface);
   virtual void getCurrentSurface(osg::Group& node);
   DtSurface convertFilenameToSurface(const std::string& fname, int& position, int& matchClass, bool& ignored);
   virtual DtSurface convertImageToSurfaceType(osg::StateSet* stateSet, bool& hasValidSurface, bool& ignored);

   struct BtTriangle
   {
      btVector3 point1;
      btVector3 point2;
      btVector3 point3;
   };
   typedef std::multimap<long long, BtTriangle> Fid2BttriangleMap;

   class DtCollisionObject : public DtBvhCollisionObject
   {
   public:
      DtCollisionObject();

      void addDynamicFeature(const std::shared_ptr<makVrv::DtDynamicTerrainFeature>& feature);
      virtual DynamicFeatures dynamicFeatures() const override;
      DtTerrainInstanceId objectId() const;

   protected:
      static std::atomic<unsigned int> theLastId;

      typedef std::vector< std::weak_ptr<makVrv::DtDynamicTerrainFeature> > DynamicFeatureVector;
      DynamicFeatureVector myFeatures;
      DtTerrainInstanceId myObjectId = 0;
   };

   class DtSwitchableCollisionObject : public DtCollisionObject
   {
      DtSwitchableCollisionObject();
      DtSwitchableCollisionObject(long long fid);

   public:
      static std::shared_ptr<DtSwitchableCollisionObject> Create();
      static std::shared_ptr<DtSwitchableCollisionObject> Create(long long fid);
      long long getFid();
      virtual bool enabled() const override;
      void hide(bool value);
      void incrementDisabledCounter();
      void decrementDisabledCounter();

   protected:
      std::atomic<unsigned int> myDisabledCounter;
      long long myFid;
      bool myHidden;
   };

   class NodeId
   {
   public:
      typedef std::list<NodeId> List;
      explicit NodeId(size_t hash);
      NodeId* addChild(size_t hash);
      const List& children() const;
      void addCollisionObject(const std::shared_ptr<btCollisionObject>& obj);
      void getAllCollisionObjects(DtCollisionObjectList& objs) const;

   private:
      DtCollisionObjectList myObjects;
      List myChildNodes;
      size_t myHash;
   };

   bool ignoreDrawable(osg::Drawable* drawable) const;
   size_t getScaleHash(const osg::Vec3d& scale) const;
   void createMeshForDrawables(const DtSurface& surface, const DrawablesList& drawables, osg::Node& node);
   void createMeshFromDrawables(osg::Geode& geode, DtSurface surface, bool hasValidSurface);
   virtual bool createGeometryFromCache(osg::Node& node);
   
   virtual void apply(osg::Geode& geode) override;
   virtual void apply(osg::Drawable& drawable) override;
   virtual void apply(osg::Geometry& geometry) override;
   virtual void apply(osg::LOD& node) override;
   virtual void apply(osg::PagedLOD& node) override;
   virtual void apply(osg::Group& node) override;
   virtual void apply(osg::Sequence& node) override;
   virtual void apply(osg::Transform& node) override;
   virtual void apply(osg::MatrixTransform& node) override;
   virtual void apply(osg::Node& node) override;

   class VrfSwitch : public makVrv::DtDynamicTerrainSwitch
   {
   public:
      VrfSwitch();
      virtual void setFeature(const std::shared_ptr<makVrv::DtDynamicTerrainFeature>& feature) override;
      void addObjectToStateState(unsigned int index, const std::shared_ptr<btCollisionObject>& obj);
      void addObjectsToStateState(unsigned int index, DtCollisionObjectList& objects);
      virtual void setState(unsigned int index) override;
      virtual unsigned int getState() const override;
      virtual unsigned int getPreviousState() const override;
      virtual unsigned int numStates() const;

   private:
      typedef std::vector<std::shared_ptr<DtSwitchableCollisionObject>> CollisionObjectVector;
      typedef std::vector<CollisionObjectVector> CollisionObjectSets;

      CollisionObjectSets myObjects;
      int myCurrentState;
      unsigned int myPreviousState;
   };

   virtual makVrv::DtDynamicTerrainSwitch* createSwitch(const osg::ref_ptr<osgSim::MultiSwitch>& mswitch) override;
   virtual makVrv::DtDynamicTerrainSwitch* createSwitch(const osg::ref_ptr<osg::Switch>& sw) override;
   virtual makVrv::DtDynamicTerrainSwitch* createSwitch(
      const osg::ref_ptr<makVrv::DtDynamicTerrainSwitchNode>& sw, size_t hash) override;
   void getCollisionObjects(DtCollisionObjectList& objs);

   typedef std::vector<osg::Matrix> MatrixStack;

protected:

   void createCollisionObjectFromMesh(std::unique_ptr<DtTriangleMeshWithSoil>& mesh, osg::Node& node, long long fid);
   void collectInstanceTriangles(osgEarth::DrawInstanced::InstanceGeometry* instancedGeometry, Fid2BttriangleMap& geometryMap);

   typedef std::list<DtBvhTriangleMeshShape::Ptr> ShapeList;
   typedef std::map<size_t, ShapeList> ScaledInstanceShapeMap;
   typedef std::unordered_map<osg::Node*, ScaledInstanceShapeMap> NodeToShapeMap;

   DtVantageTerrainEngine* myTerrainEngine;

   NodeToShapeMap myNodeToShapeMap;
   DtSurface myCurrentSurface;
   makVrf::DtSurfaceCharacteristicMapConstPtr mySurfaceCharacteristicMap;
   osg::Matrix       myMatrix;

   MatrixStack myMatrixStack;
   inline void pushMatrix(osg::Matrix& matrix) { myMatrixStack.push_back(matrix); }
   inline void popMatrix() { myMatrixStack.pop_back(); }

   std::vector<boost::regex> myIgnoreRegexSurfacesMatching;
   ConvertToBulletFlags myFlags;
   unsigned myNumGeodeParents;
   bool myLoadOnlyActiveSwitchState;
   std::string myDefaultSoiltype;
   
   class ParentStackGuard : boost::noncopyable
   {
   public:
      explicit ParentStackGuard(osg::Node& node, ConvertToBulletVisitor& visitor);
      ~ParentStackGuard();

   private:
      ConvertToBulletVisitor& myVisitor;
      NodeId* mySavedParentId;
   };

   friend class ParentStackGuard;

   NodeId myRootNodeId;
   NodeId* myCurrentParentNodeId;

   typedef boost::unordered_map<size_t, NodeId*> HashToNodeIdMap;
   HashToNodeIdMap myHashToNodeIdMap;

   typedef boost::unordered_map<osg::Node*, NodeId*> NodeToNodeIdMap;
   NodeToNodeIdMap myNodeToNodeIdMap;

   osgEarth::MetadataNode* myMetadataNode;
   osg::observer_ptr< osg::TextureBuffer > myTbo;

public:
   int myNumDrawables;
   int myNumTriangles;
   int myNumBulletShapes;
   int myNumBulletObjects;
   int myNumScaledGeometries;
};


class DT_DLL_vantageTerrainImplementation DtVrfSimTerrainProcessor
{
public:
   static std::unique_ptr<DtVrfSimTerrainProcessor> Create();

   static std::unique_ptr<DtVrfSimTerrainProcessor> Create(DtVantageTerrainEngine&);

   virtual ~DtVrfSimTerrainProcessor();

   virtual unsigned int numberOfTriangles() const = 0;

   virtual void setDefaultSurface(const DtSurface&) = 0;
   virtual void setMatrix(const osg::Matrix&) = 0;
   virtual void setTraversalMode(osg::NodeVisitor::TraversalMode) = 0;
   virtual void setVisitorType(osg::NodeVisitor::VisitorType) = 0;
   virtual void setSurfaceCharacteristicsMap(makVrf::DtSurfaceCharacteristicMapConstPtr) = 0;
   virtual void setSurfacesToIgnore(const std::vector<std::string>&) = 0;

   virtual void setTreatPagedLODAsLOD(bool) = 0;
   virtual void setCheckGeodesForSurfaces(bool) = 0;
   virtual void setUseQuantization(bool) = 0;
   virtual void setBuildBvhNow(bool) = 0;
   virtual void setFilterTransparentPolygons(bool) = 0;

   virtual makVrv::DtDynamicTerrainWorld::FeatureHandle createTerrainObjects(
      osg::Node*, const std::string& defaultSoiltype, bool LoadOnlyActiveSwitchState = false) = 0;

   virtual void getCollisionObjects(DtCollisionObjectList& objs) = 0;

protected:
   explicit DtVrfSimTerrainProcessor(DtVantageTerrainEngine*);

   DtVantageTerrainEngine* myTerrainEngine;
};