Bullet Collision Detection & Physics Library
btWorldImporter.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2012 Erwin Coumans http://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#include "btWorldImporter.h"
17#include "btBulletDynamicsCommon.h"
18#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h"
19#ifdef USE_GIMPACT
20#include "BulletCollision/Gimpact/btGImpactShape.h"
21#endif
22btWorldImporter::btWorldImporter(btDynamicsWorld* world)
23 : m_dynamicsWorld(world),
24 m_verboseMode(0),
25 m_importerFlags(0)
26{
27}
28
29btWorldImporter::~btWorldImporter()
30{
31}
32
33void btWorldImporter::deleteAllData()
34{
35 int i;
36 for (i = 0; i < m_allocatedConstraints.size(); i++)
37 {
38 if (m_dynamicsWorld)
39 m_dynamicsWorld->removeConstraint(m_allocatedConstraints[i]);
40 delete m_allocatedConstraints[i];
41 }
42 m_allocatedConstraints.clear();
43
44 for (i = 0; i < m_allocatedRigidBodies.size(); i++)
45 {
46 if (m_dynamicsWorld)
47 m_dynamicsWorld->removeRigidBody(btRigidBody::upcast(m_allocatedRigidBodies[i]));
48 delete m_allocatedRigidBodies[i];
49 }
50
51 m_allocatedRigidBodies.clear();
52
53 for (i = 0; i < m_allocatedCollisionShapes.size(); i++)
54 {
55 delete m_allocatedCollisionShapes[i];
56 }
57 m_allocatedCollisionShapes.clear();
58
59 for (i = 0; i < m_allocatedBvhs.size(); i++)
60 {
61 delete m_allocatedBvhs[i];
62 }
63 m_allocatedBvhs.clear();
64
65 for (i = 0; i < m_allocatedTriangleInfoMaps.size(); i++)
66 {
67 delete m_allocatedTriangleInfoMaps[i];
68 }
69 m_allocatedTriangleInfoMaps.clear();
70 for (i = 0; i < m_allocatedTriangleIndexArrays.size(); i++)
71 {
72 delete m_allocatedTriangleIndexArrays[i];
73 }
74 m_allocatedTriangleIndexArrays.clear();
75 for (i = 0; i < m_allocatedNames.size(); i++)
76 {
77 delete[] m_allocatedNames[i];
78 }
79 m_allocatedNames.clear();
80
81 for (i = 0; i < m_allocatedbtStridingMeshInterfaceDatas.size(); i++)
82 {
83 btStridingMeshInterfaceData* curData = m_allocatedbtStridingMeshInterfaceDatas[i];
84
85 for (int a = 0; a < curData->m_numMeshParts; a++)
86 {
87 btMeshPartData* curPart = &curData->m_meshPartsPtr[a];
88 if (curPart->m_vertices3f)
89 delete[] curPart->m_vertices3f;
90
91 if (curPart->m_vertices3d)
92 delete[] curPart->m_vertices3d;
93
94 if (curPart->m_indices32)
95 delete[] curPart->m_indices32;
96
97 if (curPart->m_3indices16)
98 delete[] curPart->m_3indices16;
99
100 if (curPart->m_indices16)
101 delete[] curPart->m_indices16;
102
103 if (curPart->m_3indices8)
104 delete[] curPart->m_3indices8;
105 }
106 delete[] curData->m_meshPartsPtr;
107 delete curData;
108 }
109 m_allocatedbtStridingMeshInterfaceDatas.clear();
110
111 for (i = 0; i < m_indexArrays.size(); i++)
112 {
113 btAlignedFree(m_indexArrays[i]);
114 }
115 m_indexArrays.clear();
116
117 for (i = 0; i < m_shortIndexArrays.size(); i++)
118 {
119 btAlignedFree(m_shortIndexArrays[i]);
120 }
121 m_shortIndexArrays.clear();
122
123 for (i = 0; i < m_charIndexArrays.size(); i++)
124 {
125 btAlignedFree(m_charIndexArrays[i]);
126 }
127 m_charIndexArrays.clear();
128
129 for (i = 0; i < m_floatVertexArrays.size(); i++)
130 {
131 btAlignedFree(m_floatVertexArrays[i]);
132 }
133 m_floatVertexArrays.clear();
134
135 for (i = 0; i < m_doubleVertexArrays.size(); i++)
136 {
137 btAlignedFree(m_doubleVertexArrays[i]);
138 }
139 m_doubleVertexArrays.clear();
140}
141
142btCollisionShape* btWorldImporter::convertCollisionShape(btCollisionShapeData* shapeData)
143{
144 btCollisionShape* shape = 0;
145
146 switch (shapeData->m_shapeType)
147 {
148 case STATIC_PLANE_PROXYTYPE:
149 {
150 btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)shapeData;
151 btVector3 planeNormal, localScaling;
152 planeNormal.deSerializeFloat(planeData->m_planeNormal);
153 localScaling.deSerializeFloat(planeData->m_localScaling);
154 shape = createPlaneShape(planeNormal, planeData->m_planeConstant);
155 shape->setLocalScaling(localScaling);
156
157 break;
158 }
159 case SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE:
160 {
161 btScaledTriangleMeshShapeData* scaledMesh = (btScaledTriangleMeshShapeData*)shapeData;
162 btCollisionShapeData* colShapeData = (btCollisionShapeData*)&scaledMesh->m_trimeshShapeData;
163 colShapeData->m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE;
164 btCollisionShape* childShape = convertCollisionShape(colShapeData);
165 btBvhTriangleMeshShape* meshShape = (btBvhTriangleMeshShape*)childShape;
166 btVector3 localScaling;
167 localScaling.deSerializeFloat(scaledMesh->m_localScaling);
168
169 shape = createScaledTrangleMeshShape(meshShape, localScaling);
170 break;
171 }
172 case GIMPACT_SHAPE_PROXYTYPE:
173 {
174#ifdef USE_GIMPACT
175 btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*)shapeData;
176 if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE)
177 {
178 btStridingMeshInterfaceData* interfaceData = createStridingMeshInterfaceData(&gimpactData->m_meshInterface);
179 btTriangleIndexVertexArray* meshInterface = createMeshInterface(*interfaceData);
180
181 btGImpactMeshShape* gimpactShape = createGimpactShape(meshInterface);
182 btVector3 localScaling;
183 localScaling.deSerializeFloat(gimpactData->m_localScaling);
184 gimpactShape->setLocalScaling(localScaling);
185 gimpactShape->setMargin(btScalar(gimpactData->m_collisionMargin));
186 gimpactShape->updateBound();
187 shape = gimpactShape;
188 }
189 else
190 {
191 printf("unsupported gimpact sub type\n");
192 }
193#endif //USE_GIMPACT
194 break;
195 }
196 //The btCapsuleShape* API has issue passing the margin/scaling/halfextents unmodified through the API
197 //so deal with this
198 case CAPSULE_SHAPE_PROXYTYPE:
199 {
200 btCapsuleShapeData* capData = (btCapsuleShapeData*)shapeData;
201
202 switch (capData->m_upAxis)
203 {
204 case 0:
205 {
206 shape = createCapsuleShapeX(1, 1);
207 break;
208 }
209 case 1:
210 {
211 shape = createCapsuleShapeY(1, 1);
212 break;
213 }
214 case 2:
215 {
216 shape = createCapsuleShapeZ(1, 1);
217 break;
218 }
219 default:
220 {
221 printf("error: wrong up axis for btCapsuleShape\n");
222 }
223 };
224 if (shape)
225 {
226 btCapsuleShape* cap = (btCapsuleShape*)shape;
227 cap->deSerializeFloat(capData);
228 }
229 break;
230 }
231 case CYLINDER_SHAPE_PROXYTYPE:
232 case CONE_SHAPE_PROXYTYPE:
233 case BOX_SHAPE_PROXYTYPE:
234 case SPHERE_SHAPE_PROXYTYPE:
235 case MULTI_SPHERE_SHAPE_PROXYTYPE:
236 case CONVEX_HULL_SHAPE_PROXYTYPE:
237 {
238 btConvexInternalShapeData* bsd = (btConvexInternalShapeData*)shapeData;
239 btVector3 implicitShapeDimensions;
240 implicitShapeDimensions.deSerializeFloat(bsd->m_implicitShapeDimensions);
241 btVector3 localScaling;
242 localScaling.deSerializeFloat(bsd->m_localScaling);
243 btVector3 margin(bsd->m_collisionMargin, bsd->m_collisionMargin, bsd->m_collisionMargin);
244 switch (shapeData->m_shapeType)
245 {
246 case BOX_SHAPE_PROXYTYPE:
247 {
248 btBoxShape* box = (btBoxShape*)createBoxShape(implicitShapeDimensions / localScaling + margin);
249 //box->initializePolyhedralFeatures();
250 shape = box;
251
252 break;
253 }
254 case SPHERE_SHAPE_PROXYTYPE:
255 {
256 shape = createSphereShape(implicitShapeDimensions.getX());
257 break;
258 }
259
260 case CYLINDER_SHAPE_PROXYTYPE:
261 {
262 btCylinderShapeData* cylData = (btCylinderShapeData*)shapeData;
263 btVector3 halfExtents = implicitShapeDimensions + margin;
264 switch (cylData->m_upAxis)
265 {
266 case 0:
267 {
268 shape = createCylinderShapeX(halfExtents.getY(), halfExtents.getX());
269 break;
270 }
271 case 1:
272 {
273 shape = createCylinderShapeY(halfExtents.getX(), halfExtents.getY());
274 break;
275 }
276 case 2:
277 {
278 shape = createCylinderShapeZ(halfExtents.getX(), halfExtents.getZ());
279 break;
280 }
281 default:
282 {
283 printf("unknown Cylinder up axis\n");
284 }
285 };
286
287 break;
288 }
289 case CONE_SHAPE_PROXYTYPE:
290 {
291 btConeShapeData* conData = (btConeShapeData*)shapeData;
292 btVector3 halfExtents = implicitShapeDimensions; //+margin;
293 switch (conData->m_upIndex)
294 {
295 case 0:
296 {
297 shape = createConeShapeX(halfExtents.getY(), halfExtents.getX());
298 break;
299 }
300 case 1:
301 {
302 shape = createConeShapeY(halfExtents.getX(), halfExtents.getY());
303 break;
304 }
305 case 2:
306 {
307 shape = createConeShapeZ(halfExtents.getX(), halfExtents.getZ());
308 break;
309 }
310 default:
311 {
312 printf("unknown Cone up axis\n");
313 }
314 };
315
316 break;
317 }
318 case MULTI_SPHERE_SHAPE_PROXYTYPE:
319 {
320 btMultiSphereShapeData* mss = (btMultiSphereShapeData*)bsd;
321 int numSpheres = mss->m_localPositionArraySize;
322
323 btAlignedObjectArray<btVector3> tmpPos;
324 btAlignedObjectArray<btScalar> radii;
325 radii.resize(numSpheres);
326 tmpPos.resize(numSpheres);
327 int i;
328 for (i = 0; i < numSpheres; i++)
329 {
330 tmpPos[i].deSerializeFloat(mss->m_localPositionArrayPtr[i].m_pos);
331 radii[i] = mss->m_localPositionArrayPtr[i].m_radius;
332 }
333 shape = createMultiSphereShape(&tmpPos[0], &radii[0], numSpheres);
334 break;
335 }
336 case CONVEX_HULL_SHAPE_PROXYTYPE:
337 {
338 // int sz = sizeof(btConvexHullShapeData);
339 // int sz2 = sizeof(btConvexInternalShapeData);
340 // int sz3 = sizeof(btCollisionShapeData);
341 btConvexHullShapeData* convexData = (btConvexHullShapeData*)bsd;
342 int numPoints = convexData->m_numUnscaledPoints;
343
344 btAlignedObjectArray<btVector3> tmpPoints;
345 tmpPoints.resize(numPoints);
346 int i;
347 for (i = 0; i < numPoints; i++)
348 {
349#ifdef BT_USE_DOUBLE_PRECISION
350 if (convexData->m_unscaledPointsDoublePtr)
351 tmpPoints[i].deSerialize(convexData->m_unscaledPointsDoublePtr[i]);
352 if (convexData->m_unscaledPointsFloatPtr)
353 tmpPoints[i].deSerializeFloat(convexData->m_unscaledPointsFloatPtr[i]);
354#else
355 if (convexData->m_unscaledPointsFloatPtr)
356 tmpPoints[i].deSerialize(convexData->m_unscaledPointsFloatPtr[i]);
357 if (convexData->m_unscaledPointsDoublePtr)
358 tmpPoints[i].deSerializeDouble(convexData->m_unscaledPointsDoublePtr[i]);
359#endif //BT_USE_DOUBLE_PRECISION
360 }
361 btConvexHullShape* hullShape = createConvexHullShape();
362 for (i = 0; i < numPoints; i++)
363 {
364 hullShape->addPoint(tmpPoints[i]);
365 }
366 hullShape->setMargin(bsd->m_collisionMargin);
367 //hullShape->initializePolyhedralFeatures();
368 shape = hullShape;
369 break;
370 }
371 default:
372 {
373 printf("error: cannot create shape type (%d)\n", shapeData->m_shapeType);
374 }
375 }
376
377 if (shape)
378 {
379 shape->setMargin(bsd->m_collisionMargin);
380
381 btVector3 localScaling;
382 localScaling.deSerializeFloat(bsd->m_localScaling);
383 shape->setLocalScaling(localScaling);
384 }
385 break;
386 }
387 case TRIANGLE_MESH_SHAPE_PROXYTYPE:
388 {
389 btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData;
390 btStridingMeshInterfaceData* interfaceData = createStridingMeshInterfaceData(&trimesh->m_meshInterface);
391 btTriangleIndexVertexArray* meshInterface = createMeshInterface(*interfaceData);
392 if (!meshInterface->getNumSubParts())
393 {
394 return 0;
395 }
396
397 btVector3 scaling;
398 scaling.deSerializeFloat(trimesh->m_meshInterface.m_scaling);
399 meshInterface->setScaling(scaling);
400
401 btOptimizedBvh* bvh = 0;
402#if 1
403 if (trimesh->m_quantizedFloatBvh)
404 {
405 btOptimizedBvh** bvhPtr = m_bvhMap.find(trimesh->m_quantizedFloatBvh);
406 if (bvhPtr && *bvhPtr)
407 {
408 bvh = *bvhPtr;
409 }
410 else
411 {
412 bvh = createOptimizedBvh();
413 bvh->deSerializeFloat(*trimesh->m_quantizedFloatBvh);
414 }
415 }
416 if (trimesh->m_quantizedDoubleBvh)
417 {
418 btOptimizedBvh** bvhPtr = m_bvhMap.find(trimesh->m_quantizedDoubleBvh);
419 if (bvhPtr && *bvhPtr)
420 {
421 bvh = *bvhPtr;
422 }
423 else
424 {
425 bvh = createOptimizedBvh();
426 bvh->deSerializeDouble(*trimesh->m_quantizedDoubleBvh);
427 }
428 }
429#endif
430
431 btBvhTriangleMeshShape* trimeshShape = createBvhTriangleMeshShape(meshInterface, bvh);
432 trimeshShape->setMargin(trimesh->m_collisionMargin);
433 shape = trimeshShape;
434
435 if (trimesh->m_triangleInfoMap)
436 {
437 btTriangleInfoMap* map = createTriangleInfoMap();
438 map->deSerialize(*trimesh->m_triangleInfoMap);
439 trimeshShape->setTriangleInfoMap(map);
440
441#ifdef USE_INTERNAL_EDGE_UTILITY
442 gContactAddedCallback = btAdjustInternalEdgeContactsCallback;
443#endif //USE_INTERNAL_EDGE_UTILITY
444 }
445
446 //printf("trimesh->m_collisionMargin=%f\n",trimesh->m_collisionMargin);
447 break;
448 }
449 case COMPOUND_SHAPE_PROXYTYPE:
450 {
451 btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData;
452 btCompoundShape* compoundShape = createCompoundShape();
453
454 btAlignedObjectArray<btCollisionShape*> childShapes;
455 for (int i = 0; i < compoundData->m_numChildShapes; i++)
456 {
457 btCollisionShapeData* cd = compoundData->m_childShapePtr[i].m_childShape;
458
459 btCollisionShape* childShape = convertCollisionShape(cd);
460 if (childShape)
461 {
462 btTransform localTransform;
463 localTransform.deSerializeFloat(compoundData->m_childShapePtr[i].m_transform);
464 compoundShape->addChildShape(localTransform, childShape);
465 }
466 else
467 {
468#ifdef _DEBUG
469 printf("error: couldn't create childShape for compoundShape\n");
470#endif
471 }
472 }
473 shape = compoundShape;
474
475 break;
476 }
477 case SOFTBODY_SHAPE_PROXYTYPE:
478 {
479 return 0;
480 }
481 default:
482 {
483#ifdef _DEBUG
484 printf("unsupported shape type (%d)\n", shapeData->m_shapeType);
485#endif
486 }
487 }
488
489 return shape;
490}
491
492char* btWorldImporter::duplicateName(const char* name)
493{
494 if (name)
495 {
496 int l = (int)strlen(name);
497 char* newName = new char[l + 1];
498 memcpy(newName, name, l);
499 newName[l] = 0;
500 m_allocatedNames.push_back(newName);
501 return newName;
502 }
503 return 0;
504}
505
506void btWorldImporter::convertConstraintBackwardsCompatible281(btTypedConstraintData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion)
507{
508 btTypedConstraint* constraint = 0;
509
510 switch (constraintData->m_objectType)
511 {
512 case POINT2POINT_CONSTRAINT_TYPE:
513 {
514 btPoint2PointConstraintDoubleData* p2pData = (btPoint2PointConstraintDoubleData*)constraintData;
515 if (rbA && rbB)
516 {
517 btVector3 pivotInA, pivotInB;
518 pivotInA.deSerializeDouble(p2pData->m_pivotInA);
519 pivotInB.deSerializeDouble(p2pData->m_pivotInB);
520 constraint = createPoint2PointConstraint(*rbA, *rbB, pivotInA, pivotInB);
521 }
522 else
523 {
524 btVector3 pivotInA;
525 pivotInA.deSerializeDouble(p2pData->m_pivotInA);
526 constraint = createPoint2PointConstraint(*rbA, pivotInA);
527 }
528 break;
529 }
530 case HINGE_CONSTRAINT_TYPE:
531 {
532 btHingeConstraint* hinge = 0;
533
534 btHingeConstraintDoubleData* hingeData = (btHingeConstraintDoubleData*)constraintData;
535 if (rbA && rbB)
536 {
537 btTransform rbAFrame, rbBFrame;
538 rbAFrame.deSerializeDouble(hingeData->m_rbAFrame);
539 rbBFrame.deSerializeDouble(hingeData->m_rbBFrame);
540 hinge = createHingeConstraint(*rbA, *rbB, rbAFrame, rbBFrame, hingeData->m_useReferenceFrameA != 0);
541 }
542 else
543 {
544 btTransform rbAFrame;
545 rbAFrame.deSerializeDouble(hingeData->m_rbAFrame);
546 hinge = createHingeConstraint(*rbA, rbAFrame, hingeData->m_useReferenceFrameA != 0);
547 }
548 if (hingeData->m_enableAngularMotor)
549 {
550 hinge->enableAngularMotor(true, (btScalar)hingeData->m_motorTargetVelocity, (btScalar)hingeData->m_maxMotorImpulse);
551 }
552 hinge->setAngularOnly(hingeData->m_angularOnly != 0);
553 hinge->setLimit(btScalar(hingeData->m_lowerLimit), btScalar(hingeData->m_upperLimit), btScalar(hingeData->m_limitSoftness), btScalar(hingeData->m_biasFactor), btScalar(hingeData->m_relaxationFactor));
554
555 constraint = hinge;
556 break;
557 }
558 case CONETWIST_CONSTRAINT_TYPE:
559 {
560 btConeTwistConstraintData* coneData = (btConeTwistConstraintData*)constraintData;
561 btConeTwistConstraint* coneTwist = 0;
562
563 if (rbA && rbB)
564 {
565 btTransform rbAFrame, rbBFrame;
566 rbAFrame.deSerializeFloat(coneData->m_rbAFrame);
567 rbBFrame.deSerializeFloat(coneData->m_rbBFrame);
568 coneTwist = createConeTwistConstraint(*rbA, *rbB, rbAFrame, rbBFrame);
569 }
570 else
571 {
572 btTransform rbAFrame;
573 rbAFrame.deSerializeFloat(coneData->m_rbAFrame);
574 coneTwist = createConeTwistConstraint(*rbA, rbAFrame);
575 }
576 coneTwist->setLimit((btScalar)coneData->m_swingSpan1, (btScalar)coneData->m_swingSpan2, (btScalar)coneData->m_twistSpan, (btScalar)coneData->m_limitSoftness,
577 (btScalar)coneData->m_biasFactor, (btScalar)coneData->m_relaxationFactor);
578 coneTwist->setDamping((btScalar)coneData->m_damping);
579
580 constraint = coneTwist;
581 break;
582 }
583
584 case D6_SPRING_CONSTRAINT_TYPE:
585 {
586 btGeneric6DofSpringConstraintData* dofData = (btGeneric6DofSpringConstraintData*)constraintData;
587 // int sz = sizeof(btGeneric6DofSpringConstraintData);
588 btGeneric6DofSpringConstraint* dof = 0;
589
590 if (rbA && rbB)
591 {
592 btTransform rbAFrame, rbBFrame;
593 rbAFrame.deSerializeFloat(dofData->m_6dofData.m_rbAFrame);
594 rbBFrame.deSerializeFloat(dofData->m_6dofData.m_rbBFrame);
595 dof = createGeneric6DofSpringConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_6dofData.m_useLinearReferenceFrameA != 0);
596 }
597 else
598 {
599 printf("Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
600 }
601
602 if (dof)
603 {
604 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
605 angLowerLimit.deSerializeFloat(dofData->m_6dofData.m_angularLowerLimit);
606 angUpperLimit.deSerializeFloat(dofData->m_6dofData.m_angularUpperLimit);
607 linLowerLimit.deSerializeFloat(dofData->m_6dofData.m_linearLowerLimit);
608 linUpperlimit.deSerializeFloat(dofData->m_6dofData.m_linearUpperLimit);
609
610 angLowerLimit.setW(0.f);
611 dof->setAngularLowerLimit(angLowerLimit);
612 dof->setAngularUpperLimit(angUpperLimit);
613 dof->setLinearLowerLimit(linLowerLimit);
614 dof->setLinearUpperLimit(linUpperlimit);
615
616 int i;
617 if (fileVersion > 280)
618 {
619 for (i = 0; i < 6; i++)
620 {
621 dof->setStiffness(i, (btScalar)dofData->m_springStiffness[i]);
622 dof->setEquilibriumPoint(i, (btScalar)dofData->m_equilibriumPoint[i]);
623 dof->enableSpring(i, dofData->m_springEnabled[i] != 0);
624 dof->setDamping(i, (btScalar)dofData->m_springDamping[i]);
625 }
626 }
627 }
628
629 constraint = dof;
630 break;
631 }
632 case D6_CONSTRAINT_TYPE:
633 {
634 btGeneric6DofConstraintData* dofData = (btGeneric6DofConstraintData*)constraintData;
635 btGeneric6DofConstraint* dof = 0;
636
637 if (rbA && rbB)
638 {
639 btTransform rbAFrame, rbBFrame;
640 rbAFrame.deSerializeFloat(dofData->m_rbAFrame);
641 rbBFrame.deSerializeFloat(dofData->m_rbBFrame);
642 dof = createGeneric6DofConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
643 }
644 else
645 {
646 if (rbB)
647 {
648 btTransform rbBFrame;
649 rbBFrame.deSerializeFloat(dofData->m_rbBFrame);
650 dof = createGeneric6DofConstraint(*rbB, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
651 }
652 else
653 {
654 printf("Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
655 }
656 }
657
658 if (dof)
659 {
660 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
661 angLowerLimit.deSerializeFloat(dofData->m_angularLowerLimit);
662 angUpperLimit.deSerializeFloat(dofData->m_angularUpperLimit);
663 linLowerLimit.deSerializeFloat(dofData->m_linearLowerLimit);
664 linUpperlimit.deSerializeFloat(dofData->m_linearUpperLimit);
665
666 dof->setAngularLowerLimit(angLowerLimit);
667 dof->setAngularUpperLimit(angUpperLimit);
668 dof->setLinearLowerLimit(linLowerLimit);
669 dof->setLinearUpperLimit(linUpperlimit);
670 }
671
672 constraint = dof;
673 break;
674 }
675 case SLIDER_CONSTRAINT_TYPE:
676 {
677 btSliderConstraintData* sliderData = (btSliderConstraintData*)constraintData;
678 btSliderConstraint* slider = 0;
679 if (rbA && rbB)
680 {
681 btTransform rbAFrame, rbBFrame;
682 rbAFrame.deSerializeFloat(sliderData->m_rbAFrame);
683 rbBFrame.deSerializeFloat(sliderData->m_rbBFrame);
684 slider = createSliderConstraint(*rbA, *rbB, rbAFrame, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
685 }
686 else
687 {
688 btTransform rbBFrame;
689 rbBFrame.deSerializeFloat(sliderData->m_rbBFrame);
690 slider = createSliderConstraint(*rbB, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
691 }
692 slider->setLowerLinLimit((btScalar)sliderData->m_linearLowerLimit);
693 slider->setUpperLinLimit((btScalar)sliderData->m_linearUpperLimit);
694 slider->setLowerAngLimit((btScalar)sliderData->m_angularLowerLimit);
695 slider->setUpperAngLimit((btScalar)sliderData->m_angularUpperLimit);
696 slider->setUseFrameOffset(sliderData->m_useOffsetForConstraintFrame != 0);
697 constraint = slider;
698 break;
699 }
700
701 default:
702 {
703 printf("unknown constraint type\n");
704 }
705 };
706
707 if (constraint)
708 {
709 constraint->setDbgDrawSize((btScalar)constraintData->m_dbgDrawSize);
711 if (fileVersion >= 280)
712 {
713 constraint->setBreakingImpulseThreshold((btScalar)constraintData->m_breakingImpulseThreshold);
714 constraint->setEnabled(constraintData->m_isEnabled != 0);
715 constraint->setOverrideNumSolverIterations(constraintData->m_overrideNumSolverIterations);
716 }
717
718 if (constraintData->m_name)
719 {
720 char* newname = duplicateName(constraintData->m_name);
721 m_nameConstraintMap.insert(newname, constraint);
722 m_objectNameMap.insert(constraint, newname);
723 }
724 if (m_dynamicsWorld)
725 m_dynamicsWorld->addConstraint(constraint, constraintData->m_disableCollisionsBetweenLinkedBodies != 0);
726 }
727}
728
729void btWorldImporter::convertConstraintFloat(btTypedConstraintFloatData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion)
730{
731 btTypedConstraint* constraint = 0;
732
733 switch (constraintData->m_objectType)
734 {
735 case POINT2POINT_CONSTRAINT_TYPE:
736 {
737 btPoint2PointConstraintFloatData* p2pData = (btPoint2PointConstraintFloatData*)constraintData;
738 if (rbA && rbB)
739 {
740 btVector3 pivotInA, pivotInB;
741 pivotInA.deSerializeFloat(p2pData->m_pivotInA);
742 pivotInB.deSerializeFloat(p2pData->m_pivotInB);
743 constraint = createPoint2PointConstraint(*rbA, *rbB, pivotInA, pivotInB);
744 }
745 else
746 {
747 btVector3 pivotInA;
748 pivotInA.deSerializeFloat(p2pData->m_pivotInA);
749 constraint = createPoint2PointConstraint(*rbA, pivotInA);
750 }
751 break;
752 }
753 case HINGE_CONSTRAINT_TYPE:
754 {
755 btHingeConstraint* hinge = 0;
756 btHingeConstraintFloatData* hingeData = (btHingeConstraintFloatData*)constraintData;
757 if (rbA && rbB)
758 {
759 btTransform rbAFrame, rbBFrame;
760 rbAFrame.deSerializeFloat(hingeData->m_rbAFrame);
761 rbBFrame.deSerializeFloat(hingeData->m_rbBFrame);
762 hinge = createHingeConstraint(*rbA, *rbB, rbAFrame, rbBFrame, hingeData->m_useReferenceFrameA != 0);
763 }
764 else
765 {
766 btTransform rbAFrame;
767 rbAFrame.deSerializeFloat(hingeData->m_rbAFrame);
768 hinge = createHingeConstraint(*rbA, rbAFrame, hingeData->m_useReferenceFrameA != 0);
769 }
770 if (hingeData->m_enableAngularMotor)
771 {
772 hinge->enableAngularMotor(true, hingeData->m_motorTargetVelocity, hingeData->m_maxMotorImpulse);
773 }
774 hinge->setAngularOnly(hingeData->m_angularOnly != 0);
775 hinge->setLimit(btScalar(hingeData->m_lowerLimit), btScalar(hingeData->m_upperLimit), btScalar(hingeData->m_limitSoftness), btScalar(hingeData->m_biasFactor), btScalar(hingeData->m_relaxationFactor));
776
777 constraint = hinge;
778 break;
779 }
780 case CONETWIST_CONSTRAINT_TYPE:
781 {
782 btConeTwistConstraintData* coneData = (btConeTwistConstraintData*)constraintData;
783 btConeTwistConstraint* coneTwist = 0;
784
785 if (rbA && rbB)
786 {
787 btTransform rbAFrame, rbBFrame;
788 rbAFrame.deSerializeFloat(coneData->m_rbAFrame);
789 rbBFrame.deSerializeFloat(coneData->m_rbBFrame);
790 coneTwist = createConeTwistConstraint(*rbA, *rbB, rbAFrame, rbBFrame);
791 }
792 else
793 {
794 btTransform rbAFrame;
795 rbAFrame.deSerializeFloat(coneData->m_rbAFrame);
796 coneTwist = createConeTwistConstraint(*rbA, rbAFrame);
797 }
798 coneTwist->setLimit(coneData->m_swingSpan1, coneData->m_swingSpan2, coneData->m_twistSpan, coneData->m_limitSoftness, coneData->m_biasFactor, coneData->m_relaxationFactor);
799 coneTwist->setDamping(coneData->m_damping);
800
801 constraint = coneTwist;
802 break;
803 }
804
805 case D6_SPRING_CONSTRAINT_TYPE:
806 {
807 btGeneric6DofSpringConstraintData* dofData = (btGeneric6DofSpringConstraintData*)constraintData;
808 // int sz = sizeof(btGeneric6DofSpringConstraintData);
809 btGeneric6DofSpringConstraint* dof = 0;
810
811 if (rbA && rbB)
812 {
813 btTransform rbAFrame, rbBFrame;
814 rbAFrame.deSerializeFloat(dofData->m_6dofData.m_rbAFrame);
815 rbBFrame.deSerializeFloat(dofData->m_6dofData.m_rbBFrame);
816 dof = createGeneric6DofSpringConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_6dofData.m_useLinearReferenceFrameA != 0);
817 }
818 else
819 {
820 printf("Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
821 }
822
823 if (dof)
824 {
825 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
826 angLowerLimit.deSerializeFloat(dofData->m_6dofData.m_angularLowerLimit);
827 angUpperLimit.deSerializeFloat(dofData->m_6dofData.m_angularUpperLimit);
828 linLowerLimit.deSerializeFloat(dofData->m_6dofData.m_linearLowerLimit);
829 linUpperlimit.deSerializeFloat(dofData->m_6dofData.m_linearUpperLimit);
830
831 angLowerLimit.setW(0.f);
832 dof->setAngularLowerLimit(angLowerLimit);
833 dof->setAngularUpperLimit(angUpperLimit);
834 dof->setLinearLowerLimit(linLowerLimit);
835 dof->setLinearUpperLimit(linUpperlimit);
836
837 int i;
838 if (fileVersion > 280)
839 {
840 for (i = 0; i < 6; i++)
841 {
842 dof->setStiffness(i, dofData->m_springStiffness[i]);
843 dof->setEquilibriumPoint(i, dofData->m_equilibriumPoint[i]);
844 dof->enableSpring(i, dofData->m_springEnabled[i] != 0);
845 dof->setDamping(i, dofData->m_springDamping[i]);
846 }
847 }
848 }
849
850 constraint = dof;
851 break;
852 }
853 case D6_CONSTRAINT_TYPE:
854 {
855 btGeneric6DofConstraintData* dofData = (btGeneric6DofConstraintData*)constraintData;
856 btGeneric6DofConstraint* dof = 0;
857
858 if (rbA && rbB)
859 {
860 btTransform rbAFrame, rbBFrame;
861 rbAFrame.deSerializeFloat(dofData->m_rbAFrame);
862 rbBFrame.deSerializeFloat(dofData->m_rbBFrame);
863 dof = createGeneric6DofConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
864 }
865 else
866 {
867 if (rbB)
868 {
869 btTransform rbBFrame;
870 rbBFrame.deSerializeFloat(dofData->m_rbBFrame);
871 dof = createGeneric6DofConstraint(*rbB, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
872 }
873 else
874 {
875 printf("Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
876 }
877 }
878
879 if (dof)
880 {
881 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
882 angLowerLimit.deSerializeFloat(dofData->m_angularLowerLimit);
883 angUpperLimit.deSerializeFloat(dofData->m_angularUpperLimit);
884 linLowerLimit.deSerializeFloat(dofData->m_linearLowerLimit);
885 linUpperlimit.deSerializeFloat(dofData->m_linearUpperLimit);
886
887 dof->setAngularLowerLimit(angLowerLimit);
888 dof->setAngularUpperLimit(angUpperLimit);
889 dof->setLinearLowerLimit(linLowerLimit);
890 dof->setLinearUpperLimit(linUpperlimit);
891 }
892
893 constraint = dof;
894 break;
895 }
896 case SLIDER_CONSTRAINT_TYPE:
897 {
898 btSliderConstraintData* sliderData = (btSliderConstraintData*)constraintData;
899 btSliderConstraint* slider = 0;
900 if (rbA && rbB)
901 {
902 btTransform rbAFrame, rbBFrame;
903 rbAFrame.deSerializeFloat(sliderData->m_rbAFrame);
904 rbBFrame.deSerializeFloat(sliderData->m_rbBFrame);
905 slider = createSliderConstraint(*rbA, *rbB, rbAFrame, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
906 }
907 else
908 {
909 btTransform rbBFrame;
910 rbBFrame.deSerializeFloat(sliderData->m_rbBFrame);
911 slider = createSliderConstraint(*rbB, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
912 }
913 slider->setLowerLinLimit(sliderData->m_linearLowerLimit);
914 slider->setUpperLinLimit(sliderData->m_linearUpperLimit);
915 slider->setLowerAngLimit(sliderData->m_angularLowerLimit);
916 slider->setUpperAngLimit(sliderData->m_angularUpperLimit);
917 slider->setUseFrameOffset(sliderData->m_useOffsetForConstraintFrame != 0);
918 constraint = slider;
919 break;
920 }
921 case GEAR_CONSTRAINT_TYPE:
922 {
923 btGearConstraintFloatData* gearData = (btGearConstraintFloatData*)constraintData;
924 btGearConstraint* gear = 0;
925 if (rbA && rbB)
926 {
927 btVector3 axisInA, axisInB;
928 axisInA.deSerializeFloat(gearData->m_axisInA);
929 axisInB.deSerializeFloat(gearData->m_axisInB);
930 gear = createGearConstraint(*rbA, *rbB, axisInA, axisInB, gearData->m_ratio);
931 }
932 else
933 {
934 btAssert(0);
935 //perhaps a gear against a 'fixed' body, while the 'fixed' body is not serialized?
936 //btGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA,const btVector3& axisInB, btScalar ratio=1.f);
937 }
938 constraint = gear;
939 break;
940 }
941 case D6_SPRING_2_CONSTRAINT_TYPE:
942 {
943 btGeneric6DofSpring2ConstraintData* dofData = (btGeneric6DofSpring2ConstraintData*)constraintData;
944
945 btGeneric6DofSpring2Constraint* dof = 0;
946
947 if (rbA && rbB)
948 {
949 btTransform rbAFrame, rbBFrame;
950 rbAFrame.deSerializeFloat(dofData->m_rbAFrame);
951 rbBFrame.deSerializeFloat(dofData->m_rbBFrame);
952 dof = createGeneric6DofSpring2Constraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_rotateOrder);
953 }
954 else
955 {
956 printf("Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
957 }
958
959 if (dof)
960 {
961 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
962 angLowerLimit.deSerializeFloat(dofData->m_angularLowerLimit);
963 angUpperLimit.deSerializeFloat(dofData->m_angularUpperLimit);
964 linLowerLimit.deSerializeFloat(dofData->m_linearLowerLimit);
965 linUpperlimit.deSerializeFloat(dofData->m_linearUpperLimit);
966
967 angLowerLimit.setW(0.f);
968 dof->setAngularLowerLimit(angLowerLimit);
969 dof->setAngularUpperLimit(angUpperLimit);
970 dof->setLinearLowerLimit(linLowerLimit);
971 dof->setLinearUpperLimit(linUpperlimit);
972
973 int i;
974 if (fileVersion > 280)
975 {
976 //6-dof: 3 linear followed by 3 angular
977 for (i = 0; i < 3; i++)
978 {
979 dof->setStiffness(i, dofData->m_linearSpringStiffness.m_floats[i], dofData->m_linearSpringStiffnessLimited[i] != 0);
980 dof->setEquilibriumPoint(i, dofData->m_linearEquilibriumPoint.m_floats[i]);
981 dof->enableSpring(i, dofData->m_linearEnableSpring[i] != 0);
982 dof->setDamping(i, dofData->m_linearSpringDamping.m_floats[i], (dofData->m_linearSpringDampingLimited[i] != 0));
983 }
984 for (i = 0; i < 3; i++)
985 {
986 dof->setStiffness(i + 3, dofData->m_angularSpringStiffness.m_floats[i], (dofData->m_angularSpringStiffnessLimited[i] != 0));
987 dof->setEquilibriumPoint(i + 3, dofData->m_angularEquilibriumPoint.m_floats[i]);
988 dof->enableSpring(i + 3, dofData->m_angularEnableSpring[i] != 0);
989 dof->setDamping(i + 3, dofData->m_angularSpringDamping.m_floats[i], dofData->m_angularSpringDampingLimited[i]);
990 }
991 }
992 }
993
994 constraint = dof;
995 break;
996 }
997 case FIXED_CONSTRAINT_TYPE:
998 {
999 btGeneric6DofSpring2Constraint* dof = 0;
1000 if (rbA && rbB)
1001 {
1002 btTransform rbAFrame, rbBFrame;
1003 //compute a shared world frame, and compute frameInA, frameInB relative to this
1004 btTransform sharedFrame;
1005 sharedFrame.setIdentity();
1006 btVector3 centerPos = btScalar(0.5) * (rbA->getWorldTransform().getOrigin() +
1007 rbB->getWorldTransform().getOrigin());
1008 sharedFrame.setOrigin(centerPos);
1009 rbAFrame = rbA->getWorldTransform().inverse() * sharedFrame;
1010 rbBFrame = rbB->getWorldTransform().inverse() * sharedFrame;
1011
1012 dof = createGeneric6DofSpring2Constraint(*rbA, *rbB, rbAFrame, rbBFrame, RO_XYZ);
1013 dof->setLinearUpperLimit(btVector3(0, 0, 0));
1014 dof->setLinearLowerLimit(btVector3(0, 0, 0));
1015 dof->setAngularUpperLimit(btVector3(0, 0, 0));
1016 dof->setAngularLowerLimit(btVector3(0, 0, 0));
1017 }
1018 else
1019 {
1020 printf("Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1021 }
1022
1023 constraint = dof;
1024 break;
1025 }
1026 default:
1027 {
1028 printf("unknown constraint type\n");
1029 }
1030 };
1031
1032 if (constraint)
1033 {
1034 constraint->setDbgDrawSize(constraintData->m_dbgDrawSize);
1036 if (fileVersion >= 280)
1037 {
1038 constraint->setBreakingImpulseThreshold(constraintData->m_breakingImpulseThreshold);
1039 constraint->setEnabled(constraintData->m_isEnabled != 0);
1040 constraint->setOverrideNumSolverIterations(constraintData->m_overrideNumSolverIterations);
1041 }
1042
1043 if (constraintData->m_name)
1044 {
1045 char* newname = duplicateName(constraintData->m_name);
1046 m_nameConstraintMap.insert(newname, constraint);
1047 m_objectNameMap.insert(constraint, newname);
1048 }
1049 if (m_dynamicsWorld)
1050 m_dynamicsWorld->addConstraint(constraint, constraintData->m_disableCollisionsBetweenLinkedBodies != 0);
1051 }
1052}
1053
1054void btWorldImporter::convertConstraintDouble(btTypedConstraintDoubleData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion)
1055{
1056 btTypedConstraint* constraint = 0;
1057
1058 switch (constraintData->m_objectType)
1059 {
1060 case POINT2POINT_CONSTRAINT_TYPE:
1061 {
1062 btPoint2PointConstraintDoubleData2* p2pData = (btPoint2PointConstraintDoubleData2*)constraintData;
1063 if (rbA && rbB)
1064 {
1065 btVector3 pivotInA, pivotInB;
1066 pivotInA.deSerializeDouble(p2pData->m_pivotInA);
1067 pivotInB.deSerializeDouble(p2pData->m_pivotInB);
1068 constraint = createPoint2PointConstraint(*rbA, *rbB, pivotInA, pivotInB);
1069 }
1070 else
1071 {
1072 btVector3 pivotInA;
1073 pivotInA.deSerializeDouble(p2pData->m_pivotInA);
1074 constraint = createPoint2PointConstraint(*rbA, pivotInA);
1075 }
1076 break;
1077 }
1078 case HINGE_CONSTRAINT_TYPE:
1079 {
1080 btHingeConstraint* hinge = 0;
1081
1082 btHingeConstraintDoubleData2* hingeData = (btHingeConstraintDoubleData2*)constraintData;
1083 if (rbA && rbB)
1084 {
1085 btTransform rbAFrame, rbBFrame;
1086 rbAFrame.deSerializeDouble(hingeData->m_rbAFrame);
1087 rbBFrame.deSerializeDouble(hingeData->m_rbBFrame);
1088 hinge = createHingeConstraint(*rbA, *rbB, rbAFrame, rbBFrame, hingeData->m_useReferenceFrameA != 0);
1089 }
1090 else
1091 {
1092 btTransform rbAFrame;
1093 rbAFrame.deSerializeDouble(hingeData->m_rbAFrame);
1094 hinge = createHingeConstraint(*rbA, rbAFrame, hingeData->m_useReferenceFrameA != 0);
1095 }
1096 if (hingeData->m_enableAngularMotor)
1097 {
1098 hinge->enableAngularMotor(true, (btScalar)hingeData->m_motorTargetVelocity, (btScalar)hingeData->m_maxMotorImpulse);
1099 }
1100 hinge->setAngularOnly(hingeData->m_angularOnly != 0);
1101 hinge->setLimit(btScalar(hingeData->m_lowerLimit), btScalar(hingeData->m_upperLimit), btScalar(hingeData->m_limitSoftness), btScalar(hingeData->m_biasFactor), btScalar(hingeData->m_relaxationFactor));
1102
1103 constraint = hinge;
1104 break;
1105 }
1106 case CONETWIST_CONSTRAINT_TYPE:
1107 {
1108 btConeTwistConstraintDoubleData* coneData = (btConeTwistConstraintDoubleData*)constraintData;
1109 btConeTwistConstraint* coneTwist = 0;
1110
1111 if (rbA && rbB)
1112 {
1113 btTransform rbAFrame, rbBFrame;
1114 rbAFrame.deSerializeDouble(coneData->m_rbAFrame);
1115 rbBFrame.deSerializeDouble(coneData->m_rbBFrame);
1116 coneTwist = createConeTwistConstraint(*rbA, *rbB, rbAFrame, rbBFrame);
1117 }
1118 else
1119 {
1120 btTransform rbAFrame;
1121 rbAFrame.deSerializeDouble(coneData->m_rbAFrame);
1122 coneTwist = createConeTwistConstraint(*rbA, rbAFrame);
1123 }
1124 coneTwist->setLimit((btScalar)coneData->m_swingSpan1, (btScalar)coneData->m_swingSpan2, (btScalar)coneData->m_twistSpan, (btScalar)coneData->m_limitSoftness,
1125 (btScalar)coneData->m_biasFactor, (btScalar)coneData->m_relaxationFactor);
1126 coneTwist->setDamping((btScalar)coneData->m_damping);
1127
1128 constraint = coneTwist;
1129 break;
1130 }
1131
1132 case D6_SPRING_CONSTRAINT_TYPE:
1133 {
1134 btGeneric6DofSpringConstraintDoubleData2* dofData = (btGeneric6DofSpringConstraintDoubleData2*)constraintData;
1135 // int sz = sizeof(btGeneric6DofSpringConstraintData);
1136 btGeneric6DofSpringConstraint* dof = 0;
1137
1138 if (rbA && rbB)
1139 {
1140 btTransform rbAFrame, rbBFrame;
1141 rbAFrame.deSerializeDouble(dofData->m_6dofData.m_rbAFrame);
1142 rbBFrame.deSerializeDouble(dofData->m_6dofData.m_rbBFrame);
1143 dof = createGeneric6DofSpringConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_6dofData.m_useLinearReferenceFrameA != 0);
1144 }
1145 else
1146 {
1147 printf("Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
1148 }
1149
1150 if (dof)
1151 {
1152 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1153 angLowerLimit.deSerializeDouble(dofData->m_6dofData.m_angularLowerLimit);
1154 angUpperLimit.deSerializeDouble(dofData->m_6dofData.m_angularUpperLimit);
1155 linLowerLimit.deSerializeDouble(dofData->m_6dofData.m_linearLowerLimit);
1156 linUpperlimit.deSerializeDouble(dofData->m_6dofData.m_linearUpperLimit);
1157
1158 angLowerLimit.setW(0.f);
1159 dof->setAngularLowerLimit(angLowerLimit);
1160 dof->setAngularUpperLimit(angUpperLimit);
1161 dof->setLinearLowerLimit(linLowerLimit);
1162 dof->setLinearUpperLimit(linUpperlimit);
1163
1164 int i;
1165 if (fileVersion > 280)
1166 {
1167 for (i = 0; i < 6; i++)
1168 {
1169 dof->setStiffness(i, (btScalar)dofData->m_springStiffness[i]);
1170 dof->setEquilibriumPoint(i, (btScalar)dofData->m_equilibriumPoint[i]);
1171 dof->enableSpring(i, dofData->m_springEnabled[i] != 0);
1172 dof->setDamping(i, (btScalar)dofData->m_springDamping[i]);
1173 }
1174 }
1175 }
1176
1177 constraint = dof;
1178 break;
1179 }
1180 case D6_CONSTRAINT_TYPE:
1181 {
1182 btGeneric6DofConstraintDoubleData2* dofData = (btGeneric6DofConstraintDoubleData2*)constraintData;
1183 btGeneric6DofConstraint* dof = 0;
1184
1185 if (rbA && rbB)
1186 {
1187 btTransform rbAFrame, rbBFrame;
1188 rbAFrame.deSerializeDouble(dofData->m_rbAFrame);
1189 rbBFrame.deSerializeDouble(dofData->m_rbBFrame);
1190 dof = createGeneric6DofConstraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
1191 }
1192 else
1193 {
1194 if (rbB)
1195 {
1196 btTransform rbBFrame;
1197 rbBFrame.deSerializeDouble(dofData->m_rbBFrame);
1198 dof = createGeneric6DofConstraint(*rbB, rbBFrame, dofData->m_useLinearReferenceFrameA != 0);
1199 }
1200 else
1201 {
1202 printf("Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
1203 }
1204 }
1205
1206 if (dof)
1207 {
1208 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1209 angLowerLimit.deSerializeDouble(dofData->m_angularLowerLimit);
1210 angUpperLimit.deSerializeDouble(dofData->m_angularUpperLimit);
1211 linLowerLimit.deSerializeDouble(dofData->m_linearLowerLimit);
1212 linUpperlimit.deSerializeDouble(dofData->m_linearUpperLimit);
1213
1214 dof->setAngularLowerLimit(angLowerLimit);
1215 dof->setAngularUpperLimit(angUpperLimit);
1216 dof->setLinearLowerLimit(linLowerLimit);
1217 dof->setLinearUpperLimit(linUpperlimit);
1218 }
1219
1220 constraint = dof;
1221 break;
1222 }
1223 case SLIDER_CONSTRAINT_TYPE:
1224 {
1225 btSliderConstraintDoubleData* sliderData = (btSliderConstraintDoubleData*)constraintData;
1226 btSliderConstraint* slider = 0;
1227 if (rbA && rbB)
1228 {
1229 btTransform rbAFrame, rbBFrame;
1230 rbAFrame.deSerializeDouble(sliderData->m_rbAFrame);
1231 rbBFrame.deSerializeDouble(sliderData->m_rbBFrame);
1232 slider = createSliderConstraint(*rbA, *rbB, rbAFrame, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
1233 }
1234 else
1235 {
1236 btTransform rbBFrame;
1237 rbBFrame.deSerializeDouble(sliderData->m_rbBFrame);
1238 slider = createSliderConstraint(*rbB, rbBFrame, sliderData->m_useLinearReferenceFrameA != 0);
1239 }
1240 slider->setLowerLinLimit((btScalar)sliderData->m_linearLowerLimit);
1241 slider->setUpperLinLimit((btScalar)sliderData->m_linearUpperLimit);
1242 slider->setLowerAngLimit((btScalar)sliderData->m_angularLowerLimit);
1243 slider->setUpperAngLimit((btScalar)sliderData->m_angularUpperLimit);
1244 slider->setUseFrameOffset(sliderData->m_useOffsetForConstraintFrame != 0);
1245 constraint = slider;
1246 break;
1247 }
1248 case GEAR_CONSTRAINT_TYPE:
1249 {
1250 btGearConstraintDoubleData* gearData = (btGearConstraintDoubleData*)constraintData;
1251 btGearConstraint* gear = 0;
1252 if (rbA && rbB)
1253 {
1254 btVector3 axisInA, axisInB;
1255 axisInA.deSerializeDouble(gearData->m_axisInA);
1256 axisInB.deSerializeDouble(gearData->m_axisInB);
1257 gear = createGearConstraint(*rbA, *rbB, axisInA, axisInB, gearData->m_ratio);
1258 }
1259 else
1260 {
1261 btAssert(0);
1262 //perhaps a gear against a 'fixed' body, while the 'fixed' body is not serialized?
1263 //btGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA,const btVector3& axisInB, btScalar ratio=1.f);
1264 }
1265 constraint = gear;
1266 break;
1267 }
1268
1269 case D6_SPRING_2_CONSTRAINT_TYPE:
1270 {
1271 btGeneric6DofSpring2ConstraintDoubleData2* dofData = (btGeneric6DofSpring2ConstraintDoubleData2*)constraintData;
1272
1273 btGeneric6DofSpring2Constraint* dof = 0;
1274
1275 if (rbA && rbB)
1276 {
1277 btTransform rbAFrame, rbBFrame;
1278 rbAFrame.deSerializeDouble(dofData->m_rbAFrame);
1279 rbBFrame.deSerializeDouble(dofData->m_rbBFrame);
1280 dof = createGeneric6DofSpring2Constraint(*rbA, *rbB, rbAFrame, rbBFrame, dofData->m_rotateOrder);
1281 }
1282 else
1283 {
1284 printf("Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1285 }
1286
1287 if (dof)
1288 {
1289 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1290 angLowerLimit.deSerializeDouble(dofData->m_angularLowerLimit);
1291 angUpperLimit.deSerializeDouble(dofData->m_angularUpperLimit);
1292 linLowerLimit.deSerializeDouble(dofData->m_linearLowerLimit);
1293 linUpperlimit.deSerializeDouble(dofData->m_linearUpperLimit);
1294
1295 angLowerLimit.setW(0.f);
1296 dof->setAngularLowerLimit(angLowerLimit);
1297 dof->setAngularUpperLimit(angUpperLimit);
1298 dof->setLinearLowerLimit(linLowerLimit);
1299 dof->setLinearUpperLimit(linUpperlimit);
1300
1301 int i;
1302 if (fileVersion > 280)
1303 {
1304 //6-dof: 3 linear followed by 3 angular
1305 for (i = 0; i < 3; i++)
1306 {
1307 dof->setStiffness(i, dofData->m_linearSpringStiffness.m_floats[i], dofData->m_linearSpringStiffnessLimited[i]);
1308 dof->setEquilibriumPoint(i, dofData->m_linearEquilibriumPoint.m_floats[i]);
1309 dof->enableSpring(i, dofData->m_linearEnableSpring[i] != 0);
1310 dof->setDamping(i, dofData->m_linearSpringDamping.m_floats[i], (dofData->m_linearSpringDampingLimited[i] != 0));
1311 }
1312 for (i = 0; i < 3; i++)
1313 {
1314 dof->setStiffness(i + 3, dofData->m_angularSpringStiffness.m_floats[i], (dofData->m_angularSpringStiffnessLimited[i] != 0));
1315 dof->setEquilibriumPoint(i + 3, dofData->m_angularEquilibriumPoint.m_floats[i]);
1316 dof->enableSpring(i + 3, dofData->m_angularEnableSpring[i] != 0);
1317 dof->setDamping(i + 3, dofData->m_angularSpringDamping.m_floats[i], (dofData->m_angularSpringDampingLimited[i] != 0));
1318 }
1319 }
1320 }
1321
1322 constraint = dof;
1323 break;
1324 }
1325 case FIXED_CONSTRAINT_TYPE:
1326 {
1327 btGeneric6DofSpring2Constraint* dof = 0;
1328 if (rbA && rbB)
1329 {
1330 btTransform rbAFrame, rbBFrame;
1331 //compute a shared world frame, and compute frameInA, frameInB relative to this
1332 btTransform sharedFrame;
1333 sharedFrame.setIdentity();
1334 btVector3 centerPos = btScalar(0.5) * (rbA->getWorldTransform().getOrigin() +
1335 rbB->getWorldTransform().getOrigin());
1336 sharedFrame.setOrigin(centerPos);
1337 rbAFrame = rbA->getWorldTransform().inverse() * sharedFrame;
1338 rbBFrame = rbB->getWorldTransform().inverse() * sharedFrame;
1339
1340 dof = createGeneric6DofSpring2Constraint(*rbA, *rbB, rbAFrame, rbBFrame, RO_XYZ);
1341 dof->setLinearUpperLimit(btVector3(0, 0, 0));
1342 dof->setLinearLowerLimit(btVector3(0, 0, 0));
1343 dof->setAngularUpperLimit(btVector3(0, 0, 0));
1344 dof->setAngularLowerLimit(btVector3(0, 0, 0));
1345 }
1346 else
1347 {
1348 printf("Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1349 }
1350
1351 constraint = dof;
1352 break;
1353 }
1354
1355 default:
1356 {
1357 printf("unknown constraint type\n");
1358 }
1359 };
1360
1361 if (constraint)
1362 {
1363 constraint->setDbgDrawSize((btScalar)constraintData->m_dbgDrawSize);
1365 if (fileVersion >= 280)
1366 {
1367 constraint->setBreakingImpulseThreshold((btScalar)constraintData->m_breakingImpulseThreshold);
1368 constraint->setEnabled(constraintData->m_isEnabled != 0);
1369 constraint->setOverrideNumSolverIterations(constraintData->m_overrideNumSolverIterations);
1370 }
1371
1372 if (constraintData->m_name)
1373 {
1374 char* newname = duplicateName(constraintData->m_name);
1375 m_nameConstraintMap.insert(newname, constraint);
1376 m_objectNameMap.insert(constraint, newname);
1377 }
1378 if (m_dynamicsWorld)
1379 m_dynamicsWorld->addConstraint(constraint, constraintData->m_disableCollisionsBetweenLinkedBodies != 0);
1380 }
1381}
1382
1383btTriangleIndexVertexArray* btWorldImporter::createMeshInterface(btStridingMeshInterfaceData& meshData)
1384{
1385 btTriangleIndexVertexArray* meshInterface = createTriangleMeshContainer();
1386
1387 for (int i = 0; i < meshData.m_numMeshParts; i++)
1388 {
1389 btIndexedMesh meshPart;
1390 meshPart.m_numTriangles = meshData.m_meshPartsPtr[i].m_numTriangles;
1391 meshPart.m_numVertices = meshData.m_meshPartsPtr[i].m_numVertices;
1392
1393 if (meshData.m_meshPartsPtr[i].m_indices32)
1394 {
1395 meshPart.m_indexType = PHY_INTEGER;
1396 meshPart.m_triangleIndexStride = 3 * sizeof(int);
1397 int* indexArray = (int*)btAlignedAlloc(sizeof(int) * 3 * meshPart.m_numTriangles, 16);
1398 m_indexArrays.push_back(indexArray);
1399 for (int j = 0; j < 3 * meshPart.m_numTriangles; j++)
1400 {
1401 indexArray[j] = meshData.m_meshPartsPtr[i].m_indices32[j].m_value;
1402 }
1403 meshPart.m_triangleIndexBase = (const unsigned char*)indexArray;
1404 }
1405 else
1406 {
1407 if (meshData.m_meshPartsPtr[i].m_3indices16)
1408 {
1409 meshPart.m_indexType = PHY_SHORT;
1410 meshPart.m_triangleIndexStride = sizeof(short int) * 3; //sizeof(btShortIntIndexTripletData);
1411
1412 short int* indexArray = (short int*)btAlignedAlloc(sizeof(short int) * 3 * meshPart.m_numTriangles, 16);
1413 m_shortIndexArrays.push_back(indexArray);
1414
1415 for (int j = 0; j < meshPart.m_numTriangles; j++)
1416 {
1417 indexArray[3 * j] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[0];
1418 indexArray[3 * j + 1] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[1];
1419 indexArray[3 * j + 2] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[2];
1420 }
1421
1422 meshPart.m_triangleIndexBase = (const unsigned char*)indexArray;
1423 }
1424 if (meshData.m_meshPartsPtr[i].m_indices16)
1425 {
1426 meshPart.m_indexType = PHY_SHORT;
1427 meshPart.m_triangleIndexStride = 3 * sizeof(short int);
1428 short int* indexArray = (short int*)btAlignedAlloc(sizeof(short int) * 3 * meshPart.m_numTriangles, 16);
1429 m_shortIndexArrays.push_back(indexArray);
1430 for (int j = 0; j < 3 * meshPart.m_numTriangles; j++)
1431 {
1432 indexArray[j] = meshData.m_meshPartsPtr[i].m_indices16[j].m_value;
1433 }
1434
1435 meshPart.m_triangleIndexBase = (const unsigned char*)indexArray;
1436 }
1437
1438 if (meshData.m_meshPartsPtr[i].m_3indices8)
1439 {
1440 meshPart.m_indexType = PHY_UCHAR;
1441 meshPart.m_triangleIndexStride = sizeof(unsigned char) * 3;
1442
1443 unsigned char* indexArray = (unsigned char*)btAlignedAlloc(sizeof(unsigned char) * 3 * meshPart.m_numTriangles, 16);
1444 m_charIndexArrays.push_back(indexArray);
1445
1446 for (int j = 0; j < meshPart.m_numTriangles; j++)
1447 {
1448 indexArray[3 * j] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[0];
1449 indexArray[3 * j + 1] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[1];
1450 indexArray[3 * j + 2] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[2];
1451 }
1452
1453 meshPart.m_triangleIndexBase = (const unsigned char*)indexArray;
1454 }
1455 }
1456
1457 if (meshData.m_meshPartsPtr[i].m_vertices3f)
1458 {
1459 meshPart.m_vertexType = PHY_FLOAT;
1460 meshPart.m_vertexStride = sizeof(btVector3FloatData);
1461 btVector3FloatData* vertices = (btVector3FloatData*)btAlignedAlloc(sizeof(btVector3FloatData) * meshPart.m_numVertices, 16);
1462 m_floatVertexArrays.push_back(vertices);
1463
1464 for (int j = 0; j < meshPart.m_numVertices; j++)
1465 {
1466 vertices[j].m_floats[0] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[0];
1467 vertices[j].m_floats[1] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[1];
1468 vertices[j].m_floats[2] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[2];
1469 vertices[j].m_floats[3] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[3];
1470 }
1471 meshPart.m_vertexBase = (const unsigned char*)vertices;
1472 }
1473 else
1474 {
1475 meshPart.m_vertexType = PHY_DOUBLE;
1476 meshPart.m_vertexStride = sizeof(btVector3DoubleData);
1477
1478 btVector3DoubleData* vertices = (btVector3DoubleData*)btAlignedAlloc(sizeof(btVector3DoubleData) * meshPart.m_numVertices, 16);
1479 m_doubleVertexArrays.push_back(vertices);
1480
1481 for (int j = 0; j < meshPart.m_numVertices; j++)
1482 {
1483 vertices[j].m_floats[0] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[0];
1484 vertices[j].m_floats[1] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[1];
1485 vertices[j].m_floats[2] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[2];
1486 vertices[j].m_floats[3] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[3];
1487 }
1488 meshPart.m_vertexBase = (const unsigned char*)vertices;
1489 }
1490
1491 if (meshPart.m_triangleIndexBase && meshPart.m_vertexBase)
1492 {
1493 meshInterface->addIndexedMesh(meshPart, meshPart.m_indexType);
1494 }
1495 }
1496
1497 return meshInterface;
1498}
1499
1500btStridingMeshInterfaceData* btWorldImporter::createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData)
1501{
1502 //create a new btStridingMeshInterfaceData that is an exact copy of shapedata and store it in the WorldImporter
1503 btStridingMeshInterfaceData* newData = new btStridingMeshInterfaceData;
1504
1505 newData->m_scaling = interfaceData->m_scaling;
1506 newData->m_numMeshParts = interfaceData->m_numMeshParts;
1507 newData->m_meshPartsPtr = new btMeshPartData[newData->m_numMeshParts];
1508
1509 for (int i = 0; i < newData->m_numMeshParts; i++)
1510 {
1511 btMeshPartData* curPart = &interfaceData->m_meshPartsPtr[i];
1512 btMeshPartData* curNewPart = &newData->m_meshPartsPtr[i];
1513
1514 curNewPart->m_numTriangles = curPart->m_numTriangles;
1515 curNewPart->m_numVertices = curPart->m_numVertices;
1516
1517 if (curPart->m_vertices3f)
1518 {
1519 curNewPart->m_vertices3f = new btVector3FloatData[curNewPart->m_numVertices];
1520 memcpy(curNewPart->m_vertices3f, curPart->m_vertices3f, sizeof(btVector3FloatData) * curNewPart->m_numVertices);
1521 }
1522 else
1523 curNewPart->m_vertices3f = NULL;
1524
1525 if (curPart->m_vertices3d)
1526 {
1527 curNewPart->m_vertices3d = new btVector3DoubleData[curNewPart->m_numVertices];
1528 memcpy(curNewPart->m_vertices3d, curPart->m_vertices3d, sizeof(btVector3DoubleData) * curNewPart->m_numVertices);
1529 }
1530 else
1531 curNewPart->m_vertices3d = NULL;
1532
1533 int numIndices = curNewPart->m_numTriangles * 3;
1536 bool uninitialized3indices8Workaround = false;
1537
1538 if (curPart->m_indices32)
1539 {
1540 uninitialized3indices8Workaround = true;
1541 curNewPart->m_indices32 = new btIntIndexData[numIndices];
1542 memcpy(curNewPart->m_indices32, curPart->m_indices32, sizeof(btIntIndexData) * numIndices);
1543 }
1544 else
1545 curNewPart->m_indices32 = NULL;
1546
1547 if (curPart->m_3indices16)
1548 {
1549 uninitialized3indices8Workaround = true;
1550 curNewPart->m_3indices16 = new btShortIntIndexTripletData[curNewPart->m_numTriangles];
1551 memcpy(curNewPart->m_3indices16, curPart->m_3indices16, sizeof(btShortIntIndexTripletData) * curNewPart->m_numTriangles);
1552 }
1553 else
1554 curNewPart->m_3indices16 = NULL;
1555
1556 if (curPart->m_indices16)
1557 {
1558 uninitialized3indices8Workaround = true;
1559 curNewPart->m_indices16 = new btShortIntIndexData[numIndices];
1560 memcpy(curNewPart->m_indices16, curPart->m_indices16, sizeof(btShortIntIndexData) * numIndices);
1561 }
1562 else
1563 curNewPart->m_indices16 = NULL;
1564
1565 if (!uninitialized3indices8Workaround && curPart->m_3indices8)
1566 {
1567 curNewPart->m_3indices8 = new btCharIndexTripletData[curNewPart->m_numTriangles];
1568 memcpy(curNewPart->m_3indices8, curPart->m_3indices8, sizeof(btCharIndexTripletData) * curNewPart->m_numTriangles);
1569 }
1570 else
1571 curNewPart->m_3indices8 = NULL;
1572 }
1573
1574 m_allocatedbtStridingMeshInterfaceDatas.push_back(newData);
1575
1576 return (newData);
1577}
1578
1579#ifdef USE_INTERNAL_EDGE_UTILITY
1580extern ContactAddedCallback gContactAddedCallback;
1581
1582static bool btAdjustInternalEdgeContactsCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0, int index0, const btCollisionObject* colObj1, int partId1, int index1)
1583{
1584 btAdjustInternalEdgeContacts(cp, colObj1, colObj0, partId1, index1);
1585 //btAdjustInternalEdgeContacts(cp,colObj1,colObj0, partId1,index1, BT_TRIANGLE_CONVEX_BACKFACE_MODE);
1586 //btAdjustInternalEdgeContacts(cp,colObj1,colObj0, partId1,index1, BT_TRIANGLE_CONVEX_DOUBLE_SIDED+BT_TRIANGLE_CONCAVE_DOUBLE_SIDED);
1587 return true;
1588}
1589#endif //USE_INTERNAL_EDGE_UTILITY
1590
1591btCollisionObject* btWorldImporter::createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName)
1592{
1593 return createRigidBody(false, 0, startTransform, shape, bodyName);
1594}
1595
1596void btWorldImporter::setDynamicsWorldInfo(const btVector3& gravity, const btContactSolverInfo& solverInfo)
1597{
1598 if (m_dynamicsWorld)
1599 {
1600 m_dynamicsWorld->setGravity(gravity);
1601 m_dynamicsWorld->getSolverInfo() = solverInfo;
1602 }
1603}
1604
1605btRigidBody* btWorldImporter::createRigidBody(bool isDynamic, btScalar mass, const btTransform& startTransform, btCollisionShape* shape, const char* bodyName)
1606{
1607 btVector3 localInertia;
1608 localInertia.setZero();
1609
1610 if (mass)
1611 shape->calculateLocalInertia(mass, localInertia);
1612
1613 btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
1614 body->setWorldTransform(startTransform);
1615
1616 if (m_dynamicsWorld)
1617 m_dynamicsWorld->addRigidBody(body);
1618
1619 if (bodyName)
1620 {
1621 char* newname = duplicateName(bodyName);
1622 m_objectNameMap.insert(body, newname);
1623 m_nameBodyMap.insert(newname, body);
1624 }
1625 m_allocatedRigidBodies.push_back(body);
1626 return body;
1627}
1628
1629btCollisionShape* btWorldImporter::createPlaneShape(const btVector3& planeNormal, btScalar planeConstant)
1630{
1631 btStaticPlaneShape* shape = new btStaticPlaneShape(planeNormal, planeConstant);
1632 m_allocatedCollisionShapes.push_back(shape);
1633 return shape;
1634}
1635btCollisionShape* btWorldImporter::createBoxShape(const btVector3& halfExtents)
1636{
1637 btBoxShape* shape = new btBoxShape(halfExtents);
1638 m_allocatedCollisionShapes.push_back(shape);
1639 return shape;
1640}
1641btCollisionShape* btWorldImporter::createSphereShape(btScalar radius)
1642{
1643 btSphereShape* shape = new btSphereShape(radius);
1644 m_allocatedCollisionShapes.push_back(shape);
1645 return shape;
1646}
1647
1648btCollisionShape* btWorldImporter::createCapsuleShapeX(btScalar radius, btScalar height)
1649{
1650 btCapsuleShapeX* shape = new btCapsuleShapeX(radius, height);
1651 m_allocatedCollisionShapes.push_back(shape);
1652 return shape;
1653}
1654
1655btCollisionShape* btWorldImporter::createCapsuleShapeY(btScalar radius, btScalar height)
1656{
1657 btCapsuleShape* shape = new btCapsuleShape(radius, height);
1658 m_allocatedCollisionShapes.push_back(shape);
1659 return shape;
1660}
1661
1662btCollisionShape* btWorldImporter::createCapsuleShapeZ(btScalar radius, btScalar height)
1663{
1664 btCapsuleShapeZ* shape = new btCapsuleShapeZ(radius, height);
1665 m_allocatedCollisionShapes.push_back(shape);
1666 return shape;
1667}
1668
1669btCollisionShape* btWorldImporter::createCylinderShapeX(btScalar radius, btScalar height)
1670{
1671 btCylinderShapeX* shape = new btCylinderShapeX(btVector3(height, radius, radius));
1672 m_allocatedCollisionShapes.push_back(shape);
1673 return shape;
1674}
1675
1676btCollisionShape* btWorldImporter::createCylinderShapeY(btScalar radius, btScalar height)
1677{
1678 btCylinderShape* shape = new btCylinderShape(btVector3(radius, height, radius));
1679 m_allocatedCollisionShapes.push_back(shape);
1680 return shape;
1681}
1682
1683btCollisionShape* btWorldImporter::createCylinderShapeZ(btScalar radius, btScalar height)
1684{
1685 btCylinderShapeZ* shape = new btCylinderShapeZ(btVector3(radius, radius, height));
1686 m_allocatedCollisionShapes.push_back(shape);
1687 return shape;
1688}
1689
1690btCollisionShape* btWorldImporter::createConeShapeX(btScalar radius, btScalar height)
1691{
1692 btConeShapeX* shape = new btConeShapeX(radius, height);
1693 m_allocatedCollisionShapes.push_back(shape);
1694 return shape;
1695}
1696
1697btCollisionShape* btWorldImporter::createConeShapeY(btScalar radius, btScalar height)
1698{
1699 btConeShape* shape = new btConeShape(radius, height);
1700 m_allocatedCollisionShapes.push_back(shape);
1701 return shape;
1702}
1703
1704btCollisionShape* btWorldImporter::createConeShapeZ(btScalar radius, btScalar height)
1705{
1706 btConeShapeZ* shape = new btConeShapeZ(radius, height);
1707 m_allocatedCollisionShapes.push_back(shape);
1708 return shape;
1709}
1710
1711btTriangleIndexVertexArray* btWorldImporter::createTriangleMeshContainer()
1712{
1713 btTriangleIndexVertexArray* in = new btTriangleIndexVertexArray();
1714 m_allocatedTriangleIndexArrays.push_back(in);
1715 return in;
1716}
1717
1718btOptimizedBvh* btWorldImporter::createOptimizedBvh()
1719{
1720 btOptimizedBvh* bvh = new btOptimizedBvh();
1721 m_allocatedBvhs.push_back(bvh);
1722 return bvh;
1723}
1724
1725btTriangleInfoMap* btWorldImporter::createTriangleInfoMap()
1726{
1727 btTriangleInfoMap* tim = new btTriangleInfoMap();
1728 m_allocatedTriangleInfoMaps.push_back(tim);
1729 return tim;
1730}
1731
1732btBvhTriangleMeshShape* btWorldImporter::createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh)
1733{
1734 if (bvh)
1735 {
1736 btBvhTriangleMeshShape* bvhTriMesh = new btBvhTriangleMeshShape(trimesh, bvh->isQuantized(), false);
1737 bvhTriMesh->setOptimizedBvh(bvh);
1738 m_allocatedCollisionShapes.push_back(bvhTriMesh);
1739 return bvhTriMesh;
1740 }
1741
1742 btBvhTriangleMeshShape* ts = new btBvhTriangleMeshShape(trimesh, true);
1743 m_allocatedCollisionShapes.push_back(ts);
1744 return ts;
1745}
1746btCollisionShape* btWorldImporter::createConvexTriangleMeshShape(btStridingMeshInterface* trimesh)
1747{
1748 return 0;
1749}
1750btGImpactMeshShape* btWorldImporter::createGimpactShape(btStridingMeshInterface* trimesh)
1751{
1752#ifdef USE_GIMPACT
1753 btGImpactMeshShape* shape = new btGImpactMeshShape(trimesh);
1754 m_allocatedCollisionShapes.push_back(shape);
1755 return shape;
1756#else
1757 return 0;
1758#endif
1759}
1760btConvexHullShape* btWorldImporter::createConvexHullShape()
1761{
1762 btConvexHullShape* shape = new btConvexHullShape();
1763 m_allocatedCollisionShapes.push_back(shape);
1764 return shape;
1765}
1766
1767btCompoundShape* btWorldImporter::createCompoundShape()
1768{
1769 btCompoundShape* shape = new btCompoundShape();
1770 m_allocatedCollisionShapes.push_back(shape);
1771 return shape;
1772}
1773
1774btScaledBvhTriangleMeshShape* btWorldImporter::createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape, const btVector3& localScaling)
1775{
1776 btScaledBvhTriangleMeshShape* shape = new btScaledBvhTriangleMeshShape(meshShape, localScaling);
1777 m_allocatedCollisionShapes.push_back(shape);
1778 return shape;
1779}
1780
1781btMultiSphereShape* btWorldImporter::createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres)
1782{
1783 btMultiSphereShape* shape = new btMultiSphereShape(positions, radi, numSpheres);
1784 m_allocatedCollisionShapes.push_back(shape);
1785 return shape;
1786}
1787
1788class btHeightfieldTerrainShape* btWorldImporter::createHeightfieldShape(int heightStickWidth, int heightStickLength,
1789 const void* heightfieldData, btScalar heightScale,
1790 btScalar minHeight, btScalar maxHeight,
1791 int upAxis, int heightDataType,
1792 bool flipQuadEdges)
1793{
1794
1795 btHeightfieldTerrainShape* shape = new btHeightfieldTerrainShape(heightStickWidth, heightStickLength,
1796 heightfieldData, heightScale, minHeight, maxHeight, upAxis, PHY_ScalarType(heightDataType), flipQuadEdges);
1797 m_allocatedCollisionShapes.push_back(shape);
1798 return shape;
1799}
1800
1801btRigidBody& btWorldImporter::getFixedBody()
1802{
1803 static btRigidBody s_fixed(0, 0, 0);
1804 s_fixed.setMassProps(btScalar(0.), btVector3(btScalar(0.), btScalar(0.), btScalar(0.)));
1805 return s_fixed;
1806}
1807
1808btPoint2PointConstraint* btWorldImporter::createPoint2PointConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& pivotInA, const btVector3& pivotInB)
1809{
1810 btPoint2PointConstraint* p2p = new btPoint2PointConstraint(rbA, rbB, pivotInA, pivotInB);
1811 m_allocatedConstraints.push_back(p2p);
1812 return p2p;
1813}
1814
1815btPoint2PointConstraint* btWorldImporter::createPoint2PointConstraint(btRigidBody& rbA, const btVector3& pivotInA)
1816{
1817 btPoint2PointConstraint* p2p = new btPoint2PointConstraint(rbA, pivotInA);
1818 m_allocatedConstraints.push_back(p2p);
1819 return p2p;
1820}
1821
1822btHingeConstraint* btWorldImporter::createHingeConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA)
1823{
1824 btHingeConstraint* hinge = new btHingeConstraint(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA);
1825 m_allocatedConstraints.push_back(hinge);
1826 return hinge;
1827}
1828
1829btHingeConstraint* btWorldImporter::createHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame, bool useReferenceFrameA)
1830{
1831 btHingeConstraint* hinge = new btHingeConstraint(rbA, rbAFrame, useReferenceFrameA);
1832 m_allocatedConstraints.push_back(hinge);
1833 return hinge;
1834}
1835
1836btConeTwistConstraint* btWorldImporter::createConeTwistConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame)
1837{
1838 btConeTwistConstraint* cone = new btConeTwistConstraint(rbA, rbB, rbAFrame, rbBFrame);
1839 m_allocatedConstraints.push_back(cone);
1840 return cone;
1841}
1842
1843btConeTwistConstraint* btWorldImporter::createConeTwistConstraint(btRigidBody& rbA, const btTransform& rbAFrame)
1844{
1845 btConeTwistConstraint* cone = new btConeTwistConstraint(rbA, rbAFrame);
1846 m_allocatedConstraints.push_back(cone);
1847 return cone;
1848}
1849
1850btGeneric6DofConstraint* btWorldImporter::createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA)
1851{
1852 btGeneric6DofConstraint* dof = new btGeneric6DofConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA);
1853 m_allocatedConstraints.push_back(dof);
1854 return dof;
1855}
1856
1857btGeneric6DofConstraint* btWorldImporter::createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB)
1858{
1859 btGeneric6DofConstraint* dof = new btGeneric6DofConstraint(rbB, frameInB, useLinearReferenceFrameB);
1860 m_allocatedConstraints.push_back(dof);
1861 return dof;
1862}
1863
1864btGeneric6DofSpring2Constraint* btWorldImporter::createGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, int rotateOrder)
1865{
1866 btGeneric6DofSpring2Constraint* dof = new btGeneric6DofSpring2Constraint(rbA, rbB, frameInA, frameInB, (RotateOrder)rotateOrder);
1867 m_allocatedConstraints.push_back(dof);
1868 return dof;
1869}
1870
1871btGeneric6DofSpringConstraint* btWorldImporter::createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA)
1872{
1873 btGeneric6DofSpringConstraint* dof = new btGeneric6DofSpringConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA);
1874 m_allocatedConstraints.push_back(dof);
1875 return dof;
1876}
1877
1878btSliderConstraint* btWorldImporter::createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA)
1879{
1880 btSliderConstraint* slider = new btSliderConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA);
1881 m_allocatedConstraints.push_back(slider);
1882 return slider;
1883}
1884
1885btSliderConstraint* btWorldImporter::createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA)
1886{
1887 btSliderConstraint* slider = new btSliderConstraint(rbB, frameInB, useLinearReferenceFrameA);
1888 m_allocatedConstraints.push_back(slider);
1889 return slider;
1890}
1891
1892btGearConstraint* btWorldImporter::createGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA, const btVector3& axisInB, btScalar ratio)
1893{
1894 btGearConstraint* gear = new btGearConstraint(rbA, rbB, axisInA, axisInB, ratio);
1895 m_allocatedConstraints.push_back(gear);
1896 return gear;
1897}
1898
1899// query for data
1900int btWorldImporter::getNumCollisionShapes() const
1901{
1902 return m_allocatedCollisionShapes.size();
1903}
1904
1905btCollisionShape* btWorldImporter::getCollisionShapeByIndex(int index)
1906{
1907 return m_allocatedCollisionShapes[index];
1908}
1909
1910btCollisionShape* btWorldImporter::getCollisionShapeByName(const char* name)
1911{
1912 btCollisionShape** shapePtr = m_nameShapeMap.find(name);
1913 if (shapePtr && *shapePtr)
1914 {
1915 return *shapePtr;
1916 }
1917 return 0;
1918}
1919
1920btRigidBody* btWorldImporter::getRigidBodyByName(const char* name)
1921{
1922 btRigidBody** bodyPtr = m_nameBodyMap.find(name);
1923 if (bodyPtr && *bodyPtr)
1924 {
1925 return *bodyPtr;
1926 }
1927 return 0;
1928}
1929
1930btTypedConstraint* btWorldImporter::getConstraintByName(const char* name)
1931{
1932 btTypedConstraint** constraintPtr = m_nameConstraintMap.find(name);
1933 if (constraintPtr && *constraintPtr)
1934 {
1935 return *constraintPtr;
1936 }
1937 return 0;
1938}
1939
1940const char* btWorldImporter::getNameForPointer(const void* ptr) const
1941{
1942 const char* const* namePtr = m_objectNameMap.find(ptr);
1943 if (namePtr && *namePtr)
1944 return *namePtr;
1945 return 0;
1946}
1947
1948int btWorldImporter::getNumRigidBodies() const
1949{
1950 return m_allocatedRigidBodies.size();
1951}
1952
1953btCollisionObject* btWorldImporter::getRigidBodyByIndex(int index) const
1954{
1955 return m_allocatedRigidBodies[index];
1956}
1957int btWorldImporter::getNumConstraints() const
1958{
1959 return m_allocatedConstraints.size();
1960}
1961
1962btTypedConstraint* btWorldImporter::getConstraintByIndex(int index) const
1963{
1964 return m_allocatedConstraints[index];
1965}
1966
1967int btWorldImporter::getNumBvhs() const
1968{
1969 return m_allocatedBvhs.size();
1970}
1971btOptimizedBvh* btWorldImporter::getBvhByIndex(int index) const
1972{
1973 return m_allocatedBvhs[index];
1974}
1975
1976int btWorldImporter::getNumTriangleInfoMaps() const
1977{
1978 return m_allocatedTriangleInfoMaps.size();
1979}
1980
1981btTriangleInfoMap* btWorldImporter::getTriangleInfoMapByIndex(int index) const
1982{
1983 return m_allocatedTriangleInfoMaps[index];
1984}
1985
1986void btWorldImporter::convertRigidBodyFloat(btRigidBodyFloatData* colObjData)
1987{
1988 btScalar mass = btScalar(colObjData->m_inverseMass ? 1.f / colObjData->m_inverseMass : 0.f);
1989 btVector3 localInertia;
1990 localInertia.setZero();
1991 btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionObjectData.m_collisionShape);
1992 if (shapePtr && *shapePtr)
1993 {
1994 btTransform startTransform;
1995 colObjData->m_collisionObjectData.m_worldTransform.m_origin.m_floats[3] = 0.f;
1996 startTransform.deSerializeFloat(colObjData->m_collisionObjectData.m_worldTransform);
1997
1998 // startTransform.setBasis(btMatrix3x3::getIdentity());
1999 btCollisionShape* shape = (btCollisionShape*)*shapePtr;
2000 if (shape->isNonMoving())
2001 {
2002 mass = 0.f;
2003 }
2004 if (mass)
2005 {
2006 shape->calculateLocalInertia(mass, localInertia);
2007 }
2008 bool isDynamic = mass != 0.f;
2009 btRigidBody* body = createRigidBody(isDynamic, mass, startTransform, shape, colObjData->m_collisionObjectData.m_name);
2010 body->setFriction(colObjData->m_collisionObjectData.m_friction);
2011 body->setRestitution(colObjData->m_collisionObjectData.m_restitution);
2012 btVector3 linearFactor, angularFactor;
2013 linearFactor.deSerializeFloat(colObjData->m_linearFactor);
2014 angularFactor.deSerializeFloat(colObjData->m_angularFactor);
2015 body->setLinearFactor(linearFactor);
2016 body->setAngularFactor(angularFactor);
2017
2018#ifdef USE_INTERNAL_EDGE_UTILITY
2019 if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
2020 {
2021 btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
2022 if (trimesh->getTriangleInfoMap())
2023 {
2024 body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
2025 }
2026 }
2027#endif //USE_INTERNAL_EDGE_UTILITY
2028 m_bodyMap.insert(colObjData, body);
2029 }
2030 else
2031 {
2032 printf("error: no shape found\n");
2033 }
2034}
2035
2036void btWorldImporter::convertRigidBodyDouble(btRigidBodyDoubleData* colObjData)
2037{
2038 btScalar mass = btScalar(colObjData->m_inverseMass ? 1.f / colObjData->m_inverseMass : 0.f);
2039 btVector3 localInertia;
2040 localInertia.setZero();
2041 btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionObjectData.m_collisionShape);
2042 if (shapePtr && *shapePtr)
2043 {
2044 btTransform startTransform;
2045 colObjData->m_collisionObjectData.m_worldTransform.m_origin.m_floats[3] = 0.f;
2046 startTransform.deSerializeDouble(colObjData->m_collisionObjectData.m_worldTransform);
2047
2048 // startTransform.setBasis(btMatrix3x3::getIdentity());
2049 btCollisionShape* shape = (btCollisionShape*)*shapePtr;
2050 if (shape->isNonMoving())
2051 {
2052 mass = 0.f;
2053 }
2054 if (mass)
2055 {
2056 shape->calculateLocalInertia(mass, localInertia);
2057 }
2058 bool isDynamic = mass != 0.f;
2059 btRigidBody* body = createRigidBody(isDynamic, mass, startTransform, shape, colObjData->m_collisionObjectData.m_name);
2060 body->setFriction(btScalar(colObjData->m_collisionObjectData.m_friction));
2061 body->setRestitution(btScalar(colObjData->m_collisionObjectData.m_restitution));
2062 btVector3 linearFactor, angularFactor;
2063 linearFactor.deSerializeDouble(colObjData->m_linearFactor);
2064 angularFactor.deSerializeDouble(colObjData->m_angularFactor);
2065 body->setLinearFactor(linearFactor);
2066 body->setAngularFactor(angularFactor);
2067
2068#ifdef USE_INTERNAL_EDGE_UTILITY
2069 if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
2070 {
2071 btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
2072 if (trimesh->getTriangleInfoMap())
2073 {
2074 body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
2075 }
2076 }
2077#endif //USE_INTERNAL_EDGE_UTILITY
2078 m_bodyMap.insert(colObjData, body);
2079 }
2080 else
2081 {
2082 printf("error: no shape found\n");
2083 }
2084}
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
COMPOUND_SHAPE_PROXYTYPE
@ COMPOUND_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:71
GIMPACT_SHAPE_PROXYTYPE
@ GIMPACT_SHAPE_PROXYTYPE
Used for GIMPACT Trimesh integration.
Definition: btBroadphaseProxy.h:61
SOFTBODY_SHAPE_PROXYTYPE
@ SOFTBODY_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:73
SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE
@ SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:55
TRIANGLE_MESH_SHAPE_PROXYTYPE
@ TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:54
STATIC_PLANE_PROXYTYPE
@ STATIC_PLANE_PROXYTYPE
Definition: btBroadphaseProxy.h:66
SPHERE_SHAPE_PROXYTYPE
@ SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:39
BOX_SHAPE_PROXYTYPE
@ BOX_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:30
MULTI_SPHERE_SHAPE_PROXYTYPE
@ MULTI_SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:40
CYLINDER_SHAPE_PROXYTYPE
@ CYLINDER_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:44
CONE_SHAPE_PROXYTYPE
@ CONE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:42
CAPSULE_SHAPE_PROXYTYPE
@ CAPSULE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:41
CONVEX_HULL_SHAPE_PROXYTYPE
@ CONVEX_HULL_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:34
PHY_ScalarType
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
Definition: btConcaveShape.h:26
PHY_FLOAT
@ PHY_FLOAT
Definition: btConcaveShape.h:27
PHY_UCHAR
@ PHY_UCHAR
Definition: btConcaveShape.h:32
PHY_DOUBLE
@ PHY_DOUBLE
Definition: btConcaveShape.h:28
PHY_SHORT
@ PHY_SHORT
Definition: btConcaveShape.h:30
PHY_INTEGER
@ PHY_INTEGER
Definition: btConcaveShape.h:29
CONST_GIMPACT_TRIMESH_SHAPE
@ CONST_GIMPACT_TRIMESH_SHAPE
Definition: btGImpactShape.h:48
btAdjustInternalEdgeContacts
void btAdjustInternalEdgeContacts(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, const btCollisionObjectWrapper *colObj1Wrap, int partId0, int index0, int normalAdjustFlags)
Changes a btManifoldPoint collision normal to the normal from the mesh.
Definition: btInternalEdgeUtility.cpp:486
gContactAddedCallback
ContactAddedCallback gContactAddedCallback
This is to allow MaterialCombiner/Custom Friction/Restitution values.
Definition: btManifoldResult.cpp:22
ContactAddedCallback
bool(* ContactAddedCallback)(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)
Definition: btManifoldResult.h:31
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btAssert
#define btAssert(x)
Definition: btScalar.h:153
SLIDER_CONSTRAINT_TYPE
@ SLIDER_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:40
GEAR_CONSTRAINT_TYPE
@ GEAR_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:43
CONETWIST_CONSTRAINT_TYPE
@ CONETWIST_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:38
FIXED_CONSTRAINT_TYPE
@ FIXED_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:44
POINT2POINT_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:36
D6_SPRING_2_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:45
HINGE_CONSTRAINT_TYPE
@ HINGE_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:37
D6_SPRING_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:42
D6_CONSTRAINT_TYPE
@ D6_CONSTRAINT_TYPE
Definition: btTypedConstraint.h:39
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:142
btAlignedObjectArray::resize
void resize(int newsize, const T &fillData=T())
Definition: btAlignedObjectArray.h:203
btAlignedObjectArray::clear
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
Definition: btAlignedObjectArray.h:176
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:257
btBoxShape
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
Definition: btBoxShape.h:28
btBvhTriangleMeshShape
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
Definition: btBvhTriangleMeshShape.h:36
btBvhTriangleMeshShape::setOptimizedBvh
void setOptimizedBvh(btOptimizedBvh *bvh, const btVector3 &localScaling=btVector3(1, 1, 1))
Definition: btBvhTriangleMeshShape.cpp:355
btBvhTriangleMeshShape::getTriangleInfoMap
const btTriangleInfoMap * getTriangleInfoMap() const
Definition: btBvhTriangleMeshShape.h:97
btBvhTriangleMeshShape::setTriangleInfoMap
void setTriangleInfoMap(btTriangleInfoMap *triangleInfoMap)
Definition: btBvhTriangleMeshShape.h:92
btCapsuleShapeX
btCapsuleShapeX represents a capsule around the Z axis the total height is height+2*radius,...
Definition: btCapsuleShape.h:115
btCapsuleShapeZ
btCapsuleShapeZ represents a capsule around the Z axis the total height is height+2*radius,...
Definition: btCapsuleShape.h:129
btCapsuleShape
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
Definition: btCapsuleShape.h:27
btCapsuleShape::deSerializeFloat
void deSerializeFloat(struct btCapsuleShapeData *dataBuffer)
Definition: btCapsuleShape.h:173
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:51
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:311
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:494
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:379
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:389
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:320
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:489
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:28
btCollisionShape::setMargin
virtual void setMargin(btScalar margin)=0
btCollisionShape::getShapeType
int getShapeType() const
Definition: btCollisionShape.h:107
btCollisionShape::calculateLocalInertia
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const =0
btCollisionShape::isNonMoving
bool isNonMoving() const
Definition: btCollisionShape.h:74
btCollisionShape::setLocalScaling
virtual void setLocalScaling(const btVector3 &scaling)=0
btCompoundShape
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
Definition: btCompoundShape.h:57
btCompoundShape::addChildShape
void addChildShape(const btTransform &localTransform, btCollisionShape *shape)
Definition: btCompoundShape.cpp:50
btConcaveShape::setMargin
virtual void setMargin(btScalar collisionMargin)
Definition: btConcaveShape.h:56
btConeShapeX
btConeShape implements a Cone shape, around the X axis
Definition: btConeShape.h:108
btConeShapeZ
btConeShapeZ implements a Cone shape, around the Z axis
Definition: btConeShape.h:126
btConeShape
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
Definition: btConeShape.h:26
btConeTwistConstraint
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
Definition: btConeTwistConstraint.h:59
btConeTwistConstraint::setLimit
void setLimit(int limitIndex, btScalar limitValue)
Definition: btConeTwistConstraint.h:170
btConeTwistConstraint::setDamping
void setDamping(btScalar damping)
Definition: btConeTwistConstraint.h:296
btConvexHullShape
The btConvexHullShape implements an implicit convex hull of an array of vertices.
Definition: btConvexHullShape.h:27
btConvexHullShape::addPoint
void addPoint(const btVector3 &point, bool recalculateLocalAabb=true)
Definition: btConvexHullShape.cpp:51
btConvexInternalShape::setMargin
virtual void setMargin(btScalar margin)
Definition: btConvexInternalShape.h:102
btCylinderShape
The btCylinderShape class implements a cylinder shape primitive, centered around the origin....
Definition: btCylinderShape.h:27
btDynamicsWorld
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
Definition: btDynamicsWorld.h:43
btDynamicsWorld::removeRigidBody
virtual void removeRigidBody(btRigidBody *body)=0
btDynamicsWorld::getSolverInfo
btContactSolverInfo & getSolverInfo()
Definition: btDynamicsWorld.h:140
btDynamicsWorld::removeConstraint
virtual void removeConstraint(btTypedConstraint *constraint)
Definition: btDynamicsWorld.h:75
btDynamicsWorld::addRigidBody
virtual void addRigidBody(btRigidBody *body)=0
btDynamicsWorld::addConstraint
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
Definition: btDynamicsWorld.h:69
btDynamicsWorld::setGravity
virtual void setGravity(const btVector3 &gravity)=0
btGImpactMeshShape
This class manages a mesh supplied by the btStridingMeshInterface interface.
Definition: btGImpactShape.h:851
btGImpactMeshShape::setMargin
virtual void setMargin(btScalar margin)
Definition: btGImpactShape.h:934
btGImpactMeshShape::setLocalScaling
virtual void setLocalScaling(const btVector3 &scaling)
Definition: btGImpactShape.h:920
btGImpactShapeInterface::updateBound
void updateBound()
performs refit operation
Definition: btGImpactShape.h:115
btGearConstraint
The btGeatConstraint will couple the angular velocity for two bodies around given local axis and rati...
Definition: btGearConstraint.h:32
btGeneric6DofConstraint
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
Definition: btGeneric6DofConstraint.h:268
btGeneric6DofConstraint::setLinearLowerLimit
void setLinearLowerLimit(const btVector3 &linearLower)
Definition: btGeneric6DofConstraint.h:433
btGeneric6DofConstraint::setAngularLowerLimit
void setAngularLowerLimit(const btVector3 &angularLower)
Definition: btGeneric6DofConstraint.h:453
btGeneric6DofConstraint::setAngularUpperLimit
void setAngularUpperLimit(const btVector3 &angularUpper)
Definition: btGeneric6DofConstraint.h:465
btGeneric6DofConstraint::setLinearUpperLimit
void setLinearUpperLimit(const btVector3 &linearUpper)
Definition: btGeneric6DofConstraint.h:443
btGeneric6DofSpring2Constraint::setStiffness
void setStiffness(int index, btScalar stiffness, bool limitIfNeeded=true)
Definition: btGeneric6DofSpring2Constraint.cpp:1139
btGeneric6DofSpring2Constraint::setDamping
void setDamping(int index, btScalar damping, bool limitIfNeeded=true)
Definition: btGeneric6DofSpring2Constraint.cpp:1154
btGeneric6DofSpring2Constraint::setLinearUpperLimit
void setLinearUpperLimit(const btVector3 &linearUpper)
Definition: btGeneric6DofSpring2Constraint.h:359
btGeneric6DofSpring2Constraint::setAngularUpperLimit
void setAngularUpperLimit(const btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:386
btGeneric6DofSpring2Constraint::setAngularLowerLimit
void setAngularLowerLimit(const btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:362
btGeneric6DofSpring2Constraint::setLinearLowerLimit
void setLinearLowerLimit(const btVector3 &linearLower)
Definition: btGeneric6DofSpring2Constraint.h:357
btGeneric6DofSpringConstraint
Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF.
Definition: btGeneric6DofSpringConstraint.h:43
btGeneric6DofSpringConstraint::setDamping
void setDamping(int index, btScalar damping)
Definition: btGeneric6DofSpringConstraint.cpp:65
btGeneric6DofSpringConstraint::setStiffness
void setStiffness(int index, btScalar stiffness)
Definition: btGeneric6DofSpringConstraint.cpp:59
btHashMap::insert
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:264
btHashMap::find
const Value * find(const Key &key) const
Definition: btHashMap.h:424
btHeightfieldTerrainShape
btHeightfieldTerrainShape simulates a 2D heightfield terrain
Definition: btHeightfieldTerrainShape.h:72
btHeightfieldTerrainShape::btHeightfieldTerrainShape
btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const float *heightfieldData, btScalar minHeight, btScalar maxHeight, int upAxis, bool flipQuadEdges)
preferred constructors
Definition: btHeightfieldTerrainShape.cpp:20
btHingeConstraint
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
Definition: btHingeConstraint.h:49
btHingeConstraint::setAngularOnly
void setAngularOnly(bool angularOnly)
Definition: btHingeConstraint.h:154
btHingeConstraint::setLimit
void setLimit(btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
Definition: btHingeConstraint.h:175
btHingeConstraint::enableAngularMotor
void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
Definition: btHingeConstraint.h:159
btManifoldPoint
ManifoldContactPoint collects and maintains persistent contactpoints.
Definition: btManifoldPoint.h:52
btMultiSphereShape
The btMultiSphereShape represents the convex hull of a collection of spheres.
Definition: btMultiSphereShape.h:28
btOptimizedBvh
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes,...
Definition: btOptimizedBvh.h:28
btPoint2PointConstraint
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
Definition: btPoint2PointConstraint.h:54
btQuantizedBvh::deSerializeFloat
virtual void deSerializeFloat(struct btQuantizedBvhFloatData &quantizedBvhFloatData)
Definition: btQuantizedBvh.cpp:1119
btQuantizedBvh::deSerializeDouble
virtual void deSerializeDouble(struct btQuantizedBvhDoubleData &quantizedBvhDoubleData)
Definition: btQuantizedBvh.cpp:1190
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:60
btRigidBody::setLinearFactor
void setLinearFactor(const btVector3 &linearFactor)
Definition: btRigidBody.h:258
btRigidBody::setMassProps
void setMassProps(btScalar mass, const btVector3 &inertia)
Definition: btRigidBody.cpp:226
btRigidBody::setAngularFactor
void setAngularFactor(const btVector3 &angFac)
Definition: btRigidBody.h:568
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:189
btScaledBvhTriangleMeshShape
The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMesh...
Definition: btScaledBvhTriangleMeshShape.h:25
btSliderConstraint::setUseFrameOffset
void setUseFrameOffset(bool frameOffsetOnOff)
Definition: btSliderConstraint.h:262
btSliderConstraint::setLowerLinLimit
void setLowerLinLimit(btScalar lowerLimit)
Definition: btSliderConstraint.h:188
btSliderConstraint::setUpperLinLimit
void setUpperLinLimit(btScalar upperLimit)
Definition: btSliderConstraint.h:190
btSliderConstraint::setUpperAngLimit
void setUpperAngLimit(btScalar upperLimit)
Definition: btSliderConstraint.h:194
btSliderConstraint::setLowerAngLimit
void setLowerAngLimit(btScalar lowerLimit)
Definition: btSliderConstraint.h:192
btSphereShape
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
Definition: btSphereShape.h:25
btStaticPlaneShape
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane.
Definition: btStaticPlaneShape.h:24
btStridingMeshInterface
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
Definition: btStridingMeshInterface.h:28
btStridingMeshInterface::setScaling
void setScaling(const btVector3 &scaling)
Definition: btStridingMeshInterface.h:84
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:183
btTransform::deSerializeFloat
void deSerializeFloat(const struct btTransformFloatData &dataIn)
Definition: btTransform.h:275
btTransform::deSerializeDouble
void deSerializeDouble(const struct btTransformDoubleData &dataIn)
Definition: btTransform.h:281
btTransform::setIdentity
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:167
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:114
btTransform::setOrigin
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:147
btTriangleIndexVertexArray
The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing t...
Definition: btTriangleIndexVertexArray.h:67
btTriangleIndexVertexArray::addIndexedMesh
void addIndexedMesh(const btIndexedMesh &mesh, PHY_ScalarType indexType=PHY_INTEGER)
Definition: btTriangleIndexVertexArray.h:87
btTriangleIndexVertexArray::getNumSubParts
virtual int getNumSubParts() const
getNumSubParts returns the number of separate subparts each subpart has a continuous array of vertice...
Definition: btTriangleIndexVertexArray.h:105
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:76
btTypedConstraint::setDbgDrawSize
void setDbgDrawSize(btScalar dbgDrawSize)
Definition: btTypedConstraint.h:307
btTypedConstraint::setEnabled
void setEnabled(bool enabled)
Definition: btTypedConstraint.h:206
btTypedConstraint::setOverrideNumSolverIterations
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
Definition: btTypedConstraint.h:157
btTypedConstraint::setBreakingImpulseThreshold
void setBreakingImpulseThreshold(btScalar threshold)
Definition: btTypedConstraint.h:196
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
btVector3::getZ
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
btVector3::deSerializeFloat
void deSerializeFloat(const struct btVector3FloatData &dataIn)
Definition: btVector3.h:1298
btVector3::deSerializeDouble
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
Definition: btVector3.h:1311
btVector3::setW
void setW(btScalar _w)
Set the w value.
Definition: btVector3.h:573
btVector3::getY
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
btVector3::setZero
void setZero()
Definition: btVector3.h:671
btVector3::getX
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
btWorldImporter::duplicateName
char * duplicateName(const char *name)
Definition: btWorldImporter.cpp:492
btWorldImporter::m_allocatedTriangleIndexArrays
btAlignedObjectArray< btTriangleIndexVertexArray * > m_allocatedTriangleIndexArrays
Definition: btWorldImporter.h:79
btWorldImporter::m_allocatedNames
btAlignedObjectArray< char * > m_allocatedNames
Definition: btWorldImporter.h:82
btWorldImporter::createCollisionObject
virtual btCollisionObject * createCollisionObject(const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
Definition: btWorldImporter.cpp:1591
btWorldImporter::getConstraintByName
btTypedConstraint * getConstraintByName(const char *name)
Definition: btWorldImporter.cpp:1930
btWorldImporter::getFixedBody
static btRigidBody & getFixedBody()
Definition: btWorldImporter.cpp:1801
btWorldImporter::createConeShapeY
virtual btCollisionShape * createConeShapeY(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1697
btWorldImporter::m_allocatedRigidBodies
btAlignedObjectArray< btCollisionObject * > m_allocatedRigidBodies
Definition: btWorldImporter.h:75
btWorldImporter::getNumBvhs
int getNumBvhs() const
Definition: btWorldImporter.cpp:1967
btWorldImporter::createCapsuleShapeY
virtual btCollisionShape * createCapsuleShapeY(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1655
btWorldImporter::getConstraintByIndex
btTypedConstraint * getConstraintByIndex(int index) const
Definition: btWorldImporter.cpp:1962
btWorldImporter::createOptimizedBvh
virtual btOptimizedBvh * createOptimizedBvh()
acceleration and connectivity structures
Definition: btWorldImporter.cpp:1718
btWorldImporter::createScaledTrangleMeshShape
virtual class btScaledBvhTriangleMeshShape * createScaledTrangleMeshShape(btBvhTriangleMeshShape *meshShape, const btVector3 &localScalingbtBvhTriangleMeshShape)
Definition: btWorldImporter.cpp:1774
btWorldImporter::createRigidBody
virtual btRigidBody * createRigidBody(bool isDynamic, btScalar mass, const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
Definition: btWorldImporter.cpp:1605
btWorldImporter::convertConstraintBackwardsCompatible281
void convertConstraintBackwardsCompatible281(btTypedConstraintData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:506
btWorldImporter::getRigidBodyByName
btRigidBody * getRigidBodyByName(const char *name)
Definition: btWorldImporter.cpp:1920
btWorldImporter::createConvexHullShape
virtual class btConvexHullShape * createConvexHullShape()
Definition: btWorldImporter.cpp:1760
btWorldImporter::createConvexTriangleMeshShape
virtual btCollisionShape * createConvexTriangleMeshShape(btStridingMeshInterface *trimesh)
Definition: btWorldImporter.cpp:1746
btWorldImporter::getNameForPointer
const char * getNameForPointer(const void *ptr) const
Definition: btWorldImporter.cpp:1940
btWorldImporter::createCapsuleShapeX
virtual btCollisionShape * createCapsuleShapeX(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1648
btWorldImporter::createPlaneShape
virtual btCollisionShape * createPlaneShape(const btVector3 &planeNormal, btScalar planeConstant)
shapes
Definition: btWorldImporter.cpp:1629
btWorldImporter::m_allocatedBvhs
btAlignedObjectArray< btOptimizedBvh * > m_allocatedBvhs
Definition: btWorldImporter.h:77
btWorldImporter::m_bvhMap
btHashMap< btHashPtr, btOptimizedBvh * > m_bvhMap
Definition: btWorldImporter.h:91
btWorldImporter::getRigidBodyByIndex
btCollisionObject * getRigidBodyByIndex(int index) const
Definition: btWorldImporter.cpp:1953
btWorldImporter::getCollisionShapeByIndex
btCollisionShape * getCollisionShapeByIndex(int index)
Definition: btWorldImporter.cpp:1905
btWorldImporter::m_nameConstraintMap
btHashMap< btHashString, btTypedConstraint * > m_nameConstraintMap
Definition: btWorldImporter.h:96
btWorldImporter::createConeTwistConstraint
virtual btConeTwistConstraint * createConeTwistConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
Definition: btWorldImporter.cpp:1836
btWorldImporter::createMultiSphereShape
virtual class btMultiSphereShape * createMultiSphereShape(const btVector3 *positions, const btScalar *radi, int numSpheres)
Definition: btWorldImporter.cpp:1781
btWorldImporter::~btWorldImporter
virtual ~btWorldImporter()
Definition: btWorldImporter.cpp:29
btWorldImporter::createStridingMeshInterfaceData
virtual btStridingMeshInterfaceData * createStridingMeshInterfaceData(btStridingMeshInterfaceData *interfaceData)
Definition: btWorldImporter.cpp:1500
btWorldImporter::m_allocatedConstraints
btAlignedObjectArray< btTypedConstraint * > m_allocatedConstraints
Definition: btWorldImporter.h:76
btWorldImporter::convertConstraintDouble
void convertConstraintDouble(btTypedConstraintDoubleData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:1054
btWorldImporter::createGeneric6DofSpring2Constraint
virtual btGeneric6DofSpring2Constraint * createGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, int rotateOrder)
Definition: btWorldImporter.cpp:1864
btWorldImporter::m_charIndexArrays
btAlignedObjectArray< unsigned char * > m_charIndexArrays
Definition: btWorldImporter.h:86
btWorldImporter::createBoxShape
virtual btCollisionShape * createBoxShape(const btVector3 &halfExtents)
Definition: btWorldImporter.cpp:1635
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:1596
btWorldImporter::getNumRigidBodies
int getNumRigidBodies() const
Definition: btWorldImporter.cpp:1948
btWorldImporter::getNumTriangleInfoMaps
int getNumTriangleInfoMaps() const
Definition: btWorldImporter.cpp:1976
btWorldImporter::createMeshInterface
virtual btTriangleIndexVertexArray * createMeshInterface(btStridingMeshInterfaceData &meshData)
Definition: btWorldImporter.cpp:1383
btWorldImporter::m_indexArrays
btAlignedObjectArray< int * > m_indexArrays
Definition: btWorldImporter.h:84
btWorldImporter::createGeneric6DofConstraint
virtual btGeneric6DofConstraint * createGeneric6DofConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
Definition: btWorldImporter.cpp:1850
btWorldImporter::getNumCollisionShapes
int getNumCollisionShapes() const
Definition: btWorldImporter.cpp:1900
btWorldImporter::m_allocatedTriangleInfoMaps
btAlignedObjectArray< btTriangleInfoMap * > m_allocatedTriangleInfoMaps
Definition: btWorldImporter.h:78
btWorldImporter::createCylinderShapeY
virtual btCollisionShape * createCylinderShapeY(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1676
btWorldImporter::deleteAllData
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
Definition: btWorldImporter.cpp:33
btWorldImporter::createGeneric6DofSpringConstraint
virtual btGeneric6DofSpringConstraint * createGeneric6DofSpringConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
Definition: btWorldImporter.cpp:1871
btWorldImporter::createConeShapeX
virtual btCollisionShape * createConeShapeX(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1690
btWorldImporter::m_dynamicsWorld
btDynamicsWorld * m_dynamicsWorld
Definition: btWorldImporter.h:69
btWorldImporter::createCylinderShapeX
virtual btCollisionShape * createCylinderShapeX(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1669
btWorldImporter::convertConstraintFloat
void convertConstraintFloat(btTypedConstraintFloatData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
Definition: btWorldImporter.cpp:729
btWorldImporter::createCompoundShape
virtual class btCompoundShape * createCompoundShape()
Definition: btWorldImporter.cpp:1767
btWorldImporter::btWorldImporter
btWorldImporter(btDynamicsWorld *world)
Definition: btWorldImporter.cpp:22
btWorldImporter::getTriangleInfoMapByIndex
btTriangleInfoMap * getTriangleInfoMapByIndex(int index) const
Definition: btWorldImporter.cpp:1981
btWorldImporter::m_allocatedCollisionShapes
btAlignedObjectArray< btCollisionShape * > m_allocatedCollisionShapes
Definition: btWorldImporter.h:74
btWorldImporter::createGearConstraint
virtual btGearConstraint * createGearConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &axisInA, const btVector3 &axisInB, btScalar ratio)
Definition: btWorldImporter.cpp:1892
btWorldImporter::m_nameShapeMap
btHashMap< btHashString, btCollisionShape * > m_nameShapeMap
Definition: btWorldImporter.h:94
btWorldImporter::getNumConstraints
int getNumConstraints() const
Definition: btWorldImporter.cpp:1957
btWorldImporter::m_shapeMap
btHashMap< btHashPtr, btCollisionShape * > m_shapeMap
Definition: btWorldImporter.h:99
btWorldImporter::createConeShapeZ
virtual btCollisionShape * createConeShapeZ(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1704
btWorldImporter::createHingeConstraint
virtual btHingeConstraint * createHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame, bool useReferenceFrameA=false)
Definition: btWorldImporter.cpp:1822
btWorldImporter::m_doubleVertexArrays
btAlignedObjectArray< btVector3DoubleData * > m_doubleVertexArrays
Definition: btWorldImporter.h:89
btWorldImporter::m_nameBodyMap
btHashMap< btHashString, btRigidBody * > m_nameBodyMap
Definition: btWorldImporter.h:95
btWorldImporter::convertCollisionShape
btCollisionShape * convertCollisionShape(btCollisionShapeData *shapeData)
Definition: btWorldImporter.cpp:142
btWorldImporter::createSphereShape
virtual btCollisionShape * createSphereShape(btScalar radius)
Definition: btWorldImporter.cpp:1641
btWorldImporter::getCollisionShapeByName
btCollisionShape * getCollisionShapeByName(const char *name)
Definition: btWorldImporter.cpp:1910
btWorldImporter::convertRigidBodyDouble
void convertRigidBodyDouble(btRigidBodyDoubleData *colObjData)
Definition: btWorldImporter.cpp:2036
btWorldImporter::m_floatVertexArrays
btAlignedObjectArray< btVector3FloatData * > m_floatVertexArrays
Definition: btWorldImporter.h:88
btWorldImporter::createTriangleMeshContainer
virtual class btTriangleIndexVertexArray * createTriangleMeshContainer()
Definition: btWorldImporter.cpp:1711
btWorldImporter::createBvhTriangleMeshShape
virtual btBvhTriangleMeshShape * createBvhTriangleMeshShape(btStridingMeshInterface *trimesh, btOptimizedBvh *bvh)
Definition: btWorldImporter.cpp:1732
btWorldImporter::m_allocatedbtStridingMeshInterfaceDatas
btAlignedObjectArray< btStridingMeshInterfaceData * > m_allocatedbtStridingMeshInterfaceDatas
Definition: btWorldImporter.h:80
btWorldImporter::createGimpactShape
virtual btGImpactMeshShape * createGimpactShape(btStridingMeshInterface *trimesh)
Definition: btWorldImporter.cpp:1750
btWorldImporter::getBvhByIndex
btOptimizedBvh * getBvhByIndex(int index) const
Definition: btWorldImporter.cpp:1971
btWorldImporter::convertRigidBodyFloat
void convertRigidBodyFloat(btRigidBodyFloatData *colObjData)
Definition: btWorldImporter.cpp:1986
btWorldImporter::m_bodyMap
btHashMap< btHashPtr, btCollisionObject * > m_bodyMap
Definition: btWorldImporter.h:100
btWorldImporter::createPoint2PointConstraint
virtual btPoint2PointConstraint * createPoint2PointConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB)
constraints
Definition: btWorldImporter.cpp:1808
btWorldImporter::createCylinderShapeZ
virtual btCollisionShape * createCylinderShapeZ(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1683
btWorldImporter::createTriangleInfoMap
virtual btTriangleInfoMap * createTriangleInfoMap()
Definition: btWorldImporter.cpp:1725
btWorldImporter::createHeightfieldShape
virtual class btHeightfieldTerrainShape * createHeightfieldShape(int heightStickWidth, int heightStickLength, const void *heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, int heightDataType, bool flipQuadEdges)
Definition: btWorldImporter.cpp:1788
btWorldImporter::createCapsuleShapeZ
virtual btCollisionShape * createCapsuleShapeZ(btScalar radius, btScalar height)
Definition: btWorldImporter.cpp:1662
btWorldImporter::createSliderConstraint
virtual btSliderConstraint * createSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
Definition: btWorldImporter.cpp:1878
btWorldImporter::m_shortIndexArrays
btAlignedObjectArray< short int * > m_shortIndexArrays
Definition: btWorldImporter.h:85
btWorldImporter::m_objectNameMap
btHashMap< btHashPtr, const char * > m_objectNameMap
Definition: btWorldImporter.h:97
btCapsuleShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCapsuleShape.h:142
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:622
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:657
btCollisionShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCollisionShape.h:163
btCompoundShapeChildData::m_transform
btTransformFloatData m_transform
Definition: btCompoundShape.h:181
btCompoundShapeChildData::m_childShape
btCollisionShapeData * m_childShape
Definition: btCompoundShape.h:182
btCompoundShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCompoundShape.h:189
btCompoundShapeData::m_childShapePtr
btCompoundShapeChildData * m_childShapePtr
Definition: btCompoundShape.h:192
btConeShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btConeShape.h:144
btConeTwistConstraintData
this structure is not used, except for loading pre-2.82 .bullet files
Definition: btConeTwistConstraint.h:378
btConeTwistConstraintData::m_rbBFrame
btTransformFloatData m_rbBFrame
Definition: btConeTwistConstraint.h:381
btConeTwistConstraintData::m_rbAFrame
btTransformFloatData m_rbAFrame
Definition: btConeTwistConstraint.h:380
btConvexHullShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btConvexHullShape.h:99
btConvexHullShapeData::m_unscaledPointsDoublePtr
btVector3DoubleData * m_unscaledPointsDoublePtr
Definition: btConvexHullShape.h:103
btConvexHullShapeData::m_unscaledPointsFloatPtr
btVector3FloatData * m_unscaledPointsFloatPtr
Definition: btConvexHullShape.h:102
btConvexInternalShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btConvexInternalShape.h:136
btConvexInternalShapeData::m_implicitShapeDimensions
btVector3FloatData m_implicitShapeDimensions
Definition: btConvexInternalShape.h:141
btCylinderShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCylinderShape.h:175
btGImpactMeshShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btGImpactShape.h:1098
btGImpactMeshShapeData::m_meshInterface
btStridingMeshInterfaceData m_meshInterface
Definition: btGImpactShape.h:1101
btGImpactMeshShapeData::m_localScaling
btVector3FloatData m_localScaling
Definition: btGImpactShape.h:1103
btGearConstraintDoubleData::m_axisInA
btVector3DoubleData m_axisInA
Definition: btGearConstraint.h:113
btGearConstraintDoubleData::m_axisInB
btVector3DoubleData m_axisInB
Definition: btGearConstraint.h:114
btGearConstraintFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btGearConstraint.h:99
btGearConstraintFloatData::m_axisInB
btVector3FloatData m_axisInB
Definition: btGearConstraint.h:103
btGearConstraintFloatData::m_axisInA
btVector3FloatData m_axisInA
Definition: btGearConstraint.h:102
btHingeConstraintDoubleData2
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btHingeConstraint.h:418
btHingeConstraintDoubleData2::m_rbBFrame
btTransformDoubleData m_rbBFrame
Definition: btHingeConstraint.h:421
btHingeConstraintDoubleData2::m_rbAFrame
btTransformDoubleData m_rbAFrame
Definition: btHingeConstraint.h:420
btHingeConstraintDoubleData
this structure is not used, except for loading pre-2.82 .bullet files
Definition: btHingeConstraint.h:341
btHingeConstraintDoubleData::m_rbAFrame
btTransformDoubleData m_rbAFrame
Definition: btHingeConstraint.h:343
btHingeConstraintDoubleData::m_rbBFrame
btTransformDoubleData m_rbBFrame
Definition: btHingeConstraint.h:344
btHingeConstraintFloatData::m_rbAFrame
btTransformFloatData m_rbAFrame
Definition: btHingeConstraint.h:400
btHingeConstraintFloatData::m_rbBFrame
btTransformFloatData m_rbBFrame
Definition: btHingeConstraint.h:401
btIndexedMesh
The btIndexedMesh indexes a single vertex and index array.
Definition: btTriangleIndexVertexArray.h:27
btIndexedMesh::m_indexType
PHY_ScalarType m_indexType
Definition: btTriangleIndexVertexArray.h:41
btIndexedMesh::m_vertexBase
const unsigned char * m_vertexBase
Definition: btTriangleIndexVertexArray.h:35
btIndexedMesh::m_triangleIndexBase
const unsigned char * m_triangleIndexBase
Definition: btTriangleIndexVertexArray.h:31
btIndexedMesh::m_vertexType
PHY_ScalarType m_vertexType
Definition: btTriangleIndexVertexArray.h:46
btMeshPartData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btStridingMeshInterface.h:122
btMeshPartData::m_indices16
btShortIntIndexData * m_indices16
Definition: btStridingMeshInterface.h:130
btMeshPartData::m_3indices8
btCharIndexTripletData * m_3indices8
Definition: btStridingMeshInterface.h:128
btMeshPartData::m_vertices3f
btVector3FloatData * m_vertices3f
Definition: btStridingMeshInterface.h:123
btMeshPartData::m_3indices16
btShortIntIndexTripletData * m_3indices16
Definition: btStridingMeshInterface.h:127
btMeshPartData::m_indices32
btIntIndexData * m_indices32
Definition: btStridingMeshInterface.h:126
btMeshPartData::m_vertices3d
btVector3DoubleData * m_vertices3d
Definition: btStridingMeshInterface.h:124
btMultiSphereShapeData::m_localPositionArrayPtr
btPositionAndRadius * m_localPositionArrayPtr
Definition: btMultiSphereShape.h:83
btPoint2PointConstraintDoubleData2
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btPoint2PointConstraint.h:138
btPoint2PointConstraintDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 th...
Definition: btPoint2PointConstraint.h:149
btPoint2PointConstraintFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btPoint2PointConstraint.h:130
btPositionAndRadius::m_pos
btVector3FloatData m_pos
Definition: btMultiSphereShape.h:73
btRigidBodyDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:662
btRigidBodyDoubleData::m_collisionObjectData
btCollisionObjectDoubleData m_collisionObjectData
Definition: btRigidBody.h:663
btRigidBodyDoubleData::m_linearFactor
btVector3DoubleData m_linearFactor
Definition: btRigidBody.h:668
btRigidBodyDoubleData::m_angularFactor
btVector3DoubleData m_angularFactor
Definition: btRigidBody.h:667
btRigidBodyFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:636
btRigidBodyFloatData::m_linearFactor
btVector3FloatData m_linearFactor
Definition: btRigidBody.h:642
btRigidBodyFloatData::m_angularFactor
btVector3FloatData m_angularFactor
Definition: btRigidBody.h:641
btRigidBodyFloatData::m_collisionObjectData
btCollisionObjectFloatData m_collisionObjectData
Definition: btRigidBody.h:637
btScaledTriangleMeshShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btScaledBvhTriangleMeshShape.h:65
btSliderConstraintData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btSliderConstraint.h:292
btSliderConstraintData::m_rbBFrame
btTransformFloatData m_rbBFrame
Definition: btSliderConstraint.h:295
btSliderConstraintData::m_rbAFrame
btTransformFloatData m_rbAFrame
Definition: btSliderConstraint.h:294
btSliderConstraintDoubleData::m_rbAFrame
btTransformDoubleData m_rbAFrame
Definition: btSliderConstraint.h:310
btSliderConstraintDoubleData::m_rbBFrame
btTransformDoubleData m_rbBFrame
Definition: btSliderConstraint.h:311
btStaticPlaneShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btStaticPlaneShape.h:70
btStaticPlaneShapeData::m_localScaling
btVector3FloatData m_localScaling
Definition: btStaticPlaneShape.h:73
btStaticPlaneShapeData::m_planeNormal
btVector3FloatData m_planeNormal
Definition: btStaticPlaneShape.h:74
btStridingMeshInterfaceData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btStridingMeshInterface.h:139
btTransformDoubleData::m_origin
btVector3DoubleData m_origin
Definition: btTransform.h:254
btTransformFloatData::m_origin
btVector3FloatData m_origin
Definition: btTransform.h:248
btTriangleInfoMap
The btTriangleInfoMap stores edge angle information for some triangles. You can compute this informat...
Definition: btTriangleInfoMap.h:54
btTriangleInfoMap::deSerialize
void deSerialize(struct btTriangleInfoMapData &data)
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btTriangleInfoMap.h:204
btTriangleMeshShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btBvhTriangleMeshShape.h:121
btTriangleMeshShapeData::m_meshInterface
btStridingMeshInterfaceData m_meshInterface
Definition: btBvhTriangleMeshShape.h:124
btTriangleMeshShapeData::m_quantizedDoubleBvh
btQuantizedBvhDoubleData * m_quantizedDoubleBvh
Definition: btBvhTriangleMeshShape.h:127
btTriangleMeshShapeData::m_quantizedFloatBvh
btQuantizedBvhFloatData * m_quantizedFloatBvh
Definition: btBvhTriangleMeshShape.h:126
btTriangleMeshShapeData::m_triangleInfoMap
btTriangleInfoMapData * m_triangleInfoMap
Definition: btBvhTriangleMeshShape.h:129
btTypedConstraintData
this structure is not used, except for loading pre-2.82 .bullet files
Definition: btTypedConstraint.h:388
btTypedConstraintFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btTypedConstraint.h:359
btVector3DoubleData::m_floats
double m_floats[4]
Definition: btVector3.h:1288
Generated by doxygen 1.9.4