Extras/Serialize/BulletWorldImporter/btBulletWorldImporter.h

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library
   3 Copyright (c) 2003-2010 Erwin Coumans  http://continuousphysics.com/Bullet/
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14 */
  15
  16
  17 #ifndef BULLET_WORLD_IMPORTER_H
  18 #define BULLET_WORLD_IMPORTER_H
  19
  20 #include "LinearMath/btTransform.h"
  21 #include "LinearMath/btVector3.h"
  22 #include "LinearMath/btAlignedObjectArray.h"
  23 #include "LinearMath/btHashMap.h"
  24
  25
  26 class btBulletFile;
  27 class btCollisionShape;
  28 class btCollisionObject;
  29 class btRigidBody;
  30 class btTypedConstraint;
  31 class btDynamicsWorld;
  32 struct ConstraintInput;
  33 class btRigidBodyColladaInfo;
  34 struct btCollisionShapeData;
  35 class btTriangleIndexVertexArray;
  36 class btStridingMeshInterface;
  37 struct btStridingMeshInterfaceData;
  38 class btGImpactMeshShape;
  39 class btOptimizedBvh;
  40 struct btTriangleInfoMap;
  41 class btBvhTriangleMeshShape;
  42 class btPoint2PointConstraint;
  43 class btHingeConstraint;
  44 class btConeTwistConstraint;
  45 class btGeneric6DofConstraint;
  46 class btGeneric6DofSpringConstraint;
  47 class btSliderConstraint;
  48
  49
  50
  51 namespace bParse
  52 {
  53         class btBulletFile;
  54
  55 };
  56
  57
  58
  59 ///The btBulletWorldImporter is a starting point to import .bullet files.
  60 ///note that not all data is converted yet. You are expected to override or modify this class.
  61 ///See Bullet/Demos/SerializeDemo for a derived class that extract btSoftBody objects too.
  62 class btBulletWorldImporter
  63 {
  64 protected:
  65
  66         btDynamicsWorld* m_dynamicsWorld;
  67
  68         bool m_verboseDumpAllTypes;
  69
  70         btCollisionShape* convertCollisionShape(  btCollisionShapeData* shapeData  );
  71
  72         btAlignedObjectArray<btCollisionShape*>  m_allocatedCollisionShapes;
  73         btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
  74         btAlignedObjectArray<btTypedConstraint*> m_allocatedConstraints;
  75         btAlignedObjectArray<btOptimizedBvh*>    m_allocatedBvhs;
  76         btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
  77         btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
  78         btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
  79
  80         btAlignedObjectArray<char*>                             m_allocatedNames;
  81
  82         btAlignedObjectArray<int*>                              m_indexArrays;
  83         btAlignedObjectArray<short int*>                m_shortIndexArrays;
  84         btAlignedObjectArray<unsigned char*>    m_charIndexArrays;
  85
  86         btAlignedObjectArray<btVector3FloatData*>       m_floatVertexArrays;
  87         btAlignedObjectArray<btVector3DoubleData*>      m_doubleVertexArrays;
  88
  89
  90         btHashMap<btHashPtr,btOptimizedBvh*>    m_bvhMap;
  91         btHashMap<btHashPtr,btTriangleInfoMap*> m_timMap;
  92
  93         btHashMap<btHashString,btCollisionShape*>       m_nameShapeMap;
  94         btHashMap<btHashString,btRigidBody*>    m_nameBodyMap;
  95         btHashMap<btHashString,btTypedConstraint*>      m_nameConstraintMap;
  96         btHashMap<btHashPtr,const char*>        m_objectNameMap;
  97
  98         btHashMap<btHashPtr,btCollisionShape*>  m_shapeMap;
  99         btHashMap<btHashPtr,btCollisionObject*> m_bodyMap;
 100
 101
 102         //methods
 103
 104
 105
 106         static btRigidBody& getFixedBody();
 107
 108         char*   duplicateName(const char* name);
 109
 110 public:
 111
 112         btBulletWorldImporter(btDynamicsWorld* world=0);
 113
 114         virtual ~btBulletWorldImporter();
 115
 116         ///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
 117         ///make sure you don't use the dynamics world containing objects after you call this method
 118         virtual void deleteAllData();
 119
 120         bool    loadFile(const char* fileName);
 121
 122         ///the memoryBuffer might be modified (for example if endian swaps are necessary)
 123         bool    loadFileFromMemory(char *memoryBuffer, int len);
 124
 125         bool    loadFileFromMemory(bParse::btBulletFile* file);
 126
 127         //call make sure bulletFile2 has been parsed, either using btBulletFile::parse or btBulletWorldImporter::loadFileFromMemory
 128         virtual bool    convertAllObjects(bParse::btBulletFile* file);
 129
 130         void    setVerboseMode(bool verboseDumpAllTypes)
 131         {
 132                 m_verboseDumpAllTypes = verboseDumpAllTypes;
 133         }
 134
 135         bool getVerboseMode() const
 136         {
 137                 return m_verboseDumpAllTypes;
 138         }
 139
 140         // query for data
 141         int     getNumCollisionShapes() const;
 142         btCollisionShape* getCollisionShapeByIndex(int index);
 143         int getNumRigidBodies() const;
 144         btCollisionObject* getRigidBodyByIndex(int index) const;
 145         int getNumConstraints() const;
 146         btTypedConstraint* getConstraintByIndex(int index) const;
 147         int getNumBvhs() const;
 148         btOptimizedBvh*  getBvhByIndex(int index) const;
 149         int getNumTriangleInfoMaps() const;
 150         btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
 151
 152         // queris involving named objects
 153         btCollisionShape* getCollisionShapeByName(const char* name);
 154         btRigidBody* getRigidBodyByName(const char* name);
 155         btTypedConstraint* getConstraintByName(const char* name);
 156         const char*     getNameForPointer(const void* ptr) const;
 157
 158         ///those virtuals are called by load and can be overridden by the user
 159
 160         //bodies
 161         virtual btRigidBody*  createRigidBody(bool isDynamic,   btScalar mass,  const btTransform& startTransform,      btCollisionShape* shape,const char* bodyName);
 162         virtual btCollisionObject*  createCollisionObject(      const btTransform& startTransform,      btCollisionShape* shape,const char* bodyName);
 163
 164         ///shapes
 165
 166         virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal,btScalar planeConstant);
 167         virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
 168         virtual btCollisionShape* createSphereShape(btScalar radius);
 169         virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
 170         virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
 171         virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
 172
 173         virtual btCollisionShape* createCylinderShapeX(btScalar radius,btScalar height);
 174         virtual btCollisionShape* createCylinderShapeY(btScalar radius,btScalar height);
 175         virtual btCollisionShape* createCylinderShapeZ(btScalar radius,btScalar height);
 176         virtual class btTriangleIndexVertexArray*       createTriangleMeshContainer();
 177         virtual btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
 178         virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
 179         virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
 180         virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
 181
 182         virtual class btConvexHullShape* createConvexHullShape();
 183         virtual class btCompoundShape* createCompoundShape();
 184         virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape,const btVector3& localScalingbtBvhTriangleMeshShape);
 185
 186         virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
 187
 188         ///acceleration and connectivity structures
 189         virtual btOptimizedBvh* createOptimizedBvh();
 190         virtual btTriangleInfoMap* createTriangleInfoMap();
 191
 192         ///constraints
 193         virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB);
 194         virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);
 195         virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA=false);
 196         virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA=false);
 197         virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTransform& rbAFrame, const btTransform& rbBFrame);
 198         virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);
 199         virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
 200     virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
 201         virtual btGeneric6DofSpringConstraint* createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
 202         virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
 203     virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
 204
 205 };
 206
 207 #endif //BULLET_WORLD_IMPORTER_H
 208