Extras/Serialize/ReadBulletSample/BulletDataExtractor.cpp

   1 \r
   2 #include "BulletDataExtractor.h"\r
   3 #include "../BulletFileLoader/btBulletFile.h"\r
   4 \r
   5 #include <stdio.h>\r
   6 \r
   7 ///work-in-progress \r
   8 ///This ReadBulletSample is kept as simple as possible without dependencies to the Bullet SDK.\r
   9 ///It can be used to load .bullet data for other physics SDKs\r
  10 ///For a more complete example how to load and convert Bullet data using the Bullet SDK check out\r
  11 ///the Bullet/Demos/SerializeDemo and Bullet/Serialize/BulletWorldImporter\r
  12 \r
  13 using namespace Bullet;\r
  14 \r
  15 enum LocalBroadphaseNativeTypes\r
  16 {\r
  17         // polyhedral convex shapes\r
  18         BOX_SHAPE_PROXYTYPE,\r
  19         TRIANGLE_SHAPE_PROXYTYPE,\r
  20         TETRAHEDRAL_SHAPE_PROXYTYPE,\r
  21         CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,\r
  22         CONVEX_HULL_SHAPE_PROXYTYPE,\r
  23         CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,\r
  24         CUSTOM_POLYHEDRAL_SHAPE_TYPE,\r
  25 //implicit convex shapes\r
  26 IMPLICIT_CONVEX_SHAPES_START_HERE,\r
  27         SPHERE_SHAPE_PROXYTYPE,\r
  28         MULTI_SPHERE_SHAPE_PROXYTYPE,\r
  29         CAPSULE_SHAPE_PROXYTYPE,\r
  30         CONE_SHAPE_PROXYTYPE,\r
  31         CONVEX_SHAPE_PROXYTYPE,\r
  32         CYLINDER_SHAPE_PROXYTYPE,\r
  33         UNIFORM_SCALING_SHAPE_PROXYTYPE,\r
  34         MINKOWSKI_SUM_SHAPE_PROXYTYPE,\r
  35         MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,\r
  36         BOX_2D_SHAPE_PROXYTYPE,\r
  37         CONVEX_2D_SHAPE_PROXYTYPE,\r
  38         CUSTOM_CONVEX_SHAPE_TYPE,\r
  39 //concave shapes\r
  40 CONCAVE_SHAPES_START_HERE,\r
  41         //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!\r
  42         TRIANGLE_MESH_SHAPE_PROXYTYPE,\r
  43         SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,\r
  44         ///used for demo integration FAST/Swift collision library and Bullet\r
  45         FAST_CONCAVE_MESH_PROXYTYPE,\r
  46         //terrain\r
  47         TERRAIN_SHAPE_PROXYTYPE,\r
  48 ///Used for GIMPACT Trimesh integration\r
  49         GIMPACT_SHAPE_PROXYTYPE,\r
  50 ///Multimaterial mesh\r
  51     MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,\r
  52         \r
  53         EMPTY_SHAPE_PROXYTYPE,\r
  54         STATIC_PLANE_PROXYTYPE,\r
  55         CUSTOM_CONCAVE_SHAPE_TYPE,\r
  56 CONCAVE_SHAPES_END_HERE,\r
  57 \r
  58         COMPOUND_SHAPE_PROXYTYPE,\r
  59 \r
  60         SOFTBODY_SHAPE_PROXYTYPE,\r
  61         HFFLUID_SHAPE_PROXYTYPE,\r
  62         HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,\r
  63         INVALID_SHAPE_PROXYTYPE,\r
  64 \r
  65         MAX_BROADPHASE_COLLISION_TYPES\r
  66         \r
  67 };\r
  68 \r
  69 btBulletDataExtractor::btBulletDataExtractor()\r
  70 {\r
  71 }\r
  72 \r
  73 btBulletDataExtractor::~btBulletDataExtractor()\r
  74 {\r
  75 }\r
  76 \r
  77 void btBulletDataExtractor::convertAllObjects(bParse::btBulletFile* bulletFile2)\r
  78 {\r
  79         int i;\r
  80 \r
  81         for (i=0;i<bulletFile2->m_collisionShapes.size();i++)\r
  82         {\r
  83                 btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];\r
  84                 if (shapeData->m_name)\r
  85                         printf("converting shape %s\n", shapeData->m_name);\r
  86                 void* shape = convertCollisionShape(shapeData);\r
  87         }\r
  88 \r
  89 }\r
  90 \r
  91 \r
  92 \r
  93 void* btBulletDataExtractor::convertCollisionShape(  btCollisionShapeData* shapeData  )\r
  94 {\r
  95         void* shape = 0;\r
  96 \r
  97         switch (shapeData->m_shapeType)\r
  98                 {\r
  99         case STATIC_PLANE_PROXYTYPE:\r
 100                 {\r
 101                         btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)shapeData;\r
 102                         void* shape = createPlaneShape(planeData->m_planeNormal,planeData->m_planeConstant, planeData->m_localScaling);\r
 103                         break;\r
 104                 }\r
 105 \r
 106                 case CYLINDER_SHAPE_PROXYTYPE:\r
 107                 case CAPSULE_SHAPE_PROXYTYPE:\r
 108                 case BOX_SHAPE_PROXYTYPE:\r
 109                 case SPHERE_SHAPE_PROXYTYPE:\r
 110                 case MULTI_SPHERE_SHAPE_PROXYTYPE:\r
 111                 case CONVEX_HULL_SHAPE_PROXYTYPE:\r
 112                         {\r
 113                                 btConvexInternalShapeData* bsd = (btConvexInternalShapeData*)shapeData;\r
 114                                 \r
 115                                 switch (shapeData->m_shapeType)\r
 116                                 {\r
 117                                         case BOX_SHAPE_PROXYTYPE:\r
 118                                                 {\r
 119                                                         shape = createBoxShape(bsd->m_implicitShapeDimensions, bsd->m_localScaling,bsd->m_collisionMargin);\r
 120                                                         break;\r
 121                                                 }\r
 122                                         case SPHERE_SHAPE_PROXYTYPE:\r
 123                                                 {\r
 124                                                         shape = createSphereShape(bsd->m_implicitShapeDimensions.m_floats[0],bsd->m_localScaling, bsd->m_collisionMargin);\r
 125                                                         break;\r
 126                                                 }\r
 127 #if 0\r
 128                                         case CAPSULE_SHAPE_PROXYTYPE:\r
 129                                                 {\r
 130                                                         btCapsuleShapeData* capData = (btCapsuleShapeData*)shapeData;\r
 131                                                         switch (capData->m_upAxis)\r
 132                                                         {\r
 133                                                         case 0:\r
 134                                                                 {\r
 135                                                                         shape = createCapsuleShapeX(implicitShapeDimensions.getY(),2*implicitShapeDimensions.getX());\r
 136                                                                         break;\r
 137                                                                 }\r
 138                                                         case 1:\r
 139                                                                 {\r
 140                                                                         shape = createCapsuleShapeY(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getY());\r
 141                                                                         break;\r
 142                                                                 }\r
 143                                                         case 2:\r
 144                                                                 {\r
 145                                                                         shape = createCapsuleShapeZ(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getZ());\r
 146                                                                         break;\r
 147                                                                 }\r
 148                                                         default:\r
 149                                                                 {\r
 150                                                                         printf("error: wrong up axis for btCapsuleShape\n");\r
 151                                                                 }\r
 152 \r
 153                                                         };\r
 154                                                         \r
 155                                                         break;\r
 156                                                 }\r
 157                                         case CYLINDER_SHAPE_PROXYTYPE:\r
 158                                                 {\r
 159                                                         btCylinderShapeData* cylData = (btCylinderShapeData*) shapeData;\r
 160                                                         btVector3 halfExtents = implicitShapeDimensions+margin;\r
 161                                                         switch (cylData->m_upAxis)\r
 162                                                         {\r
 163                                                         case 0:\r
 164                                                                 {\r
 165                                                                         shape = createCylinderShapeX(halfExtents.getY(),halfExtents.getX());\r
 166                                                                         break;\r
 167                                                                 }\r
 168                                                         case 1:\r
 169                                                                 {\r
 170                                                                         shape = createCylinderShapeY(halfExtents.getX(),halfExtents.getY());\r
 171                                                                         break;\r
 172                                                                 }\r
 173                                                         case 2:\r
 174                                                                 {\r
 175                                                                         shape = createCylinderShapeZ(halfExtents.getX(),halfExtents.getZ());\r
 176                                                                         break;\r
 177                                                                 }\r
 178                                                         default:\r
 179                                                                 {\r
 180                                                                         printf("unknown Cylinder up axis\n");\r
 181                                                                 }\r
 182 \r
 183                                                         };\r
 184                                                         \r
 185 \r
 186                                                         \r
 187                                                         break;\r
 188                                                 }\r
 189                                         case MULTI_SPHERE_SHAPE_PROXYTYPE:\r
 190                                                 {\r
 191                                                         btMultiSphereShapeData* mss = (btMultiSphereShapeData*)bsd;\r
 192                                                         int numSpheres = mss->m_localPositionArraySize;\r
 193                                                         int i;\r
 194                                                         for ( i=0;i<numSpheres;i++)\r
 195                                                         {\r
 196                                                                 tmpPos[i].deSerializeFloat(mss->m_localPositionArrayPtr[i].m_pos);\r
 197                                                                 radii[i] = mss->m_localPositionArrayPtr[i].m_radius;\r
 198                                                         }\r
 199                                                         shape = new btMultiSphereShape(&tmpPos[0],&radii[0],numSpheres);\r
 200                                                         break;\r
 201                                                 }\r
 202                                         case CONVEX_HULL_SHAPE_PROXYTYPE:\r
 203                                                 {\r
 204                                                         btConvexHullShapeData* convexData = (btConvexHullShapeData*)bsd;\r
 205                                                         int numPoints = convexData->m_numUnscaledPoints;\r
 206 \r
 207                                                         btAlignedObjectArray<btVector3> tmpPoints;\r
 208                                                         tmpPoints.resize(numPoints);\r
 209                                                         int i;\r
 210                                                         for ( i=0;i<numPoints;i++)\r
 211                                                         {\r
 212                                                         if (convexData->m_unscaledPointsFloatPtr)\r
 213                                                                 tmpPoints[i].deSerialize(convexData->m_unscaledPointsFloatPtr[i]);\r
 214                                                         if (convexData->m_unscaledPointsDoublePtr)\r
 215                                                                 tmpPoints[i].deSerializeDouble(convexData->m_unscaledPointsDoublePtr[i]);\r
 216                                                         }\r
 217                                                         shape = createConvexHullShape();\r
 218 \r
 219                                                         return shape;\r
 220                                                         break;\r
 221                                                 }\r
 222 #endif\r
 223 \r
 224                                         default:\r
 225                                                 {\r
 226                                                         printf("error: cannot create shape type (%d)\n",shapeData->m_shapeType);\r
 227                                                 }\r
 228                                 }\r
 229 \r
 230                                 break;\r
 231                         }\r
 232 #if 0\r
 233                 case TRIANGLE_MESH_SHAPE_PROXYTYPE:\r
 234                 {\r
 235                         btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData;\r
 236                         btTriangleIndexVertexArray* meshInterface = createMeshInterface(trimesh->m_meshInterface);\r
 237                         if (!meshInterface->getNumSubParts())\r
 238                         {\r
 239                                 return 0;\r
 240                         }\r
 241 \r
 242                         btVector3 scaling; scaling.deSerializeFloat(trimesh->m_meshInterface.m_scaling);\r
 243                         meshInterface->setScaling(scaling);\r
 244 \r
 245 \r
 246                         btOptimizedBvh* bvh = 0;\r
 247 \r
 248                         btBvhTriangleMeshShape* trimeshShape = createBvhTriangleMeshShape(meshInterface,bvh);\r
 249                         trimeshShape->setMargin(trimesh->m_collisionMargin);\r
 250                         shape = trimeshShape;\r
 251 \r
 252                         if (trimesh->m_triangleInfoMap)\r
 253                         {\r
 254                                 btTriangleInfoMap* map = createTriangleInfoMap();\r
 255                                 map->deSerialize(*trimesh->m_triangleInfoMap);\r
 256                                 trimeshShape->setTriangleInfoMap(map);\r
 257 \r
 258 #ifdef USE_INTERNAL_EDGE_UTILITY\r
 259                                 gContactAddedCallback = btAdjustInternalEdgeContactsCallback;\r
 260 #endif //USE_INTERNAL_EDGE_UTILITY\r
 261 \r
 262                         }\r
 263 \r
 264                         //printf("trimesh->m_collisionMargin=%f\n",trimesh->m_collisionMargin);\r
 265                         break;\r
 266                 }\r
 267                 case COMPOUND_SHAPE_PROXYTYPE:\r
 268                         {\r
 269                                 btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData;\r
 270                                 btCompoundShape* compoundShape = createCompoundShape();\r
 271 \r
 272 \r
 273                                 btAlignedObjectArray<btCollisionShape*> childShapes;\r
 274                                 for (int i=0;i<compoundData->m_numChildShapes;i++)\r
 275                                 {\r
 276                                         btCollisionShape* childShape = convertCollisionShape(compoundData->m_childShapePtr[i].m_childShape);\r
 277                                         if (childShape)\r
 278                                         {\r
 279                                                 btTransform localTransform;\r
 280                                                 localTransform.deSerializeFloat(compoundData->m_childShapePtr[i].m_transform);\r
 281                                                 compoundShape->addChildShape(localTransform,childShape);\r
 282                                         } else\r
 283                                         {\r
 284                                                 printf("error: couldn't create childShape for compoundShape\n");\r
 285                                         }\r
 286                                         \r
 287                                 }\r
 288                                 shape = compoundShape;\r
 289 \r
 290                                 break;\r
 291                         }\r
 292 \r
 293                         case GIMPACT_SHAPE_PROXYTYPE:\r
 294                 {\r
 295                         btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*) shapeData;\r
 296                         if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE)\r
 297                         {\r
 298                                 btTriangleIndexVertexArray* meshInterface = createMeshInterface(gimpactData->m_meshInterface);\r
 299                                 btGImpactMeshShape* gimpactShape = createGimpactShape(meshInterface);\r
 300                                 btVector3 localScaling;\r
 301                                 localScaling.deSerializeFloat(gimpactData->m_localScaling);\r
 302                                 gimpactShape->setLocalScaling(localScaling);\r
 303                                 gimpactShape->setMargin(btScalar(gimpactData->m_collisionMargin));\r
 304                                 gimpactShape->updateBound();\r
 305                                 shape = gimpactShape;\r
 306                         } else\r
 307                         {\r
 308                                 printf("unsupported gimpact sub type\n");\r
 309                         }\r
 310                         break;\r
 311                 }\r
 312                 case SOFTBODY_SHAPE_PROXYTYPE:\r
 313                         {\r
 314                                 return 0;\r
 315                         }\r
 316 #endif \r
 317                 default:\r
 318                         {\r
 319                                 printf("unsupported shape type (%d)\n",shapeData->m_shapeType);\r
 320                         }\r
 321                 }\r
 322 \r
 323                 return shape;\r
 324         \r
 325 }\r
 326 \r
 327 void* btBulletDataExtractor::createBoxShape( const Bullet::btVector3FloatData& halfDimensions, const Bullet::btVector3FloatData& localScaling, float collisionMargin)\r
 328 {\r
 329         printf("createBoxShape with halfDimensions %f,%f,%f\n",halfDimensions.m_floats[0], halfDimensions.m_floats[1],halfDimensions.m_floats[2]);\r
 330         return 0;\r
 331 }\r
 332 \r
 333 void* btBulletDataExtractor::createSphereShape( float radius, const Bullet::btVector3FloatData& localScaling, float collisionMargin)\r
 334 {\r
 335         printf("createSphereShape with radius %f\n",radius);\r
 336         return 0;\r
 337 }\r
 338 \r
 339 \r
 340 void* btBulletDataExtractor::createPlaneShape( const btVector3FloatData& planeNormal, float planeConstant, const Bullet::btVector3FloatData& localScaling)\r
 341 {\r
 342         printf("createPlaneShape with normal %f,%f,%f and planeConstant\n",planeNormal.m_floats[0], planeNormal.m_floats[1],planeNormal.m_floats[2],planeConstant);\r
 343         return 0;\r
 344 }\r
 345 \r