22 :m_dynamicsWorld(world),
196 shape = gimpactShape;
199 printf(
"unsupported gimpact sub type\n");
230 printf(
"error: wrong up axis for btCapsuleShape\n");
274 btVector3 halfExtents = implicitShapeDimensions+margin;
294 printf(
"unknown Cylinder up axis\n");
306 btVector3 halfExtents = implicitShapeDimensions;
326 printf(
"unknown Cone up axis\n");
343 tmpPos.
resize(numSpheres);
345 for ( i=0;i<numSpheres;i++)
362 tmpPoints.
resize(numPoints);
364 for ( i=0;i<numPoints;i++)
366 #ifdef BT_USE_DOUBLE_PRECISION 376 #endif //BT_USE_DOUBLE_PRECISION 379 for (i=0;i<numPoints;i++)
390 printf(
"error: cannot create shape type (%d)\n",shapeData->
m_shapeType);
424 if (bvhPtr && *bvhPtr)
436 if (bvhPtr && *bvhPtr)
450 shape = trimeshShape;
458 #ifdef USE_INTERNAL_EDGE_UTILITY 460 #endif //USE_INTERNAL_EDGE_UTILITY 488 printf(
"error: couldn't create childShape for compoundShape\n");
493 shape = compoundShape;
504 printf(
"unsupported shape type (%d)\n",shapeData->
m_shapeType);
519 int l = (int)strlen(name);
520 char* newName =
new char[l+1];
521 memcpy(newName,name,l);
602 constraint = coneTwist;
621 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
626 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
632 angLowerLimit.
setW(0.f);
675 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
681 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
723 printf(
"unknown constraint type\n");
731 if (fileVersion>=280)
738 if (constraintData->
m_name)
821 constraint = coneTwist;
840 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
845 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
851 angLowerLimit.
setW(0.f);
893 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
899 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
972 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
977 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
983 angLowerLimit.
setW(0.f);
1040 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1048 printf(
"unknown constraint type\n");
1056 if (fileVersion>=280)
1063 if (constraintData->
m_name)
1150 constraint = coneTwist;
1169 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
1174 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
1180 angLowerLimit.
setW(0.f);
1187 if (fileVersion>280)
1222 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
1228 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
1264 constraint = slider;
1302 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1307 btVector3 angLowerLimit,angUpperLimit, linLowerLimit,linUpperlimit;
1313 angLowerLimit.
setW(0.f);
1320 if (fileVersion>280)
1370 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1379 printf(
"unknown constraint type\n");
1387 if (fileVersion>=280)
1394 if (constraintData->
m_name)
1504 meshPart.
m_vertexBase = (
const unsigned char*)vertices;
1521 meshPart.
m_vertexBase = (
const unsigned char*)vertices;
1530 return meshInterface;
1570 bool uninitialized3indices8Workaround =
false;
1574 uninitialized3indices8Workaround=
true;
1583 uninitialized3indices8Workaround=
true;
1592 uninitialized3indices8Workaround=
true;
1599 if(!uninitialized3indices8Workaround && curPart->
m_3indices8)
1614 #ifdef USE_INTERNAL_EDGE_UTILITY 1625 #endif //USE_INTERNAL_EDGE_UTILITY 1951 if (shapePtr&& *shapePtr)
1961 if (bodyPtr && *bodyPtr)
1971 if (constraintPtr && *constraintPtr)
1973 return *constraintPtr;
1981 if (namePtr && *namePtr)
2032 if (shapePtr && *shapePtr)
2048 bool isDynamic = mass!=0.f;
2058 #ifdef USE_INTERNAL_EDGE_UTILITY 2067 #endif //USE_INTERNAL_EDGE_UTILITY 2071 printf(
"error: no shape found\n");
2081 if (shapePtr && *shapePtr)
2097 bool isDynamic = mass!=0.f;
2108 #ifdef USE_INTERNAL_EDGE_UTILITY 2117 #endif //USE_INTERNAL_EDGE_UTILITY 2121 printf(
"error: no shape found\n");
btTransformFloatData m_worldTransform
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
btTransformDoubleData m_rbBFrame
double m_angularUpperLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
virtual btGeneric6DofSpringConstraint * createGeneric6DofSpringConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
void setLimit(int limitIndex, btScalar limitValue)
btTransformFloatData m_rbAFrame
btVector3FloatData m_angularUpperLimit
btTransformDoubleData m_rbAFrame
btVector3DoubleData m_pivotInA
btMeshPartData * m_meshPartsPtr
double m_springStiffness[6]
btTransformDoubleData m_rbBFrame
virtual btGeneric6DofConstraint * createGeneric6DofConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
void push_back(const T &_Val)
void setUpperLinLimit(btScalar upperLimit)
void convertConstraintBackwardsCompatible281(btTypedConstraintData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
char m_angularSpringDampingLimited[4]
btCompoundShapeChildData * m_childShapePtr
btCollisionShape * convertCollisionShape(btCollisionShapeData *shapeData)
double m_angularLowerLimit
virtual btStridingMeshInterfaceData * createStridingMeshInterfaceData(btStridingMeshInterfaceData *interfaceData)
btGeneric6DofConstraintDoubleData2 m_6dofData
double m_breakingImpulseThreshold
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
btTransformFloatData m_rbAFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
virtual class btTriangleIndexVertexArray * createTriangleMeshContainer()
void convertRigidBodyDouble(btRigidBodyDoubleData *colObjData)
virtual btBvhTriangleMeshShape * createBvhTriangleMeshShape(btStridingMeshInterface *trimesh, btOptimizedBvh *bvh)
btVector3DoubleData m_linearEquilibriumPoint
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
virtual btCollisionShape * createSphereShape(btScalar radius)
const btTriangleInfoMap * getTriangleInfoMap() const
void setLowerLinLimit(btScalar lowerLimit)
int getNumCollisionShapes() const
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const =0
virtual btConeTwistConstraint * createConeTwistConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
virtual btTriangleInfoMap * createTriangleInfoMap()
The btIndexedMesh indexes a single vertex and index array.
const char * getNameForPointer(const void *ptr) const
void convertRigidBodyFloat(btRigidBodyFloatData *colObjData)
void setLowerAngLimit(btScalar lowerLimit)
btVector3FloatData m_angularFactor
virtual btCollisionShape * createCylinderShapeZ(btScalar radius, btScalar height)
virtual void setLocalScaling(const btVector3 &scaling)
btVector3FloatData m_linearSpringStiffness
btVector3FloatData m_linearEquilibriumPoint
btAlignedObjectArray< unsigned char * > m_charIndexArrays
float m_breakingImpulseThreshold
btVector3DoubleData m_linearSpringDamping
btVector3FloatData m_linearLowerLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btOptimizedBvh * getBvhByIndex(int index) const
btTransformFloatData m_rbBFrame
double m_motorTargetVelocity
int m_localPositionArraySize
btVector3DoubleData m_linearUpperLimit
float m_motorTargetVelocity
The btGeatConstraint will couple the angular velocity for two bodies around given local axis and rati...
The btMultiSphereShape represents the convex hull of a collection of spheres.
virtual btRigidBody * createRigidBody(bool isDynamic, btScalar mass, const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
btTriangleMeshShapeData m_trimeshShapeData
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
btWorldImporter(btDynamicsWorld *world)
char m_angularSpringStiffnessLimited[4]
btTransformDoubleData m_rbAFrame
int m_disableCollisionsBetweenLinkedBodies
int m_disableCollisionsBetweenLinkedBodies
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
btVector3DoubleData * m_unscaledPointsDoublePtr
int getNumTriangleInfoMaps() const
this structure is not used, except for loading pre-2.82 .bullet files
The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc.
char m_linearEnableSpring[4]
btVector3FloatData m_angularLowerLimit
virtual class btConvexHullShape * createConvexHullShape()
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btCapsuleShapeX represents a capsule around the Z axis the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps.
btVector3FloatData m_linearLowerLimit
btConeShape implements a Cone shape, around the X axis
btVector3DoubleData m_angularEquilibriumPoint
btHashMap< btHashString, btCollisionShape * > m_nameShapeMap
btAlignedObjectArray< short int * > m_shortIndexArrays
void setDamping(btScalar damping)
virtual btCollisionShape * createConvexTriangleMeshShape(btStridingMeshInterface *trimesh)
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
void setScaling(const btVector3 &scaling)
virtual btCollisionShape * createCapsuleShapeY(btScalar radius, btScalar height)
virtual btCollisionShape * createCylinderShapeX(btScalar radius, btScalar height)
btCollisionShape * getCollisionShapeByName(const char *name)
btTransformFloatData m_rbBFrame
int m_disableCollisionsBetweenLinkedBodies
btVector3FloatData m_pivotInA
void setAngularUpperLimit(const btVector3 &angularUpper)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
ManifoldContactPoint collects and maintains persistent contactpoints.
int getCollisionFlags() const
void setUseFrameOffset(bool frameOffsetOnOff)
btStridingMeshInterfaceData m_meshInterface
virtual void setGravity(const btVector3 &gravity)=0
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btVector3DoubleData m_axisInB
btVector3FloatData * m_vertices3f
double m_relaxationFactor
void setLinearFactor(const btVector3 &linearFactor)
virtual btCollisionShape * createCylinderShapeY(btScalar radius, btScalar height)
btAlignedObjectArray< btOptimizedBvh * > m_allocatedBvhs
btVector3DoubleData m_linearLowerLimit
btVector3FloatData m_axisInB
virtual btCollisionShape * createConeShapeX(btScalar radius, btScalar height)
void addChildShape(const btTransform &localTransform, btCollisionShape *shape)
This class manages a mesh supplied by the btStridingMeshInterface interface.
void setStiffness(int index, btScalar stiffness)
Used for GIMPACT Trimesh integration.
double m_linearLowerLimit
btTriangleInfoMapData * m_triangleInfoMap
virtual void setMargin(btScalar collisionMargin)
virtual btCollisionShape * createCapsuleShapeZ(btScalar radius, btScalar height)
btTransformFloatData m_rbBFrame
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
btTransformFloatData m_rbBFrame
void setRestitution(btScalar rest)
btCollisionObjectFloatData m_collisionObjectData
btVector3DoubleData m_linearFactor
virtual btCollisionShape * createPlaneShape(const btVector3 &planeNormal, btScalar planeConstant)
shapes
btAlignedObjectArray< btTriangleInfoMap * > m_allocatedTriangleInfoMaps
float m_angularUpperLimit
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
PHY_ScalarType m_indexType
btGeneric6DofConstraintData m_6dofData
const btScalar & getZ() const
Return the z value.
btShortIntIndexData * m_indices16
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
btTypedConstraint * getConstraintByName(const char *name)
virtual void addRigidBody(btRigidBody *body)=0
btCharIndexTripletData * m_3indices8
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void setBreakingImpulseThreshold(btScalar threshold)
btVector3DoubleData m_pivotInA
virtual class btCompoundShape * createCompoundShape()
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
void setDbgDrawSize(btScalar dbgDrawSize)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
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.
The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing t...
btTransform & getWorldTransform()
virtual void setMargin(btScalar margin)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
char m_angularEnableSpring[4]
btVector3DoubleData m_angularLowerLimit
btVector3FloatData m_angularLowerLimit
btHashMap< btHashPtr, btOptimizedBvh * > m_bvhMap
int size() const
return the number of elements in the array
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
virtual void removeConstraint(btTypedConstraint *constraint)
btShortIntIndexTripletData * m_3indices16
btVector3FloatData m_linearUpperLimit
btAlignedObjectArray< btVector3DoubleData * > m_doubleVertexArrays
btAlignedObjectArray< btStridingMeshInterfaceData * > m_allocatedbtStridingMeshInterfaceDatas
int m_useLinearReferenceFrameA
void addIndexedMesh(const btIndexedMesh &mesh, PHY_ScalarType indexType=PHY_INTEGER)
btTypedConstraint * getConstraintByIndex(int index) const
int m_triangleIndexStride
float m_motorTargetVelocity
virtual btGImpactMeshShape * createGimpactShape(btStridingMeshInterface *trimesh)
btHashMap< btHashString, btTypedConstraint * > m_nameConstraintMap
void setFriction(btScalar frict)
int m_useOffsetForConstraintFrame
virtual btGearConstraint * createGearConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &axisInA, const btVector3 &axisInB, btScalar ratio)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
double m_relaxationFactor
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void enableSpring(int index, bool onOff)
int m_useLinearReferenceFrameA
int getNumConstraints() const
virtual void deSerializeDouble(struct btQuantizedBvhDoubleData &quantizedBvhDoubleData)
btVector3DoubleData m_angularLowerLimit
char m_linearSpringStiffnessLimited[4]
btVector3FloatData m_linearUpperLimit
btVector3FloatData m_pivotInB
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
virtual btCollisionShape * createConeShapeZ(btScalar radius, btScalar height)
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
virtual btOptimizedBvh * createOptimizedBvh()
acceleration and connectivity structures
void setEquilibriumPoint()
void setDamping(int index, btScalar damping)
unsigned char m_values[3]
btHashMap< btHashPtr, btCollisionShape * > m_shapeMap
btPositionAndRadius * m_localPositionArrayPtr
btStridingMeshInterfaceData m_meshInterface
void setW(btScalar _w)
Set the w value.
virtual void removeRigidBody(btRigidBody *body)=0
btTransformFloatData m_transform
void setUpperAngLimit(btScalar upperLimit)
const btScalar & getY() const
Return the y value.
char * duplicateName(const char *name)
#define btAlignedFree(ptr)
btCollisionObject can be used to manage collision detection objects.
virtual btCollisionShape * createBoxShape(const btVector3 &halfExtents)
void setOptimizedBvh(btOptimizedBvh *bvh, const btVector3 &localScaling=btVector3(1, 1, 1))
const btScalar & getX() const
Return the x value.
void insert(const Key &key, const Value &value)
btAlignedObjectArray< btTypedConstraint * > m_allocatedConstraints
virtual class btScaledBvhTriangleMeshShape * createScaledTrangleMeshShape(btBvhTriangleMeshShape *meshShape, const btVector3 &localScalingbtBvhTriangleMeshShape)
btVector3DoubleData m_angularUpperLimit
virtual btGeneric6DofSpring2Constraint * createGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, int rotateOrder)
The btRigidBody is the main class for rigid body objects.
double m_linearUpperLimit
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface.
int m_useLinearReferenceFrameA
btVector3FloatData m_localScaling
btVector3DoubleData m_linearLowerLimit
btVector3FloatData m_scaling
int m_useLinearReferenceFrameA
virtual void setMargin(btScalar margin)=0
void setEquilibriumPoint()
virtual btCollisionObject * createCollisionObject(const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
const unsigned char * m_triangleIndexBase
char m_linearSpringStiffnessLimited[4]
void setLinearUpperLimit(const btVector3 &linearUpper)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
this structure is not used, except for loading pre-2.82 .bullet files
void setLinearLowerLimit(const btVector3 &linearLower)
btVector3DoubleData m_angularFactor
btTransformDoubleData m_rbAFrame
void setAngularLowerLimit(const btVector3 &angularLower)
void setWorldTransform(const btTransform &worldTrans)
btVector3FloatData m_implicitShapeDimensions
btVector3FloatData * m_unscaledPointsFloatPtr
btAlignedObjectArray< int * > m_indexArrays
btVector3FloatData m_localScaling
virtual void setLocalScaling(const btVector3 &scaling)=0
void convertConstraintFloat(btTypedConstraintFloatData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
btQuantizedBvhDoubleData * m_quantizedDoubleBvh
btVector3DoubleData m_axisInA
btVector3FloatData m_axisInA
virtual void setDynamicsWorldInfo(const btVector3 &gravity, const btContactSolverInfo &solverInfo)
those virtuals are called by load and can be overridden by the user
btTransformDoubleData m_rbBFrame
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
virtual btTriangleIndexVertexArray * createMeshInterface(btStridingMeshInterfaceData &meshData)
virtual btCollisionShape * createConeShapeY(btScalar radius, btScalar height)
btVector3 can be used to represent 3D points and vectors.
btTriangleInfoMap * getTriangleInfoMapByIndex(int index) const
const Value * find(const Key &key) const
bool(* ContactAddedCallback)(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)
btVector3FloatData m_linearSpringDamping
char m_angularSpringStiffnessLimited[4]
virtual btPoint2PointConstraint * createPoint2PointConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB)
constraints
void setAngularOnly(bool angularOnly)
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) ...
int m_overrideNumSolverIterations
void setMassProps(btScalar mass, const btVector3 &inertia)
float m_breakingImpulseThreshold
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
btConeShapeZ implements a Cone shape, around the Z axis
btAlignedObjectArray< char * > m_allocatedNames
void setCollisionFlags(int flags)
btTransformFloatData m_rbAFrame
btCollisionObjectDoubleData m_collisionObjectData
btVector3FloatData m_angularEquilibriumPoint
btTransformDoubleData m_rbAFrame
btTransformDoubleData m_worldTransform
virtual void deSerializeFloat(struct btQuantizedBvhFloatData &quantizedBvhFloatData)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
float m_equilibriumPoint[6]
TypedConstraint is the baseclass for Bullet constraints and vehicles.
void setLimit(btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
void resize(int newsize, const T &fillData=T())
btTransformFloatData m_rbAFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
static btRigidBody & getFixedBody()
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
void setStiffness(int index, btScalar stiffness, bool limitIfNeeded=true)
void setEnabled(bool enabled)
double m_equilibriumPoint[6]
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btVector3DoubleData m_angularUpperLimit
btVector3DoubleData m_pivotInB
btAlignedObjectArray< btCollisionShape * > m_allocatedCollisionShapes
void deSerialize(struct btTriangleInfoMapData &data)
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual btHingeConstraint * createHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame, bool useReferenceFrameA=false)
btVector3FloatData m_localScaling
btVector3DoubleData m_angularSpringStiffness
The btCylinderShape class implements a cylinder shape primitive, centered around the origin...
float m_springStiffness[6]
virtual int getNumSubParts() const
getNumSubParts returns the number of seperate subparts each subpart has a continuous array of vertice...
ContactAddedCallback gContactAddedCallback
This is to allow MaterialCombiner/Custom Friction/Restitution values.
double m_springDamping[6]
The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMesh...
void setLinearLowerLimit(const btVector3 &linearLower)
btVector3DoubleData m_linearUpperLimit
btVector3FloatData m_angularSpringStiffness
btVector3DoubleData m_linearSpringStiffness
btCollisionShape * getCollisionShapeByIndex(int index)
btRigidBody * getRigidBodyByName(const char *name)
btTransformDoubleData m_rbBFrame
#define btAlignedAlloc(size, alignment)
btHashMap< btHashPtr, btCollisionObject * > m_bodyMap
btVector3DoubleData m_angularSpringDamping
btCapsuleShapeZ represents a capsule around the Z axis the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps.
btIntIndexData * m_indices32
void deSerializeFloat(struct btCapsuleShapeData *dataBuffer)
void setTriangleInfoMap(btTriangleInfoMap *triangleInfoMap)
btVector3FloatData m_planeNormal
btTransformDoubleData m_rbBFrame
void addPoint(const btVector3 &point, bool recalculateLocalAabb=true)
virtual btSliderConstraint * createSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
this structure is not used, except for loading pre-2.82 .bullet files
The btConvexHullShape implements an implicit convex hull of an array of vertices. ...
void enableSpring(int index, bool onOff)
void setAngularUpperLimit(const btVector3 &angularUpper)
The btTriangleInfoMap stores edge angle information for some triangles. You can compute this informat...
int getNumRigidBodies() const
btQuantizedBvhFloatData * m_quantizedFloatBvh
btTransformDoubleData m_rbAFrame
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
char m_angularSpringDampingLimited[4]
void updateBound()
performs refit operation
void deSerializeFloat(const struct btVector3FloatData &dataIn)
btCollisionShapeData * m_childShape
btAlignedObjectArray< btTriangleIndexVertexArray * > m_allocatedTriangleIndexArrays
char m_linearEnableSpring[4]
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 th...
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. ...
char m_linearSpringDampingLimited[4]
btAlignedObjectArray< btCollisionObject * > m_allocatedRigidBodies
void setLinearUpperLimit(const btVector3 &linearUpper)
virtual ~btWorldImporter()
btTransformDoubleData m_rbAFrame
btVector3FloatData m_localScaling
btVector3FloatData m_angularUpperLimit
btDynamicsWorld * m_dynamicsWorld
btTransformFloatData m_rbAFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void setDamping(int index, btScalar damping, bool limitIfNeeded=true)
btAlignedObjectArray< btVector3FloatData * > m_floatVertexArrays
void setAngularFactor(const btVector3 &angFac)
int m_overrideNumSolverIterations
btHashMap< btHashPtr, const char * > m_objectNameMap
btContactSolverInfo & getSolverInfo()
virtual btCollisionShape * createCapsuleShapeX(btScalar radius, btScalar height)
char m_linearSpringDampingLimited[4]
char m_angularEnableSpring[4]
void setAngularLowerLimit(const btVector3 &angularLower)
Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF...
float m_angularLowerLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btHashMap< btHashString, btRigidBody * > m_nameBodyMap
virtual class btMultiSphereShape * createMultiSphereShape(const btVector3 *positions, const btScalar *radi, int numSpheres)
int m_overrideNumSolverIterations
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btVector3FloatData m_angularSpringDamping
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void convertConstraintDouble(btTypedConstraintDoubleData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
PHY_ScalarType m_vertexType
int m_useOffsetForConstraintFrame
btVector3FloatData m_linearFactor
const unsigned char * m_vertexBase
void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
btCollisionObject * getRigidBodyByIndex(int index) const
btTransformFloatData m_rbBFrame
btVector3DoubleData m_pivotInB
virtual void setMargin(btScalar margin)
btTransformDoubleData m_rbBFrame
btVector3DoubleData * m_vertices3d