Bullet Collision Detection & Physics Library
btWorldImporter.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2012 Erwin Coumans http://bulletphysics.org
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #include "btWorldImporter.h"
17 #include "btBulletDynamicsCommon.h"
19 #ifdef USE_GIMPACT
21 #endif
23  : m_dynamicsWorld(world),
24  m_verboseMode(0),
25  m_importerFlags(0)
26 {
27 }
28 
30 {
31 }
32 
34 {
35  int i;
36  for (i = 0; i < m_allocatedConstraints.size(); i++)
37  {
38  if (m_dynamicsWorld)
40  delete m_allocatedConstraints[i];
41  }
43 
44  for (i = 0; i < m_allocatedRigidBodies.size(); i++)
45  {
46  if (m_dynamicsWorld)
48  delete m_allocatedRigidBodies[i];
49  }
50 
52 
53  for (i = 0; i < m_allocatedCollisionShapes.size(); i++)
54  {
56  }
58 
59  for (i = 0; i < m_allocatedBvhs.size(); i++)
60  {
61  delete m_allocatedBvhs[i];
62  }
64 
65  for (i = 0; i < m_allocatedTriangleInfoMaps.size(); i++)
66  {
68  }
70  for (i = 0; i < m_allocatedTriangleIndexArrays.size(); i++)
71  {
73  }
75  for (i = 0; i < m_allocatedNames.size(); i++)
76  {
77  delete[] m_allocatedNames[i];
78  }
80 
81  for (i = 0; i < m_allocatedbtStridingMeshInterfaceDatas.size(); i++)
82  {
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  }
110 
111  for (i = 0; i < m_indexArrays.size(); i++)
112  {
114  }
116 
117  for (i = 0; i < m_shortIndexArrays.size(); i++)
118  {
120  }
122 
123  for (i = 0; i < m_charIndexArrays.size(); i++)
124  {
126  }
128 
129  for (i = 0; i < m_floatVertexArrays.size(); i++)
130  {
132  }
134 
135  for (i = 0; i < m_doubleVertexArrays.size(); i++)
136  {
138  }
140 }
141 
143 {
144  btCollisionShape* shape = 0;
145 
146  switch (shapeData->m_shapeType)
147  {
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  }
160  {
162  btCollisionShapeData* colShapeData = (btCollisionShapeData*)&scaledMesh->m_trimeshShapeData;
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  }
173  {
174 #ifdef USE_GIMPACT
175  btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*)shapeData;
176  if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE)
177  {
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
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  }
233  case BOX_SHAPE_PROXYTYPE:
237  {
239  btVector3 implicitShapeDimensions;
240  implicitShapeDimensions.deSerializeFloat(bsd->m_implicitShapeDimensions);
241  btVector3 localScaling;
242  localScaling.deSerializeFloat(bsd->m_localScaling);
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  }
255  {
256  shape = createSphereShape(implicitShapeDimensions.getX());
257  break;
258  }
259 
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  }
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  }
319  {
321  int numSpheres = mss->m_localPositionArraySize;
322 
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  }
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 
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  }
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  }
388  {
389  btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData;
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  {
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  }
450  {
451  btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData;
452  btCompoundShape* compoundShape = createCompoundShape();
453 
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  }
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 
492 char* 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 
507 {
508  btTypedConstraint* constraint = 0;
509 
510  switch (constraintData->m_objectType)
511  {
513  {
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  }
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  }
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 
585  {
587  // int sz = sizeof(btGeneric6DofSpringConstraintData);
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  }
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  {
714  constraint->setEnabled(constraintData->m_isEnabled != 0);
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 
730 {
731  btTypedConstraint* constraint = 0;
732 
733  switch (constraintData->m_objectType)
734  {
736  {
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  }
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  }
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 
806  {
808  // int sz = sizeof(btGeneric6DofSpringConstraintData);
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  }
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  }
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  }
942  {
944 
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);
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  }
998  {
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);
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 
1055 {
1056  btTypedConstraint* constraint = 0;
1057 
1058  switch (constraintData->m_objectType)
1059  {
1061  {
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  }
1107  {
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 
1133  {
1135  // int sz = sizeof(btGeneric6DofSpringConstraintData);
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  {
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  }
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 
1270  {
1272 
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  {
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  {
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);
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 
1384 {
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);
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 
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 
1501 {
1502  //create a new btStridingMeshInterfaceData that is an exact copy of shapedata and store it in the WorldImporter
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 
1575 
1576  return (newData);
1577 }
1578 
1579 #ifdef USE_INTERNAL_EDGE_UTILITY
1581 
1582 static 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 
1591 btCollisionObject* btWorldImporter::createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName)
1592 {
1593  return createRigidBody(false, 0, startTransform, shape, bodyName);
1594 }
1595 
1597 {
1598  if (m_dynamicsWorld)
1599  {
1600  m_dynamicsWorld->setGravity(gravity);
1601  m_dynamicsWorld->getSolverInfo() = solverInfo;
1602  }
1603 }
1604 
1605 btRigidBody* 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)
1618 
1619  if (bodyName)
1620  {
1621  char* newname = duplicateName(bodyName);
1622  m_objectNameMap.insert(body, newname);
1623  m_nameBodyMap.insert(newname, body);
1624  }
1626  return body;
1627 }
1628 
1630 {
1631  btStaticPlaneShape* shape = new btStaticPlaneShape(planeNormal, planeConstant);
1633  return shape;
1634 }
1636 {
1637  btBoxShape* shape = new btBoxShape(halfExtents);
1639  return shape;
1640 }
1642 {
1643  btSphereShape* shape = new btSphereShape(radius);
1645  return shape;
1646 }
1647 
1649 {
1650  btCapsuleShapeX* shape = new btCapsuleShapeX(radius, height);
1652  return shape;
1653 }
1654 
1656 {
1657  btCapsuleShape* shape = new btCapsuleShape(radius, height);
1659  return shape;
1660 }
1661 
1663 {
1664  btCapsuleShapeZ* shape = new btCapsuleShapeZ(radius, height);
1666  return shape;
1667 }
1668 
1670 {
1671  btCylinderShapeX* shape = new btCylinderShapeX(btVector3(height, radius, radius));
1673  return shape;
1674 }
1675 
1677 {
1678  btCylinderShape* shape = new btCylinderShape(btVector3(radius, height, radius));
1680  return shape;
1681 }
1682 
1684 {
1685  btCylinderShapeZ* shape = new btCylinderShapeZ(btVector3(radius, radius, height));
1687  return shape;
1688 }
1689 
1691 {
1692  btConeShapeX* shape = new btConeShapeX(radius, height);
1694  return shape;
1695 }
1696 
1698 {
1699  btConeShape* shape = new btConeShape(radius, height);
1701  return shape;
1702 }
1703 
1705 {
1706  btConeShapeZ* shape = new btConeShapeZ(radius, height);
1708  return shape;
1709 }
1710 
1712 {
1715  return in;
1716 }
1717 
1719 {
1720  btOptimizedBvh* bvh = new btOptimizedBvh();
1722  return bvh;
1723 }
1724 
1726 {
1727  btTriangleInfoMap* tim = new btTriangleInfoMap();
1729  return tim;
1730 }
1731 
1733 {
1734  if (bvh)
1735  {
1736  btBvhTriangleMeshShape* bvhTriMesh = new btBvhTriangleMeshShape(trimesh, bvh->isQuantized(), false);
1737  bvhTriMesh->setOptimizedBvh(bvh);
1739  return bvhTriMesh;
1740  }
1741 
1742  btBvhTriangleMeshShape* ts = new btBvhTriangleMeshShape(trimesh, true);
1744  return ts;
1745 }
1747 {
1748  return 0;
1749 }
1751 {
1752 #ifdef USE_GIMPACT
1753  btGImpactMeshShape* shape = new btGImpactMeshShape(trimesh);
1755  return shape;
1756 #else
1757  return 0;
1758 #endif
1759 }
1761 {
1762  btConvexHullShape* shape = new btConvexHullShape();
1764  return shape;
1765 }
1766 
1768 {
1769  btCompoundShape* shape = new btCompoundShape();
1771  return shape;
1772 }
1773 
1775 {
1776  btScaledBvhTriangleMeshShape* shape = new btScaledBvhTriangleMeshShape(meshShape, localScaling);
1778  return shape;
1779 }
1780 
1781 btMultiSphereShape* btWorldImporter::createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres)
1782 {
1783  btMultiSphereShape* shape = new btMultiSphereShape(positions, radi, numSpheres);
1785  return shape;
1786 }
1787 
1788 class 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);
1798  return shape;
1799 }
1800 
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 
1809 {
1810  btPoint2PointConstraint* p2p = new btPoint2PointConstraint(rbA, rbB, pivotInA, pivotInB);
1812  return p2p;
1813 }
1814 
1816 {
1817  btPoint2PointConstraint* p2p = new btPoint2PointConstraint(rbA, pivotInA);
1819  return p2p;
1820 }
1821 
1822 btHingeConstraint* 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);
1826  return hinge;
1827 }
1828 
1830 {
1831  btHingeConstraint* hinge = new btHingeConstraint(rbA, rbAFrame, useReferenceFrameA);
1833  return hinge;
1834 }
1835 
1837 {
1838  btConeTwistConstraint* cone = new btConeTwistConstraint(rbA, rbB, rbAFrame, rbBFrame);
1840  return cone;
1841 }
1842 
1844 {
1845  btConeTwistConstraint* cone = new btConeTwistConstraint(rbA, rbAFrame);
1847  return cone;
1848 }
1849 
1850 btGeneric6DofConstraint* 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);
1854  return dof;
1855 }
1856 
1858 {
1859  btGeneric6DofConstraint* dof = new btGeneric6DofConstraint(rbB, frameInB, useLinearReferenceFrameB);
1861  return dof;
1862 }
1863 
1865 {
1866  btGeneric6DofSpring2Constraint* dof = new btGeneric6DofSpring2Constraint(rbA, rbB, frameInA, frameInB, (RotateOrder)rotateOrder);
1868  return dof;
1869 }
1870 
1872 {
1873  btGeneric6DofSpringConstraint* dof = new btGeneric6DofSpringConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA);
1875  return dof;
1876 }
1877 
1878 btSliderConstraint* 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);
1882  return slider;
1883 }
1884 
1885 btSliderConstraint* btWorldImporter::createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA)
1886 {
1887  btSliderConstraint* slider = new btSliderConstraint(rbB, frameInB, useLinearReferenceFrameA);
1889  return slider;
1890 }
1891 
1893 {
1894  btGearConstraint* gear = new btGearConstraint(rbA, rbB, axisInA, axisInB, ratio);
1896  return gear;
1897 }
1898 
1899 // query for data
1901 {
1903 }
1904 
1906 {
1907  return m_allocatedCollisionShapes[index];
1908 }
1909 
1911 {
1912  btCollisionShape** shapePtr = m_nameShapeMap.find(name);
1913  if (shapePtr && *shapePtr)
1914  {
1915  return *shapePtr;
1916  }
1917  return 0;
1918 }
1919 
1921 {
1922  btRigidBody** bodyPtr = m_nameBodyMap.find(name);
1923  if (bodyPtr && *bodyPtr)
1924  {
1925  return *bodyPtr;
1926  }
1927  return 0;
1928 }
1929 
1931 {
1932  btTypedConstraint** constraintPtr = m_nameConstraintMap.find(name);
1933  if (constraintPtr && *constraintPtr)
1934  {
1935  return *constraintPtr;
1936  }
1937  return 0;
1938 }
1939 
1940 const 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 
1949 {
1950  return m_allocatedRigidBodies.size();
1951 }
1952 
1954 {
1955  return m_allocatedRigidBodies[index];
1956 }
1958 {
1959  return m_allocatedConstraints.size();
1960 }
1961 
1963 {
1964  return m_allocatedConstraints[index];
1965 }
1966 
1968 {
1969  return m_allocatedBvhs.size();
1970 }
1972 {
1973  return m_allocatedBvhs[index];
1974 }
1975 
1977 {
1979 }
1980 
1982 {
1983  return m_allocatedTriangleInfoMaps[index];
1984 }
1985 
1987 {
1988  btScalar mass = btScalar(colObjData->m_inverseMass ? 1.f / colObjData->m_inverseMass : 0.f);
1989  btVector3 localInertia;
1990  localInertia.setZero();
1992  if (shapePtr && *shapePtr)
1993  {
1994  btTransform startTransform;
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);
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
2020  {
2022  if (trimesh->getTriangleInfoMap())
2023  {
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 
2037 {
2038  btScalar mass = btScalar(colObjData->m_inverseMass ? 1.f / colObjData->m_inverseMass : 0.f);
2039  btVector3 localInertia;
2040  localInertia.setZero();
2042  if (shapePtr && *shapePtr)
2043  {
2044  btTransform startTransform;
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);
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
2070  {
2072  if (trimesh->getTriangleInfoMap())
2073  {
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 }
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
@ COMPOUND_SHAPE_PROXYTYPE
@ GIMPACT_SHAPE_PROXYTYPE
Used for GIMPACT Trimesh integration.
@ SOFTBODY_SHAPE_PROXYTYPE
@ SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE
@ TRIANGLE_MESH_SHAPE_PROXYTYPE
@ STATIC_PLANE_PROXYTYPE
@ SPHERE_SHAPE_PROXYTYPE
@ BOX_SHAPE_PROXYTYPE
@ MULTI_SPHERE_SHAPE_PROXYTYPE
@ CYLINDER_SHAPE_PROXYTYPE
@ CONE_SHAPE_PROXYTYPE
@ CAPSULE_SHAPE_PROXYTYPE
@ CONVEX_HULL_SHAPE_PROXYTYPE
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
@ PHY_FLOAT
@ PHY_UCHAR
@ PHY_DOUBLE
@ PHY_SHORT
@ PHY_INTEGER
@ CONST_GIMPACT_TRIMESH_SHAPE
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.
ContactAddedCallback gContactAddedCallback
This is to allow MaterialCombiner/Custom Friction/Restitution values.
bool(* ContactAddedCallback)(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
#define btAssert(x)
Definition: btScalar.h:153
@ SLIDER_CONSTRAINT_TYPE
@ GEAR_CONSTRAINT_TYPE
@ CONETWIST_CONSTRAINT_TYPE
@ FIXED_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
@ HINGE_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
@ D6_CONSTRAINT_TYPE
int size() const
return the number of elements in the array
void resize(int newsize, const T &fillData=T())
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
void push_back(const T &_Val)
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
Definition: btBoxShape.h:28
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
void setOptimizedBvh(btOptimizedBvh *bvh, const btVector3 &localScaling=btVector3(1, 1, 1))
const btTriangleInfoMap * getTriangleInfoMap() const
void setTriangleInfoMap(btTriangleInfoMap *triangleInfoMap)
btCapsuleShapeX represents a capsule around the Z axis the total height is height+2*radius,...
btCapsuleShapeZ represents a capsule around the Z axis the total height is height+2*radius,...
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
void deSerializeFloat(struct btCapsuleShapeData *dataBuffer)
btCollisionObject can be used to manage collision detection objects.
void setRestitution(btScalar rest)
void setCollisionFlags(int flags)
btTransform & getWorldTransform()
void setWorldTransform(const btTransform &worldTrans)
void setFriction(btScalar frict)
int getCollisionFlags() const
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
virtual void setMargin(btScalar margin)=0
int getShapeType() const
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const =0
bool isNonMoving() const
virtual void setLocalScaling(const btVector3 &scaling)=0
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
void addChildShape(const btTransform &localTransform, btCollisionShape *shape)
virtual void setMargin(btScalar collisionMargin)
btConeShape implements a Cone shape, around the X axis
Definition: btConeShape.h:108
btConeShapeZ implements a Cone shape, around the Z axis
Definition: btConeShape.h:126
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
Definition: btConeShape.h:26
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
void setLimit(int limitIndex, btScalar limitValue)
void setDamping(btScalar damping)
The btConvexHullShape implements an implicit convex hull of an array of vertices.
void addPoint(const btVector3 &point, bool recalculateLocalAabb=true)
virtual void setMargin(btScalar margin)
The btCylinderShape class implements a cylinder shape primitive, centered around the origin....
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
virtual void removeRigidBody(btRigidBody *body)=0
virtual void removeConstraint(btTypedConstraint *constraint)
virtual void addRigidBody(btRigidBody *body)=0
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
btContactSolverInfo & getSolverInfo()
virtual void setGravity(const btVector3 &gravity)=0
This class manages a mesh supplied by the btStridingMeshInterface interface.
virtual void setMargin(btScalar margin)
virtual void setLocalScaling(const btVector3 &scaling)
void updateBound()
performs refit operation
The btGeatConstraint will couple the angular velocity for two bodies around given local axis and rati...
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
void setLinearLowerLimit(const btVector3 &linearLower)
void setAngularLowerLimit(const btVector3 &angularLower)
void setAngularUpperLimit(const btVector3 &angularUpper)
void setLinearUpperLimit(const btVector3 &linearUpper)
void setStiffness(int index, btScalar stiffness, bool limitIfNeeded=true)
void setDamping(int index, btScalar damping, bool limitIfNeeded=true)
void setLinearUpperLimit(const btVector3 &linearUpper)
void setAngularUpperLimit(const btVector3 &angularUpper)
void setAngularLowerLimit(const btVector3 &angularLower)
void setLinearLowerLimit(const btVector3 &linearLower)
Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF.
void setDamping(int index, btScalar damping)
void setStiffness(int index, btScalar stiffness)
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:264
const Value * find(const Key &key) const
Definition: btHashMap.h:424
btHeightfieldTerrainShape simulates a 2D heightfield terrain
btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const float *heightfieldData, btScalar minHeight, btScalar maxHeight, int upAxis, bool flipQuadEdges)
preferred constructors
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
void setAngularOnly(bool angularOnly)
void setLimit(btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
ManifoldContactPoint collects and maintains persistent contactpoints.
The btMultiSphereShape represents the convex hull of a collection of spheres.
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes,...
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
virtual void deSerializeFloat(struct btQuantizedBvhFloatData &quantizedBvhFloatData)
virtual void deSerializeDouble(struct btQuantizedBvhDoubleData &quantizedBvhDoubleData)
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:60
void setLinearFactor(const btVector3 &linearFactor)
Definition: btRigidBody.h:258
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
void setMassProps(btScalar mass, const btVector3 &inertia)
void setAngularFactor(const btVector3 &angFac)
Definition: btRigidBody.h:568
The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMesh...
void setUseFrameOffset(bool frameOffsetOnOff)
void setLowerLinLimit(btScalar lowerLimit)
void setUpperLinLimit(btScalar upperLimit)
void setUpperAngLimit(btScalar upperLimit)
void setLowerAngLimit(btScalar lowerLimit)
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
Definition: btSphereShape.h:25
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane.
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
void setScaling(const btVector3 &scaling)
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:182
void deSerializeFloat(const struct btTransformFloatData &dataIn)
Definition: btTransform.h:274
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:113
void deSerializeDouble(const struct btTransformDoubleData &dataIn)
Definition: btTransform.h:280
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:166
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:146
The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing t...
void addIndexedMesh(const btIndexedMesh &mesh, PHY_ScalarType indexType=PHY_INTEGER)
virtual int getNumSubParts() const
getNumSubParts returns the number of separate subparts each subpart has a continuous array of vertice...
TypedConstraint is the baseclass for Bullet constraints and vehicles.
void setDbgDrawSize(btScalar dbgDrawSize)
void setEnabled(bool enabled)
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
void setBreakingImpulseThreshold(btScalar threshold)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
void deSerializeFloat(const struct btVector3FloatData &dataIn)
Definition: btVector3.h:1298
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
Definition: btVector3.h:1311
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
void setW(btScalar _w)
Set the w value.
Definition: btVector3.h:573
void setZero()
Definition: btVector3.h:671
char * duplicateName(const char *name)
btAlignedObjectArray< btTriangleIndexVertexArray * > m_allocatedTriangleIndexArrays
btAlignedObjectArray< char * > m_allocatedNames
virtual btCollisionObject * createCollisionObject(const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
btTypedConstraint * getConstraintByName(const char *name)
static btRigidBody & getFixedBody()
virtual btCollisionShape * createConeShapeY(btScalar radius, btScalar height)
btAlignedObjectArray< btCollisionObject * > m_allocatedRigidBodies
int getNumBvhs() const
virtual btCollisionShape * createCapsuleShapeY(btScalar radius, btScalar height)
btTypedConstraint * getConstraintByIndex(int index) const
virtual btOptimizedBvh * createOptimizedBvh()
acceleration and connectivity structures
virtual class btScaledBvhTriangleMeshShape * createScaledTrangleMeshShape(btBvhTriangleMeshShape *meshShape, const btVector3 &localScalingbtBvhTriangleMeshShape)
virtual btRigidBody * createRigidBody(bool isDynamic, btScalar mass, const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
void convertConstraintBackwardsCompatible281(btTypedConstraintData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
btRigidBody * getRigidBodyByName(const char *name)
virtual class btConvexHullShape * createConvexHullShape()
virtual btCollisionShape * createConvexTriangleMeshShape(btStridingMeshInterface *trimesh)
const char * getNameForPointer(const void *ptr) const
virtual btCollisionShape * createCapsuleShapeX(btScalar radius, btScalar height)
virtual btCollisionShape * createPlaneShape(const btVector3 &planeNormal, btScalar planeConstant)
shapes
btAlignedObjectArray< btOptimizedBvh * > m_allocatedBvhs
btHashMap< btHashPtr, btOptimizedBvh * > m_bvhMap
btCollisionObject * getRigidBodyByIndex(int index) const
btCollisionShape * getCollisionShapeByIndex(int index)
btHashMap< btHashString, btTypedConstraint * > m_nameConstraintMap
virtual btConeTwistConstraint * createConeTwistConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
virtual class btMultiSphereShape * createMultiSphereShape(const btVector3 *positions, const btScalar *radi, int numSpheres)
virtual ~btWorldImporter()
virtual btStridingMeshInterfaceData * createStridingMeshInterfaceData(btStridingMeshInterfaceData *interfaceData)
btAlignedObjectArray< btTypedConstraint * > m_allocatedConstraints
void convertConstraintDouble(btTypedConstraintDoubleData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
virtual btGeneric6DofSpring2Constraint * createGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, int rotateOrder)
btAlignedObjectArray< unsigned char * > m_charIndexArrays
virtual btCollisionShape * createBoxShape(const btVector3 &halfExtents)
virtual void setDynamicsWorldInfo(const btVector3 &gravity, const btContactSolverInfo &solverInfo)
those virtuals are called by load and can be overridden by the user
int getNumRigidBodies() const
int getNumTriangleInfoMaps() const
virtual btTriangleIndexVertexArray * createMeshInterface(btStridingMeshInterfaceData &meshData)
btAlignedObjectArray< int * > m_indexArrays
virtual btGeneric6DofConstraint * createGeneric6DofConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
int getNumCollisionShapes() const
btAlignedObjectArray< btTriangleInfoMap * > m_allocatedTriangleInfoMaps
virtual btCollisionShape * createCylinderShapeY(btScalar radius, btScalar height)
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
virtual btGeneric6DofSpringConstraint * createGeneric6DofSpringConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
virtual btCollisionShape * createConeShapeX(btScalar radius, btScalar height)
btDynamicsWorld * m_dynamicsWorld
virtual btCollisionShape * createCylinderShapeX(btScalar radius, btScalar height)
void convertConstraintFloat(btTypedConstraintFloatData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
virtual class btCompoundShape * createCompoundShape()
btWorldImporter(btDynamicsWorld *world)
btTriangleInfoMap * getTriangleInfoMapByIndex(int index) const
btAlignedObjectArray< btCollisionShape * > m_allocatedCollisionShapes
virtual btGearConstraint * createGearConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &axisInA, const btVector3 &axisInB, btScalar ratio)
btHashMap< btHashString, btCollisionShape * > m_nameShapeMap
int getNumConstraints() const
btHashMap< btHashPtr, btCollisionShape * > m_shapeMap
virtual btCollisionShape * createConeShapeZ(btScalar radius, btScalar height)
virtual btHingeConstraint * createHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame, bool useReferenceFrameA=false)
btAlignedObjectArray< btVector3DoubleData * > m_doubleVertexArrays
btHashMap< btHashString, btRigidBody * > m_nameBodyMap
btCollisionShape * convertCollisionShape(btCollisionShapeData *shapeData)
virtual btCollisionShape * createSphereShape(btScalar radius)
btCollisionShape * getCollisionShapeByName(const char *name)
void convertRigidBodyDouble(btRigidBodyDoubleData *colObjData)
btAlignedObjectArray< btVector3FloatData * > m_floatVertexArrays
virtual class btTriangleIndexVertexArray * createTriangleMeshContainer()
virtual btBvhTriangleMeshShape * createBvhTriangleMeshShape(btStridingMeshInterface *trimesh, btOptimizedBvh *bvh)
btAlignedObjectArray< btStridingMeshInterfaceData * > m_allocatedbtStridingMeshInterfaceDatas
virtual btGImpactMeshShape * createGimpactShape(btStridingMeshInterface *trimesh)
btOptimizedBvh * getBvhByIndex(int index) const
void convertRigidBodyFloat(btRigidBodyFloatData *colObjData)
btHashMap< btHashPtr, btCollisionObject * > m_bodyMap
virtual btPoint2PointConstraint * createPoint2PointConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB)
constraints
virtual btCollisionShape * createCylinderShapeZ(btScalar radius, btScalar height)
virtual btTriangleInfoMap * createTriangleInfoMap()
virtual class btHeightfieldTerrainShape * createHeightfieldShape(int heightStickWidth, int heightStickLength, const void *heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, int heightDataType, bool flipQuadEdges)
virtual btCollisionShape * createCapsuleShapeZ(btScalar radius, btScalar height)
virtual btSliderConstraint * createSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btAlignedObjectArray< short int * > m_shortIndexArrays
btHashMap< btHashPtr, const char * > m_objectNameMap
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformDoubleData m_worldTransform
btTransformFloatData m_worldTransform
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformFloatData m_transform
btCollisionShapeData * m_childShape
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCompoundShapeChildData * m_childShapePtr
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btConeShape.h:144
this structure is not used, except for loading pre-2.82 .bullet files
btTransformFloatData m_rbBFrame
btTransformFloatData m_rbAFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3DoubleData * m_unscaledPointsDoublePtr
btVector3FloatData * m_unscaledPointsFloatPtr
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_implicitShapeDimensions
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btStridingMeshInterfaceData m_meshInterface
btVector3FloatData m_localScaling
btVector3DoubleData m_axisInA
btVector3DoubleData m_axisInB
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_axisInB
btVector3FloatData m_axisInA
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformDoubleData m_rbBFrame
btTransformDoubleData m_rbAFrame
this structure is not used, except for loading pre-2.82 .bullet files
btTransformDoubleData m_rbAFrame
btTransformDoubleData m_rbBFrame
btTransformFloatData m_rbAFrame
btTransformFloatData m_rbBFrame
The btIndexedMesh indexes a single vertex and index array.
PHY_ScalarType m_indexType
const unsigned char * m_vertexBase
const unsigned char * m_triangleIndexBase
PHY_ScalarType m_vertexType
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btShortIntIndexData * m_indices16
btCharIndexTripletData * m_3indices8
btVector3FloatData * m_vertices3f
btShortIntIndexTripletData * m_3indices16
btIntIndexData * m_indices32
btVector3DoubleData * m_vertices3d
btPositionAndRadius * m_localPositionArrayPtr
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 th...
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_pos
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:662
btCollisionObjectDoubleData m_collisionObjectData
Definition: btRigidBody.h:663
btVector3DoubleData m_linearFactor
Definition: btRigidBody.h:668
btVector3DoubleData m_angularFactor
Definition: btRigidBody.h:667
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:636
btVector3FloatData m_linearFactor
Definition: btRigidBody.h:642
btVector3FloatData m_angularFactor
Definition: btRigidBody.h:641
btCollisionObjectFloatData m_collisionObjectData
Definition: btRigidBody.h:637
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformFloatData m_rbBFrame
btTransformFloatData m_rbAFrame
btTransformDoubleData m_rbAFrame
btTransformDoubleData m_rbBFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_localScaling
btVector3FloatData m_planeNormal
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3DoubleData m_origin
Definition: btTransform.h:253
btVector3FloatData m_origin
Definition: btTransform.h:247
The btTriangleInfoMap stores edge angle information for some triangles. You can compute this informat...
void deSerialize(struct btTriangleInfoMapData &data)
fills the dataBuffer and returns the struct name (and 0 on failure)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btStridingMeshInterfaceData m_meshInterface
btQuantizedBvhDoubleData * m_quantizedDoubleBvh
btQuantizedBvhFloatData * m_quantizedFloatBvh
btTriangleInfoMapData * m_triangleInfoMap
this structure is not used, except for loading pre-2.82 .bullet files
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
double m_floats[4]
Definition: btVector3.h:1288