mirror of
https://github.com/bulletphysics/bullet3
synced 2025-01-09 17:10:09 +00:00
ab8f16961e
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files. make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type. This commit contains no other changes aside from adding and applying clang-format-all.sh
340 lines
9.5 KiB
C++
340 lines
9.5 KiB
C++
|
|
#include "BulletDataExtractor.h"
|
|
#include "../BulletFileLoader/btBulletFile.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
///work-in-progress
|
|
///This ReadBulletSample is kept as simple as possible without dependencies to the Bullet SDK.
|
|
///It can be used to load .bullet data for other physics SDKs
|
|
///For a more complete example how to load and convert Bullet data using the Bullet SDK check out
|
|
///the Bullet/Demos/SerializeDemo and Bullet/Serialize/BulletWorldImporter
|
|
|
|
using namespace Bullet;
|
|
|
|
enum LocalBroadphaseNativeTypes
|
|
{
|
|
// polyhedral convex shapes
|
|
BOX_SHAPE_PROXYTYPE,
|
|
TRIANGLE_SHAPE_PROXYTYPE,
|
|
TETRAHEDRAL_SHAPE_PROXYTYPE,
|
|
CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
|
|
CONVEX_HULL_SHAPE_PROXYTYPE,
|
|
CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
|
|
CUSTOM_POLYHEDRAL_SHAPE_TYPE,
|
|
//implicit convex shapes
|
|
IMPLICIT_CONVEX_SHAPES_START_HERE,
|
|
SPHERE_SHAPE_PROXYTYPE,
|
|
MULTI_SPHERE_SHAPE_PROXYTYPE,
|
|
CAPSULE_SHAPE_PROXYTYPE,
|
|
CONE_SHAPE_PROXYTYPE,
|
|
CONVEX_SHAPE_PROXYTYPE,
|
|
CYLINDER_SHAPE_PROXYTYPE,
|
|
UNIFORM_SCALING_SHAPE_PROXYTYPE,
|
|
MINKOWSKI_SUM_SHAPE_PROXYTYPE,
|
|
MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
|
|
BOX_2D_SHAPE_PROXYTYPE,
|
|
CONVEX_2D_SHAPE_PROXYTYPE,
|
|
CUSTOM_CONVEX_SHAPE_TYPE,
|
|
//concave shapes
|
|
CONCAVE_SHAPES_START_HERE,
|
|
//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
|
|
TRIANGLE_MESH_SHAPE_PROXYTYPE,
|
|
SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
|
|
///used for demo integration FAST/Swift collision library and Bullet
|
|
FAST_CONCAVE_MESH_PROXYTYPE,
|
|
//terrain
|
|
TERRAIN_SHAPE_PROXYTYPE,
|
|
///Used for GIMPACT Trimesh integration
|
|
GIMPACT_SHAPE_PROXYTYPE,
|
|
///Multimaterial mesh
|
|
MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
|
|
|
|
EMPTY_SHAPE_PROXYTYPE,
|
|
STATIC_PLANE_PROXYTYPE,
|
|
CUSTOM_CONCAVE_SHAPE_TYPE,
|
|
CONCAVE_SHAPES_END_HERE,
|
|
|
|
COMPOUND_SHAPE_PROXYTYPE,
|
|
|
|
SOFTBODY_SHAPE_PROXYTYPE,
|
|
HFFLUID_SHAPE_PROXYTYPE,
|
|
HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
|
|
INVALID_SHAPE_PROXYTYPE,
|
|
|
|
MAX_BROADPHASE_COLLISION_TYPES
|
|
|
|
};
|
|
|
|
btBulletDataExtractor::btBulletDataExtractor()
|
|
{
|
|
}
|
|
|
|
btBulletDataExtractor::~btBulletDataExtractor()
|
|
{
|
|
}
|
|
|
|
void btBulletDataExtractor::convertAllObjects(bParse::btBulletFile* bulletFile2)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < bulletFile2->m_collisionShapes.size(); i++)
|
|
{
|
|
btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
|
|
if (shapeData->m_name)
|
|
printf("converting shape %s\n", shapeData->m_name);
|
|
void* shape = convertCollisionShape(shapeData);
|
|
}
|
|
}
|
|
|
|
void* btBulletDataExtractor::convertCollisionShape(btCollisionShapeData* shapeData)
|
|
{
|
|
void* shape = 0;
|
|
|
|
switch (shapeData->m_shapeType)
|
|
{
|
|
case STATIC_PLANE_PROXYTYPE:
|
|
{
|
|
btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)shapeData;
|
|
void* shape = createPlaneShape(planeData->m_planeNormal, planeData->m_planeConstant, planeData->m_localScaling);
|
|
break;
|
|
}
|
|
|
|
case CYLINDER_SHAPE_PROXYTYPE:
|
|
case CAPSULE_SHAPE_PROXYTYPE:
|
|
case BOX_SHAPE_PROXYTYPE:
|
|
case SPHERE_SHAPE_PROXYTYPE:
|
|
case MULTI_SPHERE_SHAPE_PROXYTYPE:
|
|
case CONVEX_HULL_SHAPE_PROXYTYPE:
|
|
{
|
|
btConvexInternalShapeData* bsd = (btConvexInternalShapeData*)shapeData;
|
|
|
|
switch (shapeData->m_shapeType)
|
|
{
|
|
case BOX_SHAPE_PROXYTYPE:
|
|
{
|
|
shape = createBoxShape(bsd->m_implicitShapeDimensions, bsd->m_localScaling, bsd->m_collisionMargin);
|
|
break;
|
|
}
|
|
case SPHERE_SHAPE_PROXYTYPE:
|
|
{
|
|
shape = createSphereShape(bsd->m_implicitShapeDimensions.m_floats[0], bsd->m_localScaling, bsd->m_collisionMargin);
|
|
break;
|
|
}
|
|
#if 0
|
|
case CAPSULE_SHAPE_PROXYTYPE:
|
|
{
|
|
btCapsuleShapeData* capData = (btCapsuleShapeData*)shapeData;
|
|
switch (capData->m_upAxis)
|
|
{
|
|
case 0:
|
|
{
|
|
shape = createCapsuleShapeX(implicitShapeDimensions.getY(),2*implicitShapeDimensions.getX());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
shape = createCapsuleShapeY(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getY());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape = createCapsuleShapeZ(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getZ());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
printf("error: wrong up axis for btCapsuleShape\n");
|
|
}
|
|
|
|
};
|
|
|
|
break;
|
|
}
|
|
case CYLINDER_SHAPE_PROXYTYPE:
|
|
{
|
|
btCylinderShapeData* cylData = (btCylinderShapeData*) shapeData;
|
|
btVector3 halfExtents = implicitShapeDimensions+margin;
|
|
switch (cylData->m_upAxis)
|
|
{
|
|
case 0:
|
|
{
|
|
shape = createCylinderShapeX(halfExtents.getY(),halfExtents.getX());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
shape = createCylinderShapeY(halfExtents.getX(),halfExtents.getY());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape = createCylinderShapeZ(halfExtents.getX(),halfExtents.getZ());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
printf("unknown Cylinder up axis\n");
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
break;
|
|
}
|
|
case MULTI_SPHERE_SHAPE_PROXYTYPE:
|
|
{
|
|
btMultiSphereShapeData* mss = (btMultiSphereShapeData*)bsd;
|
|
int numSpheres = mss->m_localPositionArraySize;
|
|
int i;
|
|
for ( i=0;i<numSpheres;i++)
|
|
{
|
|
tmpPos[i].deSerializeFloat(mss->m_localPositionArrayPtr[i].m_pos);
|
|
radii[i] = mss->m_localPositionArrayPtr[i].m_radius;
|
|
}
|
|
shape = new btMultiSphereShape(&tmpPos[0],&radii[0],numSpheres);
|
|
break;
|
|
}
|
|
case CONVEX_HULL_SHAPE_PROXYTYPE:
|
|
{
|
|
btConvexHullShapeData* convexData = (btConvexHullShapeData*)bsd;
|
|
int numPoints = convexData->m_numUnscaledPoints;
|
|
|
|
btAlignedObjectArray<btVector3> tmpPoints;
|
|
tmpPoints.resize(numPoints);
|
|
int i;
|
|
for ( i=0;i<numPoints;i++)
|
|
{
|
|
if (convexData->m_unscaledPointsFloatPtr)
|
|
tmpPoints[i].deSerialize(convexData->m_unscaledPointsFloatPtr[i]);
|
|
if (convexData->m_unscaledPointsDoublePtr)
|
|
tmpPoints[i].deSerializeDouble(convexData->m_unscaledPointsDoublePtr[i]);
|
|
}
|
|
shape = createConvexHullShape();
|
|
|
|
return shape;
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
{
|
|
printf("error: cannot create shape type (%d)\n", shapeData->m_shapeType);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
#if 0
|
|
case TRIANGLE_MESH_SHAPE_PROXYTYPE:
|
|
{
|
|
btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData;
|
|
btTriangleIndexVertexArray* meshInterface = createMeshInterface(trimesh->m_meshInterface);
|
|
if (!meshInterface->getNumSubParts())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
btVector3 scaling; scaling.deSerializeFloat(trimesh->m_meshInterface.m_scaling);
|
|
meshInterface->setScaling(scaling);
|
|
|
|
|
|
btOptimizedBvh* bvh = 0;
|
|
|
|
btBvhTriangleMeshShape* trimeshShape = createBvhTriangleMeshShape(meshInterface,bvh);
|
|
trimeshShape->setMargin(trimesh->m_collisionMargin);
|
|
shape = trimeshShape;
|
|
|
|
if (trimesh->m_triangleInfoMap)
|
|
{
|
|
btTriangleInfoMap* map = createTriangleInfoMap();
|
|
map->deSerialize(*trimesh->m_triangleInfoMap);
|
|
trimeshShape->setTriangleInfoMap(map);
|
|
|
|
#ifdef USE_INTERNAL_EDGE_UTILITY
|
|
gContactAddedCallback = btAdjustInternalEdgeContactsCallback;
|
|
#endif //USE_INTERNAL_EDGE_UTILITY
|
|
|
|
}
|
|
|
|
//printf("trimesh->m_collisionMargin=%f\n",trimesh->m_collisionMargin);
|
|
break;
|
|
}
|
|
case COMPOUND_SHAPE_PROXYTYPE:
|
|
{
|
|
btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData;
|
|
btCompoundShape* compoundShape = createCompoundShape();
|
|
|
|
|
|
btAlignedObjectArray<btCollisionShape*> childShapes;
|
|
for (int i=0;i<compoundData->m_numChildShapes;i++)
|
|
{
|
|
btCollisionShape* childShape = convertCollisionShape(compoundData->m_childShapePtr[i].m_childShape);
|
|
if (childShape)
|
|
{
|
|
btTransform localTransform;
|
|
localTransform.deSerializeFloat(compoundData->m_childShapePtr[i].m_transform);
|
|
compoundShape->addChildShape(localTransform,childShape);
|
|
} else
|
|
{
|
|
printf("error: couldn't create childShape for compoundShape\n");
|
|
}
|
|
|
|
}
|
|
shape = compoundShape;
|
|
|
|
break;
|
|
}
|
|
|
|
case GIMPACT_SHAPE_PROXYTYPE:
|
|
{
|
|
btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*) shapeData;
|
|
if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE)
|
|
{
|
|
btTriangleIndexVertexArray* meshInterface = createMeshInterface(gimpactData->m_meshInterface);
|
|
btGImpactMeshShape* gimpactShape = createGimpactShape(meshInterface);
|
|
btVector3 localScaling;
|
|
localScaling.deSerializeFloat(gimpactData->m_localScaling);
|
|
gimpactShape->setLocalScaling(localScaling);
|
|
gimpactShape->setMargin(btScalar(gimpactData->m_collisionMargin));
|
|
gimpactShape->updateBound();
|
|
shape = gimpactShape;
|
|
} else
|
|
{
|
|
printf("unsupported gimpact sub type\n");
|
|
}
|
|
break;
|
|
}
|
|
case SOFTBODY_SHAPE_PROXYTYPE:
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
default:
|
|
{
|
|
printf("unsupported shape type (%d)\n", shapeData->m_shapeType);
|
|
}
|
|
}
|
|
|
|
return shape;
|
|
}
|
|
|
|
void* btBulletDataExtractor::createBoxShape(const Bullet::btVector3FloatData& halfDimensions, const Bullet::btVector3FloatData& localScaling, float collisionMargin)
|
|
{
|
|
printf("createBoxShape with halfDimensions %f,%f,%f\n", halfDimensions.m_floats[0], halfDimensions.m_floats[1], halfDimensions.m_floats[2]);
|
|
return 0;
|
|
}
|
|
|
|
void* btBulletDataExtractor::createSphereShape(float radius, const Bullet::btVector3FloatData& localScaling, float collisionMargin)
|
|
{
|
|
printf("createSphereShape with radius %f\n", radius);
|
|
return 0;
|
|
}
|
|
|
|
void* btBulletDataExtractor::createPlaneShape(const btVector3FloatData& planeNormal, float planeConstant, const Bullet::btVector3FloatData& localScaling)
|
|
{
|
|
printf("createPlaneShape with normal %f,%f,%f and planeConstant\n", planeNormal.m_floats[0], planeNormal.m_floats[1], planeNormal.m_floats[2], planeConstant);
|
|
return 0;
|
|
}
|