include/vantageTerrainImplementation/osgToBullet.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile:  $ $Revision: $ $State: $
*******************************************************************************/



#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:

      virtual DtSurface* createSurface();

   protected:
      typedef std::map <DtString, DtSurface::DtCharacteristics> DtSurfaceStringToCharacteristics;
      typedef DtSurfaceStringToCharacteristics::const_iterator DtSurfStrToCharsConstIter;
      typedef DtSurfaceStringToCharacteristics::iterator DtSurfStrToCharsIter;

      DtSurfaceStringToCharacteristics mySurfaceStringToCharacteristics;
      static const DtString theMatchString;
      DtSurface* mySurface;

   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) :
      btTriangleMesh(use32bitIndices, use4componentVertices),
      myUseSurfaceArray(false) {}
   virtual ~DtTriangleMeshWithSoil() {};

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

   DtSurface triangleSurface(unsigned int triangleIndex) const;

protected:
   void initializeSurfaceArray();

   void syncSurfaceArray();

   bool myUseSurfaceArray;
   btAlignedObjectArray<DtSurface> mySurfaceTypes;
};

typedef std::map<osg::Geode*, DtTriangleMeshWithSoil*> DtGeodeToMeshMap;
typedef std::list<std::pair<btCollisionObject*, DtTriangleMeshWithSoil*> > 
DtCollObjMeshPairList;
typedef std::list<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;
};

DtMeshTransformPairList* convertOsgNodeToTriangeMesh(osg::Node* node, 
                                                     unsigned int& numTriangleOut, const osg::Matrix& baseTransform,
                                                     const DtFilename& surfaceCharacterFilename = "");

DtMeshTransformPairList* convertOsgNodeToTriangeMesh(DtVantageRootNode node, 
                                                     unsigned int& numTriangleOut, const osg::Matrix& baseTransform,
                                                     const DtFilename& surfaceCharacterFilename = "");

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

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

template<typename T_Node>
unsigned int createCollisionObjects(
                                    T_Node node,
                                    DtCollObjMeshPairList* collObjMeshPairs, const DtDrawMode& drawMode, 
                                    osg::Matrix* worldMatrix = NULL,
                                    const DtFilename& surfaceCharacterFilename = "")
{
   unsigned int numTriangles = 0;
   osg::Matrix baseMatrix;
   if (worldMatrix)
   {
      baseMatrix = *worldMatrix;
   }
   DtMeshTransformPairList* meshTransformPairs = convertOsgNodeToTriangeMesh(
      node, numTriangles, baseMatrix, surfaceCharacterFilename);

   DtMeshTransformPairList::iterator itr = meshTransformPairs->begin();
   DtMeshTransformPairList::iterator end = meshTransformPairs->end();
   for(; itr != end; ++itr)
   {
      if (itr->first->getNumTriangles() != 0)
      {
         numTriangles += itr->first->getNumTriangles();

         btCollisionObject* collisionObject = new btCollisionObject();
         btBvhTriangleMeshShape* terrainShape = 
            new btBvhTriangleMeshShape(itr->first, true);

         collisionObject->setCollisionShape(terrainShape);

         if (drawMode & DT_DRAW_POLYGONS)
         {
            collisionObject->setCollisionFlags(collisionObject->getCollisionFlags() & !btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT);
         }
         else
         {
            collisionObject->setCollisionFlags(collisionObject->getCollisionFlags() | btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT);      
         }

         osg::Matrix matrix;
         matrix = itr->second;
         btMatrix3x3 basisA;
         btVector3 origin;

         getBasisAndOrigin(matrix, basisA, origin);

         collisionObject->getWorldTransform().setBasis(basisA);
         collisionObject->getWorldTransform().setOrigin(origin);

         collObjMeshPairs->push_back(std::make_pair(collisionObject, itr->first));  
      }
   }
   delete meshTransformPairs;

   return numTriangles;
}