Bullet Collision Detection & Physics Library: btBulletWorldImporter.cpp Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btBulletWorldImporter.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2012 Erwin Coumans http://bulletphysics.org
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 #include "btBulletWorldImporter.h"
18 #include "../BulletFileLoader/btBulletFile.h"
19
20 #include "btBulletDynamicsCommon.h"
21 #include "BulletCollision/Gimpact/btGImpactShape.h"
22
23
24
25 //#define USE_INTERNAL_EDGE_UTILITY
26 #ifdef USE_INTERNAL_EDGE_UTILITY
27 #include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h"
28 #endif //USE_INTERNAL_EDGE_UTILITY
29
30 btBulletWorldImporter::btBulletWorldImporter(btDynamicsWorld* world)
31 :btWorldImporter(world)
32 {
33 }
34
35 btBulletWorldImporter::~btBulletWorldImporter()
36 {
37 }
38
39
40 bool btBulletWorldImporter::loadFile( const char* fileName, const char* preSwapFilenameOut)
41 {
42 bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(fileName);
43
44
45 bool result = loadFileFromMemory(bulletFile2);
46 //now you could save the file in 'native' format using
47 //bulletFile2->writeFile("native.bullet");
48 if (result)
49 {
50 if (preSwapFilenameOut)
51 {
52 bulletFile2->preSwap();
53 bulletFile2->writeFile(preSwapFilenameOut);
54 }
55
56 }
57 delete bulletFile2;
58
59 return result;
60
61 }
62
63
64
65 bool btBulletWorldImporter::loadFileFromMemory( char* memoryBuffer, int len)
66 {
67 bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(memoryBuffer,len);
68
69 bool result = loadFileFromMemory(bulletFile2);
70
71 delete bulletFile2;
72
73 return result;
74 }
75
76
77
78
79 bool btBulletWorldImporter::loadFileFromMemory( bParse::btBulletFile* bulletFile2)
80 {
81 bool ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
82
83 if (ok)
84 bulletFile2->parse(m_verboseMode);
85 else
86 return false;
87
88 if (m_verboseMode & bParse::FD_VERBOSE_DUMP_CHUNKS)
89 {
90 bulletFile2->dumpChunks(bulletFile2->getFileDNA());
91 }
92
93 return convertAllObjects(bulletFile2);
94
95 }
96
97 bool btBulletWorldImporter::convertAllObjects( bParse::btBulletFile* bulletFile2)
98 {
99
100 m_shapeMap.clear();
101 m_bodyMap.clear();
102
103 int i;
104
105 for (i=0;i<bulletFile2->m_bvhs.size();i++)
106 {
107 btOptimizedBvh* bvh = createOptimizedBvh();
108
109 if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
110 {
111 btQuantizedBvhDoubleData* bvhData = (btQuantizedBvhDoubleData*)bulletFile2->m_bvhs[i];
112 bvh->deSerializeDouble(*bvhData);
113 } else
114 {
115 btQuantizedBvhFloatData* bvhData = (btQuantizedBvhFloatData*)bulletFile2->m_bvhs[i];
116 bvh->deSerializeFloat(*bvhData);
117 }
118 m_bvhMap.insert(bulletFile2->m_bvhs[i],bvh);
119 }
120
121
122
123
124
125 for (i=0;i<bulletFile2->m_collisionShapes.size();i++)
126 {
127 btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
128 btCollisionShape* shape = convertCollisionShape(shapeData);
129 if (shape)
130 {
131 // printf("shapeMap.insert(%x,%x)\n",shapeData,shape);
132 m_shapeMap.insert(shapeData,shape);
133 }
134
135 if (shape&& shapeData->m_name)
136 {
137 char* newname = duplicateName(shapeData->m_name);
138 m_objectNameMap.insert(shape,newname);
139 m_nameShapeMap.insert(newname,shape);
140 }
141 }
142
143
144
145
146
147 for (int i=0;i<bulletFile2->m_dynamicsWorldInfo.size();i++)
148 {
149 if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
150 {
151 btDynamicsWorldDoubleData* solverInfoData = (btDynamicsWorldDoubleData*)bulletFile2->m_dynamicsWorldInfo[i];
152 btContactSolverInfo solverInfo;
153
154 btVector3 gravity;
155 gravity.deSerializeDouble(solverInfoData->m_gravity);
156
157 solverInfo.m_tau = btScalar(solverInfoData->m_solverInfo.m_tau);
158 solverInfo.m_damping = btScalar(solverInfoData->m_solverInfo.m_damping);
159 solverInfo.m_friction = btScalar(solverInfoData->m_solverInfo.m_friction);
160 solverInfo.m_timeStep = btScalar(solverInfoData->m_solverInfo.m_timeStep);
161
162 solverInfo.m_restitution = btScalar(solverInfoData->m_solverInfo.m_restitution);
163 solverInfo.m_maxErrorReduction = btScalar(solverInfoData->m_solverInfo.m_maxErrorReduction);
164 solverInfo.m_sor = btScalar(solverInfoData->m_solverInfo.m_sor);
165 solverInfo.m_erp = btScalar(solverInfoData->m_solverInfo.m_erp);
166
167 solverInfo.m_erp2 = btScalar(solverInfoData->m_solverInfo.m_erp2);
168 solverInfo.m_globalCfm = btScalar(solverInfoData->m_solverInfo.m_globalCfm);
169 solverInfo.m_splitImpulsePenetrationThreshold = btScalar(solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold);
170 solverInfo.m_splitImpulseTurnErp = btScalar(solverInfoData->m_solverInfo.m_splitImpulseTurnErp);
171
172 solverInfo.m_linearSlop = btScalar(solverInfoData->m_solverInfo.m_linearSlop);
173 solverInfo.m_warmstartingFactor = btScalar(solverInfoData->m_solverInfo.m_warmstartingFactor);
174 solverInfo.m_maxGyroscopicForce = btScalar(solverInfoData->m_solverInfo.m_maxGyroscopicForce);
175 solverInfo.m_singleAxisRollingFrictionThreshold = btScalar(solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold);
176
177 solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
178 solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
179 solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
180 solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
181
182 solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
183
184 setDynamicsWorldInfo(gravity,solverInfo);
185 } else
186 {
187 btDynamicsWorldFloatData* solverInfoData = (btDynamicsWorldFloatData*)bulletFile2->m_dynamicsWorldInfo[i];
188 btContactSolverInfo solverInfo;
189
190 btVector3 gravity;
191 gravity.deSerializeFloat(solverInfoData->m_gravity);
192
193 solverInfo.m_tau = solverInfoData->m_solverInfo.m_tau;
194 solverInfo.m_damping = solverInfoData->m_solverInfo.m_damping;
195 solverInfo.m_friction = solverInfoData->m_solverInfo.m_friction;
196 solverInfo.m_timeStep = solverInfoData->m_solverInfo.m_timeStep;
197
198 solverInfo.m_restitution = solverInfoData->m_solverInfo.m_restitution;
199 solverInfo.m_maxErrorReduction = solverInfoData->m_solverInfo.m_maxErrorReduction;
200 solverInfo.m_sor = solverInfoData->m_solverInfo.m_sor;
201 solverInfo.m_erp = solverInfoData->m_solverInfo.m_erp;
202
203 solverInfo.m_erp2 = solverInfoData->m_solverInfo.m_erp2;
204 solverInfo.m_globalCfm = solverInfoData->m_solverInfo.m_globalCfm;
205 solverInfo.m_splitImpulsePenetrationThreshold = solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold;
206 solverInfo.m_splitImpulseTurnErp = solverInfoData->m_solverInfo.m_splitImpulseTurnErp;
207
208 solverInfo.m_linearSlop = solverInfoData->m_solverInfo.m_linearSlop;
209 solverInfo.m_warmstartingFactor = solverInfoData->m_solverInfo.m_warmstartingFactor;
210 solverInfo.m_maxGyroscopicForce = solverInfoData->m_solverInfo.m_maxGyroscopicForce;
211 solverInfo.m_singleAxisRollingFrictionThreshold = solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold;
212
213 solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
214 solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
215 solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
216 solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
217
218 solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
219
220 setDynamicsWorldInfo(gravity,solverInfo);
221 }
222 }
223
224
225 for (i=0;i<bulletFile2->m_rigidBodies.size();i++)
226 {
227 if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
228 {
229 btRigidBodyDoubleData* colObjData = (btRigidBodyDoubleData*)bulletFile2->m_rigidBodies[i];
230 convertRigidBodyDouble(colObjData);
231 } else
232 {
233 btRigidBodyFloatData* colObjData = (btRigidBodyFloatData*)bulletFile2->m_rigidBodies[i];
234 convertRigidBodyFloat(colObjData);
235 }
236
237
238 }
239
240 for (i=0;i<bulletFile2->m_collisionObjects.size();i++)
241 {
242 if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
243 {
244 btCollisionObjectDoubleData* colObjData = (btCollisionObjectDoubleData*)bulletFile2->m_collisionObjects[i];
245 btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
246 if (shapePtr && *shapePtr)
247 {
248 btTransform startTransform;
249 colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
250 startTransform.deSerializeDouble(colObjData->m_worldTransform);
251
252 btCollisionShape* shape = (btCollisionShape*)*shapePtr;
253 btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
254 body->setFriction(btScalar(colObjData->m_friction));
255 body->setRestitution(btScalar(colObjData->m_restitution));
256
257 #ifdef USE_INTERNAL_EDGE_UTILITY
258 if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
259 {
260 btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
261 if (trimesh->getTriangleInfoMap())
262 {
263 body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
264 }
265 }
266 #endif //USE_INTERNAL_EDGE_UTILITY
267 m_bodyMap.insert(colObjData,body);
268 } else
269 {
270 printf("error: no shape found\n");
271 }
272
273 } else
274 {
275 btCollisionObjectFloatData* colObjData = (btCollisionObjectFloatData*)bulletFile2->m_collisionObjects[i];
276 btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
277 if (shapePtr && *shapePtr)
278 {
279 btTransform startTransform;
280 colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
281 startTransform.deSerializeFloat(colObjData->m_worldTransform);
282
283 btCollisionShape* shape = (btCollisionShape*)*shapePtr;
284 btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
285
286 #ifdef USE_INTERNAL_EDGE_UTILITY
287 if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
288 {
289 btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
290 if (trimesh->getTriangleInfoMap())
291 {
292 body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
293 }
294 }
295 #endif //USE_INTERNAL_EDGE_UTILITY
296 m_bodyMap.insert(colObjData,body);
297 } else
298 {
299 printf("error: no shape found\n");
300 }
301 }
302
303 }
304
305
306 for (i=0;i<bulletFile2->m_constraints.size();i++)
307 {
308 btTypedConstraintData2* constraintData = (btTypedConstraintData2*)bulletFile2->m_constraints[i];
309 btTypedConstraintFloatData* singleC = (btTypedConstraintFloatData*)bulletFile2->m_constraints[i];
310 btTypedConstraintDoubleData* doubleC = (btTypedConstraintDoubleData*)bulletFile2->m_constraints[i];
311
312 btCollisionObject** colAptr = m_bodyMap.find(constraintData->m_rbA);
313 btCollisionObject** colBptr = m_bodyMap.find(constraintData->m_rbB);
314
315 btRigidBody* rbA = 0;
316 btRigidBody* rbB = 0;
317
318 if (colAptr)
319 {
320 rbA = btRigidBody::upcast(*colAptr);
321 if (!rbA)
322 rbA = &getFixedBody();
323 }
324 if (colBptr)
325 {
326 rbB = btRigidBody::upcast(*colBptr);
327 if (!rbB)
328 rbB = &getFixedBody();
329 }
330 if (!rbA && !rbB)
331 continue;
332
333 bool isDoublePrecisionData = (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)!=0;
334
335 if (isDoublePrecisionData)
336 {
337 if (bulletFile2->getVersion()>=282)
338 {
339 btTypedConstraintDoubleData* dc = (btTypedConstraintDoubleData*)constraintData;
340 convertConstraintDouble(dc, rbA,rbB, bulletFile2->getVersion());
341 } else
342 {
343 //double-precision constraints were messed up until 2.82, try to recover data...
344
345 btTypedConstraintData* oldData = (btTypedConstraintData*)constraintData;
346
347 convertConstraintBackwardsCompatible281(oldData, rbA,rbB, bulletFile2->getVersion());
348
349 }
350 }
351 else
352 {
353 btTypedConstraintFloatData* dc = (btTypedConstraintFloatData*)constraintData;
354 convertConstraintFloat(dc, rbA,rbB, bulletFile2->getVersion());
355 }
356
357
358 }
359
360 return true;
361 }
362
btHashMap::clear
void clear()
Definition: btHashMap.h:440
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:555
btRigidBody::upcast
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
Definition: btRigidBody.h:200
btContactSolverInfoDoubleData::m_timeStep
double m_timeStep
Definition: btContactSolverInfo.h:103
btDynamicsWorldDoubleData::m_gravity
btVector3DoubleData m_gravity
Definition: btDynamicsWorld.h:154
bParse::bFile::getVersion
int getVersion() const
Definition: bFile.h:153
btCollisionObjectFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionObject.h:548
btWorldImporter::convertConstraintBackwardsCompatible281
void convertConstraintBackwardsCompatible281(btTypedConstraintData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:528
btWorldImporter::convertCollisionShape
btCollisionShape * convertCollisionShape(btCollisionShapeData *shapeData)
Definition: btWorldImporter.cpp:148
btCollisionShape::getShapeType
int getShapeType() const
Definition: btCollisionShape.h:112
btTransform::deSerializeFloat
void deSerializeFloat(const struct btTransformFloatData &dataIn)
Definition: btTransform.h:286
btWorldImporter::convertRigidBodyDouble
void convertRigidBodyDouble(btRigidBodyDoubleData *colObjData)
Definition: btWorldImporter.cpp:2070
btWorldImporter
Definition: btWorldImporter.h:63
btVector3::deSerializeDouble
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
Definition: btVector3.h:1333
btBvhTriangleMeshShape::getTriangleInfoMap
const btTriangleInfoMap * getTriangleInfoMap() const
Definition: btBvhTriangleMeshShape.h:98
btContactSolverInfoDoubleData::m_damping
double m_damping
Definition: btContactSolverInfo.h:101
btInternalEdgeUtility.h
btWorldImporter::convertRigidBodyFloat
void convertRigidBodyFloat(btRigidBodyFloatData *colObjData)
Definition: btWorldImporter.cpp:2021
btContactSolverInfoFloatData::m_restingContactRestitutionThreshold
int m_restingContactRestitutionThreshold
Definition: btContactSolverInfo.h:150
btContactSolverInfoDoubleData::m_sor
double m_sor
Definition: btContactSolverInfo.h:106
btBulletDynamicsCommon.h
btQuantizedBvhFloatData
Definition: btQuantizedBvh.h:539
btContactSolverInfoDoubleData::m_warmstartingFactor
double m_warmstartingFactor
Definition: btContactSolverInfo.h:113
bParse::btBulletFile::m_constraints
btAlignedObjectArray< bStructHandle * > m_constraints
Definition: btBulletFile.h:49
btContactSolverInfoDoubleData::m_maxErrorReduction
double m_maxErrorReduction
Definition: btContactSolverInfo.h:105
btVector3DoubleData::m_floats
double m_floats[4]
Definition: btVector3.h:1308
btDynamicsWorldDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btDynamicsWorld.h:151
btContactSolverInfoFloatData::m_restitution
float m_restitution
Definition: btContactSolverInfo.h:133
btContactSolverInfoDoubleData::m_minimumSolverBatchSize
int m_minimumSolverBatchSize
Definition: btContactSolverInfo.h:120
btContactSolverInfoDoubleData::m_numIterations
int m_numIterations
Definition: btContactSolverInfo.h:117
btContactSolverInfoFloatData::m_minimumSolverBatchSize
int m_minimumSolverBatchSize
Definition: btContactSolverInfo.h:151
TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:55
bParse::btBulletFile
Definition: btBulletFile.h:31
btContactSolverInfoDoubleData::m_maxGyroscopicForce
double m_maxGyroscopicForce
Definition: btContactSolverInfo.h:114
btDynamicsWorld
The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc.
Definition: btDynamicsWorld.h:41
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:27
btGImpactShape.h
bParse::btBulletFile::m_collisionObjects
btAlignedObjectArray< bStructHandle * > m_collisionObjects
Definition: btBulletFile.h:45
btWorldImporter::m_nameShapeMap
btHashMap< btHashString, btCollisionShape * > m_nameShapeMap
Definition: btWorldImporter.h:91
btContactSolverInfoDoubleData::m_splitImpulse
int m_splitImpulse
Definition: btContactSolverInfo.h:121
btBulletWorldImporter::loadFile
bool loadFile(const char *fileName, const char *preSwapFilenameOut=0)
if you pass a valid preSwapFilenameOut, it will save a new file with a different endianness this pre-...
Definition: btBulletWorldImporter.cpp:40
btContactSolverInfoDoubleData::m_splitImpulseTurnErp
double m_splitImpulseTurnErp
Definition: btContactSolverInfo.h:111
btCollisionObjectDoubleData::m_name
char * m_name
Definition: btCollisionObject.h:520
btContactSolverInfoFloatData::m_linearSlop
float m_linearSlop
Definition: btContactSolverInfo.h:143
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:429
bParse::bFile::dumpChunks
void dumpChunks(bDNA *dna)
Definition: bFile.cpp:1528
btVector3FloatData::m_floats
float m_floats[4]
Definition: btVector3.h:1303
btContactSolverInfoFloatData::m_erp
float m_erp
Definition: btContactSolverInfo.h:136
bParse::bFile::getFileDNA
bDNA * getFileDNA()
Definition: bFile.h:119
btDynamicsWorldFloatData::m_gravity
btVector3FloatData m_gravity
Definition: btDynamicsWorld.h:161
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:291
btCollisionShapeData::m_name
char * m_name
Definition: btCollisionShape.h:157
btContactSolverInfoDoubleData::m_tau
double m_tau
Definition: btContactSolverInfo.h:100
btDynamicsWorldFloatData::m_solverInfo
btContactSolverInfoFloatData m_solverInfo
Definition: btDynamicsWorld.h:160
btContactSolverInfoFloatData::m_maxGyroscopicForce
float m_maxGyroscopicForce
Definition: btContactSolverInfo.h:145
btBvhTriangleMeshShape
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
Definition: btBvhTriangleMeshShape.h:34
btWorldImporter::m_verboseMode
int m_verboseMode
Definition: btWorldImporter.h:68
bParse::bFile::preSwap
void preSwap()
Definition: bFile.cpp:572
btCollisionObjectDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionObject.h:515
btCollisionObjectFloatData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:551
btContactSolverInfoFloatData::m_splitImpulseTurnErp
float m_splitImpulseTurnErp
Definition: btContactSolverInfo.h:141
btWorldImporter::m_bvhMap
btHashMap< btHashPtr, btOptimizedBvh * > m_bvhMap
Definition: btWorldImporter.h:88
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
bParse::btBulletFile::parse
virtual void parse(int verboseMode)
Definition: btBulletFile.cpp:298
bParse::FD_OK
Definition: bFile.h:29
btTransformFloatData::m_origin
btVector3FloatData m_origin
Definition: btTransform.h:256
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:300
btContactSolverInfoFloatData::m_solverMode
int m_solverMode
Definition: btContactSolverInfo.h:149
btRigidBodyDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btRigidBody.h:587
btContactSolverInfoFloatData::m_maxErrorReduction
float m_maxErrorReduction
Definition: btContactSolverInfo.h:134
btQuantizedBvh::deSerializeDouble
virtual void deSerializeDouble(struct btQuantizedBvhDoubleData &quantizedBvhDoubleData)
Definition: btQuantizedBvh.cpp:1236
btContactSolverInfoFloatData::m_globalCfm
float m_globalCfm
Definition: btContactSolverInfo.h:139
btWorldImporter::createOptimizedBvh
virtual btOptimizedBvh * createOptimizedBvh()
acceleration and connectivity structures
Definition: btWorldImporter.cpp:1759
btBulletWorldImporter::~btBulletWorldImporter
virtual ~btBulletWorldImporter()
Definition: btBulletWorldImporter.cpp:35
btWorldImporter::m_shapeMap
btHashMap< btHashPtr, btCollisionShape * > m_shapeMap
Definition: btWorldImporter.h:96
btContactSolverInfoDoubleData::m_globalCfm
double m_globalCfm
Definition: btContactSolverInfo.h:109
btCollisionObjectDoubleData::m_friction
double m_friction
Definition: btCollisionObject.h:529
btWorldImporter::duplicateName
char * duplicateName(const char *name)
Definition: btWorldImporter.cpp:514
btTypedConstraintDoubleData
Definition: btTypedConstraint.h:420
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btTypedConstraintData2
#define btTypedConstraintData2
Definition: btTypedConstraint.h:28
btHashMap::insert
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:269
btContactSolverInfoDoubleData::m_solverMode
int m_solverMode
Definition: btContactSolverInfo.h:118
btContactSolverInfoFloatData::m_tau
float m_tau
Definition: btContactSolverInfo.h:128
btContactSolverInfoDoubleData::m_friction
double m_friction
Definition: btContactSolverInfo.h:102
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btOptimizedBvh
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface.
Definition: btOptimizedBvh.h:27
btWorldImporter::createCollisionObject
virtual btCollisionObject * createCollisionObject(const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
Definition: btWorldImporter.cpp:1629
btRigidBodyFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btRigidBody.h:561
btTypedConstraintData
this structure is not used, except for loading pre-2.82 .bullet files
Definition: btTypedConstraint.h:397
btContactSolverInfoFloatData::m_damping
float m_damping
Definition: btContactSolverInfo.h:129
btWorldImporter::convertConstraintFloat
void convertConstraintFloat(btTypedConstraintFloatData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:749
bParse::FD_DOUBLE_PRECISION
Definition: bFile.h:35
bParse::bFile::writeFile
void writeFile(const char *fileName)
Definition: bFile.cpp:565
btContactSolverInfoFloatData::m_erp2
float m_erp2
Definition: btContactSolverInfo.h:138
btWorldImporter::setDynamicsWorldInfo
virtual void setDynamicsWorldInfo(const btVector3 &gravity, const btContactSolverInfo &solverInfo)
those virtuals are called by load and can be overridden by the user
Definition: btWorldImporter.cpp:1634
btDynamicsWorldDoubleData::m_solverInfo
btContactSolverInfoDoubleData m_solverInfo
Definition: btDynamicsWorld.h:153
btQuantizedBvhDoubleData
Definition: btQuantizedBvh.h:556
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btHashMap::find
const Value * find(const Key &key) const
Definition: btHashMap.h:402
btContactSolverInfoFloatData::m_numIterations
int m_numIterations
Definition: btContactSolverInfo.h:148
btContactSolverInfoDoubleData::m_erp2
double m_erp2
Definition: btContactSolverInfo.h:108
btContactSolverInfoFloatData::m_singleAxisRollingFrictionThreshold
float m_singleAxisRollingFrictionThreshold
Definition: btContactSolverInfo.h:146
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btContactSolverInfoDoubleData::m_linearSlop
double m_linearSlop
Definition: btContactSolverInfo.h:112
btBulletWorldImporter::convertAllObjects
virtual bool convertAllObjects(bParse::btBulletFile *file)
Definition: btBulletWorldImporter.cpp:97
btContactSolverInfo
Definition: btContactSolverInfo.h:65
btContactSolverInfoFloatData::m_timeStep
float m_timeStep
Definition: btContactSolverInfo.h:131
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:434
btContactSolverInfoFloatData::m_sor
float m_sor
Definition: btContactSolverInfo.h:135
btContactSolverInfoFloatData::m_splitImpulsePenetrationThreshold
float m_splitImpulsePenetrationThreshold
Definition: btContactSolverInfo.h:140
btCollisionObjectFloatData::m_name
char * m_name
Definition: btCollisionObject.h:553
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:522
bParse::btBulletFile::m_bvhs
btAlignedObjectArray< bStructHandle * > m_bvhs
Definition: btBulletFile.h:51
btQuantizedBvh::deSerializeFloat
virtual void deSerializeFloat(struct btQuantizedBvhFloatData &quantizedBvhFloatData)
Definition: btQuantizedBvh.cpp:1165
btContactSolverInfoDoubleData::m_restitution
double m_restitution
Definition: btContactSolverInfo.h:104
btWorldImporter::getFixedBody
static btRigidBody & getFixedBody()
Definition: btWorldImporter.cpp:1829
btContactSolverInfoDoubleData::m_singleAxisRollingFrictionThreshold
double m_singleAxisRollingFrictionThreshold
it is only used for 'explicit' version of gyroscopic force
Definition: btContactSolverInfo.h:115
btContactSolverInfoDoubleData::m_splitImpulsePenetrationThreshold
double m_splitImpulsePenetrationThreshold
Definition: btContactSolverInfo.h:110
bParse::btBulletFile::m_collisionShapes
btAlignedObjectArray< bStructHandle * > m_collisionShapes
Definition: btBulletFile.h:47
bParse::FD_VERBOSE_DUMP_CHUNKS
Definition: bFile.h:43
btContactSolverInfoFloatData::m_warmstartingFactor
float m_warmstartingFactor
Definition: btContactSolverInfo.h:144
btWorldImporter::m_bodyMap
btHashMap< btHashPtr, btCollisionObject * > m_bodyMap
Definition: btWorldImporter.h:97
btBulletWorldImporter::loadFileFromMemory
bool loadFileFromMemory(char *memoryBuffer, int len)
the memoryBuffer might be modified (for example if endian swaps are necessary)
Definition: btBulletWorldImporter.cpp:65
btDynamicsWorldFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btDynamicsWorld.h:158
btContactSolverInfoFloatData::m_splitImpulse
int m_splitImpulse
Definition: btContactSolverInfo.h:153
btCollisionObjectDoubleData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:518
bParse::btBulletFile::m_dynamicsWorldInfo
btAlignedObjectArray< bStructHandle * > m_dynamicsWorldInfo
Definition: btBulletFile.h:55
btVector3::deSerializeFloat
void deSerializeFloat(const struct btVector3FloatData &dataIn)
Definition: btVector3.h:1319
btTransform::deSerializeDouble
void deSerializeDouble(const struct btTransformDoubleData &dataIn)
Definition: btTransform.h:292
btCollisionObjectDoubleData::m_restitution
double m_restitution
Definition: btCollisionObject.h:531
btBulletWorldImporter::btBulletWorldImporter
btBulletWorldImporter(btDynamicsWorld *world=0)
Definition: btBulletWorldImporter.cpp:30
btWorldImporter::m_objectNameMap
btHashMap< btHashPtr, const char * > m_objectNameMap
Definition: btWorldImporter.h:94
btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK
Definition: btCollisionObject.h:127
bParse::btBulletFile::m_rigidBodies
btAlignedObjectArray< bStructHandle * > m_rigidBodies
Definition: btBulletFile.h:43
bParse::bFile::getFlags
int getFlags() const
Definition: bFile.h:126
btTransformDoubleData::m_origin
btVector3DoubleData m_origin
Definition: btTransform.h:262
btCollisionShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionShape.h:155
btContactSolverInfoDoubleData::m_restingContactRestitutionThreshold
int m_restingContactRestitutionThreshold
Definition: btContactSolverInfo.h:119
btBulletWorldImporter.h
btTypedConstraintFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btTypedConstraint.h:370
btContactSolverInfoDoubleData::m_erp
double m_erp
Definition: btContactSolverInfo.h:107
btWorldImporter::convertConstraintDouble
void convertConstraintDouble(btTypedConstraintDoubleData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:1077
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btContactSolverInfoFloatData::m_friction
float m_friction
Definition: btContactSolverInfo.h:130