osgToBullet.h

Go to the documentation of this file.

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



#pragma once


#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationUtil.h>
#include <btBulletCollisionCommon.h>
#include <memory>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlFilename.h>
#include <geometry/surface.h>

#include <osg/Matrix>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvUtil/DtCoordinateSystem.h>

#include <vlutil/vlSmartPointers.h>

#include <memory>
#include "vlutil/vlFilename.h"

class btTriangleMesh;
class Coordinate_System;



namespace osg 
{
   class Node;
   class LOD;
}

//This should move to surface.h
const DT_DLL_vantageTerrainImplementation DtSurface& DtUndefinedSoilType();



namespace makVrf {
   class DtSurfaceCharacteristicMap 
   {

   public:

      DtSurfaceCharacteristicMap();

      virtual ~DtSurfaceCharacteristicMap();

      DtSurfaceCharacteristicMap(const DtSurfaceCharacteristicMap& orig);


      virtual bool init(const DtFilename filename, bool displayWarning = false);

      virtual bool get(std::istream& stream);

      virtual bool processToken(std::istream& stream, DtString& token);

      virtual bool characteristicsFromString(const char* str, 
         unsigned int& characteristics, int& position);

   protected:
      typedef boost::unordered_map <DtString, DtSurface::DtCharacteristics> DtSurfaceStringToCharacteristics;
      typedef DtSurfaceStringToCharacteristics::const_iterator DtSurfStrToCharsConstIter;
      typedef DtSurfaceStringToCharacteristics::iterator DtSurfStrToCharsIter;

      DtSurfaceStringToCharacteristics mySurfaceStringToCharacteristics;
      static const DtString theMatchString;

   private:

      std::set<std::string> myPrintedWarnings;
   };

}

//class makVrv::DtOsgRenderer::RootList;


class DT_DLL_vantageTerrainImplementation DtTriangleMeshWithSoil : public btTriangleMesh
{
public:
   DtTriangleMeshWithSoil (bool use32bitIndices=true, bool use4componentVertices=true);
   virtual ~DtTriangleMeshWithSoil();

   bool valid(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2) const;
   bool valid(const btVector3& vertex) const;
   bool valid(const btScalar& val) const;

   bool checkAddTriangle(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2,
      bool removeDuplicateVertices = false);

   void addTriangle(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2,
      bool removeDuplicateVertices = false);

   void addTriangleWithSurface(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2,
      const DtSurface& surface, bool removeDuplicateVertices=false);

   DtSurface triangleSurface(unsigned int triangleIndex) const;

   const btVector3& max() const;
   const btVector3& min() const;

   bool isAabbValid() const;

protected:
   void updateBounds(const btVector3& val);

   void initializeSurfaceArray();

   void syncSurfaceArray();

   bool myUseSurfaceArray;
   btAlignedObjectArray<DtSurface> mySurfaceTypes;
   btVector3 myMin;
   btVector3 myMax;
};

class DT_DLL_vantageTerrainImplementation DtBvhBuilder
{
public:
   virtual ~DtBvhBuilder();

   virtual bool buildBvh() = 0;
};

typedef std::list<btCollisionObject*> DtCollisionObjectList;
typedef std::vector<std::pair<DtTriangleMeshWithSoil*, osg::Matrix> > DtMeshTransformPairList;

struct DtVantageRootNode
{
   DtVantageRootNode(makVrv::DtOsgRenderer* r, makVrv::DtOsgRenderer::SceneRoot sr)
      : osgRenderer(r), sceneRoot(sr) {};
   makVrv::DtOsgRenderer* osgRenderer;
   makVrv::DtOsgRenderer::SceneRoot sceneRoot;
};

int convertOsgNodeToTriangeMesh(DtCollisionObjectList* collObjects, const DtDrawMode& drawMode, osg::Node* node, 
                                                     const osg::Matrix& baseTransform,
                                                     const DtFilename& surfaceCharacterFilename = "", bool treatPagedLODAsLOD = false,
                                                     bool checkGeodesForSurfaces = false,
                                                     std::vector<std::string> ignoreSurfacesMatching = std::vector<std::string>());

int convertOsgNodeToTriangeMesh(DtCollisionObjectList* collObjects, const DtDrawMode& drawMode, osg::Node* node, 
                                                     const osg::Matrix& baseTransform, const DtSurface& surface);

int convertOsgNodeToTriangeMesh(DtCollisionObjectList* collObjects, const DtDrawMode& drawMode, DtVantageRootNode node, 
                                                     const osg::Matrix& baseTransform,
                                                     const DtFilename& surfaceCharacterFilename = "", bool treatPagedLODAsLOD = false,
                                                     bool checkGeodesForSurfaces = false,
                                                     std::vector<std::string> ignoreSurfacesMatching = std::vector<std::string>());

Coordinate_System* createVrfCoordinateSystem( const makVrv::DtCoordinateSystem& coodSysIn );

void getBasisAndOrigin(osg::Matrix& matrix, 
                       btMatrix3x3& basisA, btVector3& origin, bool& scaled);

template<typename T_Node>
unsigned int createCollisionObjects(
                                    T_Node node,
                                    DtCollisionObjectList* collObjects, const DtDrawMode& drawMode, 
                                    osg::Matrix* worldMatrix = NULL,
                                    const DtFilename& surfaceCharacterFilename = "", bool treatPagedLODAsLOD = false, bool checkGeodesForSurfaces = false,
                                    std::vector<std::string> ignoreSurfacesMatching = std::vector<std::string>())
{
   osg::Matrix baseMatrix;
   if (worldMatrix)
   {
      baseMatrix = *worldMatrix;
   }

   int numTriangles = convertOsgNodeToTriangeMesh(collObjects, drawMode,
      node, baseMatrix, surfaceCharacterFilename, treatPagedLODAsLOD, checkGeodesForSurfaces,
      ignoreSurfacesMatching);

   return numTriangles;
}

template<typename T_Node>
unsigned int createCollisionObjects(
                                    T_Node node,
                                    DtCollisionObjectList* collObjects, const DtDrawMode& drawMode, const DtSurface& surface,
                                    osg::Matrix* worldMatrix = NULL)
{
   osg::Matrix baseMatrix;
   if (worldMatrix)
   {
      baseMatrix = *worldMatrix;
   }

   int numTriangles = convertOsgNodeToTriangeMesh(collObjects, drawMode, node, baseMatrix, surface);

   return numTriangles;
}