Bullet Collision Detection & Physics Library
|
Go to the documentation of this file.
23 : m_dynamicsWorld(world),
187 shape = gimpactShape;
191 printf(
"unsupported gimpact sub type\n");
221 printf(
"error: wrong up axis for btCapsuleShape\n");
263 btVector3 halfExtents = implicitShapeDimensions + margin;
283 printf(
"unknown Cylinder up axis\n");
292 btVector3 halfExtents = implicitShapeDimensions;
312 printf(
"unknown Cone up axis\n");
326 tmpPos.
resize(numSpheres);
328 for (i = 0; i < numSpheres; i++)
345 tmpPoints.
resize(numPoints);
347 for (i = 0; i < numPoints; i++)
349 #ifdef BT_USE_DOUBLE_PRECISION
359 #endif //BT_USE_DOUBLE_PRECISION
362 for (i = 0; i < numPoints; i++)
373 printf(
"error: cannot create shape type (%d)\n", shapeData->
m_shapeType);
406 if (bvhPtr && *bvhPtr)
419 if (bvhPtr && *bvhPtr)
433 shape = trimeshShape;
441 #ifdef USE_INTERNAL_EDGE_UTILITY
443 #endif //USE_INTERNAL_EDGE_UTILITY
469 printf(
"error: couldn't create childShape for compoundShape\n");
473 shape = compoundShape;
484 printf(
"unsupported shape type (%d)\n", shapeData->
m_shapeType);
496 int l = (int)strlen(name);
497 char* newName =
new char[l + 1];
498 memcpy(newName, name, l);
580 constraint = coneTwist;
599 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
604 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
610 angLowerLimit.
setW(0.f);
617 if (fileVersion > 280)
619 for (i = 0; i < 6; i++)
654 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
660 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
703 printf(
"unknown constraint type\n");
711 if (fileVersion >= 280)
718 if (constraintData->
m_name)
801 constraint = coneTwist;
820 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
825 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
831 angLowerLimit.
setW(0.f);
838 if (fileVersion > 280)
840 for (i = 0; i < 6; i++)
875 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
881 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
956 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
961 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
967 angLowerLimit.
setW(0.f);
974 if (fileVersion > 280)
977 for (i = 0; i < 3; i++)
984 for (i = 0; i < 3; i++)
1020 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1028 printf(
"unknown constraint type\n");
1036 if (fileVersion >= 280)
1043 if (constraintData->
m_name)
1128 constraint = coneTwist;
1147 printf(
"Error in btWorldImporter::createGeneric6DofSpringConstraint: requires rbA && rbB\n");
1152 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1158 angLowerLimit.
setW(0.f);
1165 if (fileVersion > 280)
1167 for (i = 0; i < 6; i++)
1202 printf(
"Error in btWorldImporter::createGeneric6DofConstraint: missing rbB\n");
1208 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1245 constraint = slider;
1284 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1289 btVector3 angLowerLimit, angUpperLimit, linLowerLimit, linUpperlimit;
1295 angLowerLimit.
setW(0.f);
1302 if (fileVersion > 280)
1305 for (i = 0; i < 3; i++)
1312 for (i = 0; i < 3; i++)
1348 printf(
"Error in btWorldImporter::createGeneric6DofSpring2Constraint: requires rbA && rbB\n");
1357 printf(
"unknown constraint type\n");
1365 if (fileVersion >= 280)
1372 if (constraintData->
m_name)
1471 meshPart.
m_vertexBase = (
const unsigned char*)vertices;
1488 meshPart.
m_vertexBase = (
const unsigned char*)vertices;
1497 return meshInterface;
1536 bool uninitialized3indices8Workaround =
false;
1540 uninitialized3indices8Workaround =
true;
1549 uninitialized3indices8Workaround =
true;
1558 uninitialized3indices8Workaround =
true;
1565 if (!uninitialized3indices8Workaround && curPart->
m_3indices8)
1579 #ifdef USE_INTERNAL_EDGE_UTILITY
1589 #endif //USE_INTERNAL_EDGE_UTILITY
1789 const void* heightfieldData,
btScalar heightScale,
1791 int upAxis,
int heightDataType,
1796 heightfieldData, heightScale, minHeight, maxHeight, upAxis,
PHY_ScalarType(heightDataType), flipQuadEdges);
1913 if (shapePtr && *shapePtr)
1923 if (bodyPtr && *bodyPtr)
1933 if (constraintPtr && *constraintPtr)
1935 return *constraintPtr;
1943 if (namePtr && *namePtr)
1992 if (shapePtr && *shapePtr)
2008 bool isDynamic = mass != 0.f;
2018 #ifdef USE_INTERNAL_EDGE_UTILITY
2027 #endif //USE_INTERNAL_EDGE_UTILITY
2032 printf(
"error: no shape found\n");
2042 if (shapePtr && *shapePtr)
2058 bool isDynamic = mass != 0.f;
2068 #ifdef USE_INTERNAL_EDGE_UTILITY
2077 #endif //USE_INTERNAL_EDGE_UTILITY
2082 printf(
"error: no shape found\n");
float m_angularLowerLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
char m_angularSpringDampingLimited[4]
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
int m_useLinearReferenceFrameA
btShortIntIndexTripletData * m_3indices16
TypedConstraint is the baseclass for Bullet constraints and vehicles.
btCollisionObject * getRigidBodyByIndex(int index) const
btVector3FloatData m_linearUpperLimit
btCollisionObject can be used to manage collision detection objects.
float m_springStiffness[6]
char m_linearEnableSpring[4]
virtual btCollisionShape * createConeShapeZ(btScalar radius, btScalar height)
btTypedConstraint * getConstraintByName(const char *name)
virtual btStridingMeshInterfaceData * createStridingMeshInterfaceData(btStridingMeshInterfaceData *interfaceData)
The btRigidBody is the main class for rigid body objects.
void setAngularFactor(const btVector3 &angFac)
btVector3FloatData m_pivotInB
void setUseFrameOffset(bool frameOffsetOnOff)
btCollisionShapeData * m_childShape
int getNumRigidBodies() const
#define btAlignedFree(ptr)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_linearLowerLimit
virtual btCollisionShape * createBoxShape(const btVector3 &halfExtents)
void setLinearUpperLimit(const btVector3 &linearUpper)
btTransformFloatData m_rbBFrame
btVector3FloatData m_angularSpringDamping
btHashMap< btHashPtr, btCollisionObject * > m_bodyMap
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes,...
btTransformFloatData m_rbAFrame
virtual btCollisionShape * createSphereShape(btScalar radius)
btGeneric6DofConstraintData m_6dofData
double m_angularLowerLimit
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
btHashMap< btHashPtr, const char * > m_objectNameMap
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
btVector3FloatData * m_unscaledPointsFloatPtr
btVector3FloatData * m_vertices3f
int getNumConstraints() const
btTransformDoubleData m_rbBFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
double m_linearLowerLimit
btTransformDoubleData m_rbBFrame
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.
void convertRigidBodyDouble(btRigidBodyDoubleData *colObjData)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
double m_angularUpperLimit
btVector3DoubleData m_pivotInB
virtual btGeneric6DofSpring2Constraint * createGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, int rotateOrder)
btVector3FloatData m_angularLowerLimit
btVector3DoubleData m_linearLowerLimit
virtual ~btWorldImporter()
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
virtual btSliderConstraint * createSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btTransformFloatData m_transform
double m_springStiffness[6]
float m_breakingImpulseThreshold
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 th...
btVector3FloatData m_angularUpperLimit
PHY_ScalarType m_vertexType
char m_linearSpringDampingLimited[4]
virtual class btHeightfieldTerrainShape * createHeightfieldShape(int heightStickWidth, int heightStickLength, const void *heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, int heightDataType, bool flipQuadEdges)
btVector3FloatData m_linearFactor
void setScaling(const btVector3 &scaling)
btVector3DoubleData m_angularFactor
char m_angularEnableSpring[4]
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btAlignedObjectArray< char * > m_allocatedNames
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
btShortIntIndexData * m_indices16
ContactAddedCallback gContactAddedCallback
This is to allow MaterialCombiner/Custom Friction/Restitution values.
btCollisionObjectDoubleData m_collisionObjectData
btContactSolverInfo & getSolverInfo()
double m_motorTargetVelocity
virtual class btMultiSphereShape * createMultiSphereShape(const btVector3 *positions, const btScalar *radi, int numSpheres)
btCollisionShape * getCollisionShapeByName(const char *name)
void setStiffness(int index, btScalar stiffness, bool limitIfNeeded=true)
#define btAlignedAlloc(size, alignment)
btAlignedObjectArray< int * > m_indexArrays
btTransformDoubleData m_worldTransform
btVector3FloatData m_linearSpringStiffness
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
btHeightfieldTerrainShape simulates a 2D heightfield terrain
void setLowerAngLimit(btScalar lowerLimit)
btVector3FloatData m_angularFactor
virtual void setLocalScaling(const btVector3 &scaling)
int m_disableCollisionsBetweenLinkedBodies
This class manages a mesh supplied by the btStridingMeshInterface interface.
float m_angularUpperLimit
int m_useOffsetForConstraintFrame
void deSerialize(struct btTriangleInfoMapData &data)
fills the dataBuffer and returns the struct name (and 0 on failure)
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
const unsigned char * m_triangleIndexBase
int m_overrideNumSolverIterations
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
const char * getNameForPointer(const void *ptr) const
virtual btGearConstraint * createGearConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &axisInA, const btVector3 &axisInB, btScalar ratio)
btHashMap< btHashString, btCollisionShape * > m_nameShapeMap
static btRigidBody & getFixedBody()
int m_localPositionArraySize
btVector3FloatData m_axisInA
void convertConstraintFloat(btTypedConstraintFloatData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
btStridingMeshInterfaceData m_meshInterface
virtual btHingeConstraint * createHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame, bool useReferenceFrameA=false)
btVector3DoubleData m_linearEquilibriumPoint
void setDamping(int index, btScalar damping)
Used for GIMPACT Trimesh integration.
void setLinearFactor(const btVector3 &linearFactor)
btTransformFloatData m_rbAFrame
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
this structure is not used, except for loading pre-2.82 .bullet files
void setStiffness(int index, btScalar stiffness)
virtual class btTriangleIndexVertexArray * createTriangleMeshContainer()
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
const btScalar & getX() const
Return the x value.
btVector3DoubleData m_angularUpperLimit
void setOptimizedBvh(btOptimizedBvh *bvh, const btVector3 &localScaling=btVector3(1, 1, 1))
btTriangleInfoMapData * m_triangleInfoMap
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
btTransform & getWorldTransform()
char * duplicateName(const char *name)
btVector3DoubleData m_linearSpringStiffness
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3DoubleData m_angularSpringDamping
btTransformFloatData m_rbBFrame
btVector3FloatData m_axisInB
virtual void removeRigidBody(btRigidBody *body)=0
btVector3FloatData m_localScaling
btCapsuleShapeX represents a capsule around the Z axis the total height is height+2*radius,...
void setRestitution(btScalar rest)
void enableSpring(int index, bool onOff)
virtual void setMargin(btScalar collisionMargin)
void setAngularUpperLimit(const btVector3 &angularUpper)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
ManifoldContactPoint collects and maintains persistent contactpoints.
double m_breakingImpulseThreshold
btPositionAndRadius * m_localPositionArrayPtr
The btMultiSphereShape represents the convex hull of a collection of spheres.
btVector3FloatData m_angularUpperLimit
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
btDynamicsWorld * m_dynamicsWorld
Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF.
void setEquilibriumPoint()
btStridingMeshInterfaceData m_meshInterface
void setDbgDrawSize(btScalar dbgDrawSize)
void setAngularLowerLimit(const btVector3 &angularLower)
void resize(int newsize, const T &fillData=T())
btHashMap< btHashString, btRigidBody * > m_nameBodyMap
btVector3FloatData m_linearUpperLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
char m_linearEnableSpring[4]
The btTriangleInfoMap stores edge angle information for some triangles. You can compute this informat...
virtual void setMargin(btScalar margin)
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
virtual btCollisionShape * createConeShapeX(btScalar radius, btScalar height)
btTransformFloatData m_worldTransform
btCollisionShape * getCollisionShapeByIndex(int index)
virtual btGeneric6DofConstraint * createGeneric6DofConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
void convertRigidBodyFloat(btRigidBodyFloatData *colObjData)
virtual void addRigidBody(btRigidBody *body)=0
void setAngularOnly(bool angularOnly)
virtual btBvhTriangleMeshShape * createBvhTriangleMeshShape(btStridingMeshInterface *trimesh, btOptimizedBvh *bvh)
btVector3DoubleData m_pivotInB
The btGeatConstraint will couple the angular velocity for two bodies around given local axis and rati...
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
btCompoundShapeChildData * m_childShapePtr
void setFriction(btScalar frict)
char m_linearSpringStiffnessLimited[4]
virtual void deSerializeDouble(struct btQuantizedBvhDoubleData &quantizedBvhDoubleData)
void setWorldTransform(const btTransform &worldTrans)
int m_useLinearReferenceFrameA
void setLowerLinLimit(btScalar lowerLimit)
btVector3DoubleData m_angularLowerLimit
void enableSpring(int index, bool onOff)
btTransformFloatData m_rbAFrame
void setW(btScalar _w)
Set the w value.
char m_angularSpringDampingLimited[4]
char m_linearSpringStiffnessLimited[4]
virtual btTriangleIndexVertexArray * createMeshInterface(btStridingMeshInterfaceData &meshData)
void setBreakingImpulseThreshold(btScalar threshold)
void setEquilibriumPoint()
btQuantizedBvhDoubleData * m_quantizedDoubleBvh
int getCollisionFlags() const
bool(* ContactAddedCallback)(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)
btAlignedObjectArray< btTypedConstraint * > m_allocatedConstraints
btCollisionObjectFloatData m_collisionObjectData
The btIndexedMesh indexes a single vertex and index array.
float m_equilibriumPoint[6]
int m_overrideNumSolverIterations
btConeShapeZ implements a Cone shape, around the Z axis
btVector3DoubleData m_pivotInA
char m_angularEnableSpring[4]
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
float m_motorTargetVelocity
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
btVector3 can be used to represent 3D points and vectors.
virtual class btScaledBvhTriangleMeshShape * createScaledTrangleMeshShape(btBvhTriangleMeshShape *meshShape, const btVector3 &localScalingbtBvhTriangleMeshShape)
btTransformFloatData m_rbBFrame
void convertConstraintDouble(btTypedConstraintDoubleData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
int m_useLinearReferenceFrameA
virtual void setGravity(const btVector3 &gravity)=0
btTransformFloatData m_rbBFrame
btVector3DoubleData m_linearLowerLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
char m_angularSpringStiffnessLimited[4]
int m_triangleIndexStride
btVector3DoubleData m_angularSpringStiffness
btVector3DoubleData * m_vertices3d
btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const void *heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, PHY_ScalarType heightDataType, bool flipQuadEdges)
preferred constructor
double m_relaxationFactor
btAlignedObjectArray< btVector3FloatData * > m_floatVertexArrays
btVector3DoubleData m_linearUpperLimit
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btWorldImporter(btDynamicsWorld *world)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
int m_overrideNumSolverIterations
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
virtual void deSerializeFloat(struct btQuantizedBvhFloatData &quantizedBvhFloatData)
unsigned char m_values[3]
btTransformDoubleData m_rbAFrame
btVector3DoubleData m_linearUpperLimit
virtual btCollisionShape * createCapsuleShapeZ(btScalar radius, btScalar height)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3DoubleData m_angularUpperLimit
btAlignedObjectArray< btOptimizedBvh * > m_allocatedBvhs
btAlignedObjectArray< unsigned char * > m_charIndexArrays
void setTriangleInfoMap(btTriangleInfoMap *triangleInfoMap)
const btScalar & getZ() const
Return the z value.
btIntIndexData * m_indices32
btVector3DoubleData m_angularEquilibriumPoint
btTransformDoubleData m_rbAFrame
virtual class btConvexHullShape * createConvexHullShape()
btVector3DoubleData m_linearSpringDamping
btTransformDoubleData m_rbBFrame
const btScalar & getY() const
Return the y value.
void setUpperAngLimit(btScalar upperLimit)
int getNumCollisionShapes() const
btVector3FloatData m_linearSpringDamping
btTransformFloatData m_rbAFrame
virtual btCollisionShape * createCylinderShapeZ(btScalar radius, btScalar height)
const Value * find(const Key &key) const
virtual class btCompoundShape * createCompoundShape()
virtual btCollisionObject * createCollisionObject(const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
void setLimit(int limitIndex, btScalar limitValue)
double m_linearUpperLimit
void setLinearLowerLimit(const btVector3 &linearLower)
btQuantizedBvhFloatData * m_quantizedFloatBvh
btTransformFloatData m_rbAFrame
btVector3FloatData m_linearLowerLimit
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
float m_motorTargetVelocity
virtual btCollisionShape * createConeShapeY(btScalar radius, btScalar height)
btHashMap< btHashPtr, btCollisionShape * > m_shapeMap
btAlignedObjectArray< btCollisionShape * > m_allocatedCollisionShapes
The btConvexHullShape implements an implicit convex hull of an array of vertices.
int getNumTriangleInfoMaps() const
btAlignedObjectArray< btStridingMeshInterfaceData * > m_allocatedbtStridingMeshInterfaceDatas
void setMassProps(btScalar mass, const btVector3 &inertia)
int m_useLinearReferenceFrameA
virtual void setMargin(btScalar margin)=0
btTypedConstraint * getConstraintByIndex(int index) const
double m_relaxationFactor
btAlignedObjectArray< btTriangleIndexVertexArray * > m_allocatedTriangleIndexArrays
virtual btCollisionShape * createCylinderShapeY(btScalar radius, btScalar height)
void setCollisionFlags(int flags)
btVector3FloatData m_localScaling
void addChildShape(const btTransform &localTransform, btCollisionShape *shape)
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const =0
btVector3FloatData m_planeNormal
this structure is not used, except for loading pre-2.82 .bullet files
btOptimizedBvh * getBvhByIndex(int index) const
btVector3DoubleData * m_unscaledPointsDoublePtr
virtual void removeConstraint(btTypedConstraint *constraint)
void insert(const Key &key, const Value &value)
btVector3FloatData m_localScaling
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane.
btHashMap< btHashPtr, btOptimizedBvh * > m_bvhMap
btVector3DoubleData m_angularLowerLimit
btVector3FloatData m_angularEquilibriumPoint
virtual int getNumSubParts() const
getNumSubParts returns the number of separate subparts each subpart has a continuous array of vertice...
btMeshPartData * m_meshPartsPtr
char m_angularSpringStiffnessLimited[4]
virtual btOptimizedBvh * createOptimizedBvh()
acceleration and connectivity structures
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
void convertConstraintBackwardsCompatible281(btTypedConstraintData *constraintData, btRigidBody *rbA, btRigidBody *rbB, int fileVersion)
void addIndexedMesh(const btIndexedMesh &mesh, PHY_ScalarType indexType=PHY_INTEGER)
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
void setAngularLowerLimit(const btVector3 &angularLower)
void deSerializeFloat(struct btCapsuleShapeData *dataBuffer)
void setEnabled(bool enabled)
double m_equilibriumPoint[6]
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCollisionShape * convertCollisionShape(btCollisionShapeData *shapeData)
void setDamping(btScalar damping)
int m_disableCollisionsBetweenLinkedBodies
virtual void setMargin(btScalar margin)
btVector3FloatData m_scaling
virtual btPoint2PointConstraint * createPoint2PointConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB)
constraints
btTransformDoubleData m_rbAFrame
The btCylinderShape class implements a cylinder shape primitive, centered around the origin....
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
char m_linearSpringDampingLimited[4]
btTransformDoubleData m_rbAFrame
btHashMap< btHashString, btTypedConstraint * > m_nameConstraintMap
btVector3FloatData m_localScaling
void setDamping(int index, btScalar damping, bool limitIfNeeded=true)
btVector3DoubleData m_axisInB
void setLinearLowerLimit(const btVector3 &linearLower)
virtual void setLocalScaling(const btVector3 &scaling)=0
void deSerializeFloat(const struct btVector3FloatData &dataIn)
btTransformDoubleData m_rbBFrame
btVector3DoubleData m_axisInA
btTransformDoubleData m_rbAFrame
btTransformDoubleData m_rbBFrame
void addPoint(const btVector3 &point, bool recalculateLocalAabb=true)
const btTriangleInfoMap * getTriangleInfoMap() const
void setLimit(btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
virtual btGImpactMeshShape * createGimpactShape(btStridingMeshInterface *trimesh)
btVector3DoubleData m_pivotInA
The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing t...
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformFloatData m_rbBFrame
virtual btRigidBody * createRigidBody(bool isDynamic, btScalar mass, const btTransform &startTransform, btCollisionShape *shape, const char *bodyName)
void push_back(const T &_Val)
void setUpperLinLimit(btScalar upperLimit)
btVector3FloatData m_pivotInA
void setAngularUpperLimit(const btVector3 &angularUpper)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
virtual btCollisionShape * createConvexTriangleMeshShape(btStridingMeshInterface *trimesh)
void updateBound()
performs refit operation
const unsigned char * m_vertexBase
btTriangleInfoMap * getTriangleInfoMapByIndex(int index) const
btGeneric6DofConstraintDoubleData2 m_6dofData
int m_useOffsetForConstraintFrame
virtual btCollisionShape * createCapsuleShapeX(btScalar radius, btScalar height)
btRigidBody * getRigidBodyByName(const char *name)
void setLinearUpperLimit(const btVector3 &linearUpper)
float m_breakingImpulseThreshold
btVector3FloatData m_angularSpringStiffness
virtual void setDynamicsWorldInfo(const btVector3 &gravity, const btContactSolverInfo &solverInfo)
those virtuals are called by load and can be overridden by the user
void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
this structure is not used, except for loading pre-2.82 .bullet files
btAlignedObjectArray< short int * > m_shortIndexArrays
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMesh...
int m_disableCollisionsBetweenLinkedBodies
btAlignedObjectArray< btCollisionObject * > m_allocatedRigidBodies
virtual btCollisionShape * createCapsuleShapeY(btScalar radius, btScalar height)
btTransformDoubleData m_rbAFrame
btTransformDoubleData m_rbBFrame
btAlignedObjectArray< btVector3DoubleData * > m_doubleVertexArrays
virtual btTriangleInfoMap * createTriangleInfoMap()
virtual btCollisionShape * createCylinderShapeX(btScalar radius, btScalar height)
virtual btConeTwistConstraint * createConeTwistConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
btCapsuleShapeZ represents a capsule around the Z axis the total height is height+2*radius,...
double m_springDamping[6]
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
btVector3FloatData m_linearEquilibriumPoint
virtual btCollisionShape * createPlaneShape(const btVector3 &planeNormal, btScalar planeConstant)
shapes
PHY_ScalarType m_indexType
btVector3FloatData m_angularLowerLimit
btTriangleMeshShapeData m_trimeshShapeData
btVector3FloatData m_implicitShapeDimensions
btConeShape implements a Cone shape, around the X axis
int size() const
return the number of elements in the array
btCharIndexTripletData * m_3indices8
btVector3DoubleData m_linearFactor
virtual btGeneric6DofSpringConstraint * createGeneric6DofSpringConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btAlignedObjectArray< btTriangleInfoMap * > m_allocatedTriangleInfoMaps