Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_cl_image_format
addr64This file provides some platform/compiler checks for common definitions
btDX11SoftBodySolver::AddVelocityCB
btSoftBody::AJoint
btCollisionWorld::AllHitsRayResultCallback
btSoftBody::Anchor
btOpenCLSoftBodySolver::AnchorNodeInfoCL
btDX11SoftBodySolver::ApplyForcesCB
btSoftBodyLinkDataDX11::BatchPair
btSoftBodyTriangleDataDX11::BatchPair
btSoftBodyLinkDataDX11SIMDAware::BatchPair
btSoftBodyLinkDataOpenCL::BatchPair
btSoftBodyLinkDataOpenCLSIMDAware::BatchPair
btSoftBody::Body
Vectormath::boolInVec
BoxThe Box is an internal class used by the boxBoxDistance calculation
BoxPointInternally used class to contain feature information for boxBoxDistance calculation
BroadphaseAabbTester
BroadphaseRayTester
bt32BitAxisSweep3The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune
bt3DGrid3F1U
bt3DGridBroadphaseParams
BT_BOX_BOX_TRANSFORM_CACHEClass for transforming a model1 to the space of model0
BT_QUANTIZED_BVH_NODEBtQuantizedBvhNode is a compressed aabb node, 16 bytes
btAABBAxis aligned box
btDX11SoftBodySolver::btAcceleratedSoftBodyInterfaceSoftBody class to maintain information about a soft body instance within a solver
btActionInterfaceBasic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWorld
btActivatingCollisionAlgorithmThis class is not enabled yet (work-in-progress) to more aggressively activate objects
btAlignedAllocator< T, Alignment >The btAlignedAllocator is a portable class for aligned memory allocations
btAlignedObjectArray< T >The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data
btAngleCompareFunc
btAngularLimit
btAxisSweep3The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase
btAxisSweep3Internal< BP_FP_INT_TYPE >The internal templace class btAxisSweep3Internal implements the sweep and prune broadphase
btBarrier
btBlockInternal structure for the btStackAlloc memory allocator
btBox2dBox2dCollisionAlgorithmBox-box collision detection
btBox2dShapeThe btBox2dShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space
btBoxBoxCollisionAlgorithmBox-box collision detection
btBoxBoxDetectorBtBoxBoxDetector wraps the ODE box-box collision detector re-distributed under the Zlib license with permission from Russell L
btBoxShapeThe btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space
btBridgedManifoldResult
btMultiSapBroadphase::btBridgeProxy
btBroadphaseAabbCallback
btBroadphaseInterfaceInterface to detect aabb-overlapping object pairs
btBroadphasePairPair of aabb-overlapping objects
btBroadphasePairSortPredicate
btBroadphaseProxyThe btBroadphaseProxy is the main class that can be used with the Bullet broadphases
btBroadphaseRayCallback
btBU_Simplex1to4The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead
btBvhSubtreeInfoBtBvhSubtreeInfo provides info to gather a subtree of limited size
btBvhSubtreeInfoData
btBvhTreeBasic Box tree structure
btBvhTriangleMeshShapeThe btBvhTriangleMeshShape is a static-triangle mesh shape with several optimizations, such as bounding volume hierarchy and cache friendly traversal for PlayStation 3 Cell SPU
btCapsuleShapeThe btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis
btCapsuleShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCapsuleShapeXBtCapsuleShapeX 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
btCapsuleShapeZBtCapsuleShapeZ 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
btCharacterControllerInterface
btCharIndexTripletData
btChunk
btClockThe btClock is a portable basic clock that measures accurate time in seconds, use for profiling
btClockData
btClosestNotMeConvexResultCallback
btCollisionAlgorithmBtCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher
btCollisionAlgorithmConstructionInfo
btCollisionAlgorithmCreateFuncUsed by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm
btCollisionConfigurationBtCollisionConfiguration allows to configure Bullet collision detection stack allocator size, default collision algorithms and persistent manifold pool size
btCollisionDispatcherBtCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs
btCollisionObjectBtCollisionObject can be used to manage collision detection objects
btCollisionObjectDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCollisionObjectFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCollisionObjectWrapper
btCollisionPairCallbackInterface for iterating all overlapping collision pairs, no matter how those pairs are stored (array, set, map etc) this is useful for the collision dispatcher
btCollisionShapeInterface for collision shapes that can be shared among btCollisionObjects
btCollisionShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCollisionWorldCollisionWorld is interface and container for the collision detection
btCompoundCollisionAlgorithmBtCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes
btCompoundLeafCallback
btCompoundShapeThe btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave collision objects
btCompoundShapeChild
btCompoundShapeChildDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCompoundShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btConcaveShapeInterface for non-moving (static) concave shapes
btConeShapeThe btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis
btConeShapeXBtConeShape implements a Cone shape, around the X axis
btConeShapeZBtConeShapeZ implements a Cone shape, around the Z axis
btConeTwistConstraintBtConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
btConeTwistConstraintDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btConnectivityProcessor
btTypedConstraint::btConstraintInfo1
btTypedConstraint::btConstraintInfo2
btConstraintRow
btConstraintSetting
btConstraintSolverBtConstraintSolver provides solver interface
btConstraintSolverIO
btContactArray
btContactConstraintBtContactConstraint can be automatically created to solve contact constraints using the unified btTypedConstraint interface
btContactSolverInfo
btContactSolverInfoData
btContactSolverInfoDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btContactSolverInfoFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btContinuousConvexCollisionBtContinuousConvexCollision implements angular and linear time of impact for convex objects
btConvex2dConvex2dAlgorithmThe convex2dConvex2dAlgorithm collision algorithm support 2d collision detection for btConvex2dShape Currently it requires the btMinkowskiPenetrationDepthSolver, it has support for 2d penetration depth computation
btConvex2dShapeThe btConvex2dShape allows to use arbitrary convex shapes as 2d convex shapes, with the Z component assumed to be 0
btConvexCastBtConvexCast is an interface for Casting
btConvexConcaveCollisionAlgorithmBtConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges meshes
btConvexConvexAlgorithmEnabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation
btConvexHullComputerConvex hull implementation based on Preparata and Hong See http://code.google.com/p/bullet/issues/detail?id=275 Ole Kniemeyer, MAXON Computer GmbH
btConvexHullInternal
btConvexHullShapeThe btConvexHullShape implements an implicit convex hull of an array of vertices
btConvexHullShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btConvexInternalAabbCachingShapeBtConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations
btConvexInternalShapeThe btConvexInternalShape is an internal base class, shared by most convex shape implementations
btConvexInternalShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btConvexPenetrationDepthSolverConvexPenetrationDepthSolver provides an interface for penetration depth calculation
btConvexPlaneCollisionAlgorithmBtSphereBoxCollisionAlgorithm provides sphere-box collision detection
btConvexPointCloudShapeThe btConvexPointCloudShape implements an implicit convex hull of an array of vertices
btConvexPolyhedron
btConvexSeparatingDistanceUtilThe btConvexSeparatingDistanceUtil can help speed up convex collision detection by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance
btConvexShapeThe btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape, btConvexHullShape etc
btConvexTriangleCallbackFor each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called
btConvexTriangleMeshShapeThe btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape
btCPUVertexBufferDescriptor
btCriticalSection
btCylinderShapeImplements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis
btCylinderShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btCylinderShapeX
btCylinderShapeZ
btDbvtImplements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree)
btDbvtAabbMm
btDbvtBroadphaseThe btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt)
btDbvtNode
btDbvtNodeEnumerator
btDbvtProxy
btDbvtTreeCollider
btDefaultCollisionConfigurationBtCollisionConfiguration allows to configure Bullet collision detection stack allocator, pool memory allocators
btDefaultCollisionConstructionInfo
btDefaultMotionStateThe btDefaultMotionState provides a common implementation to synchronize world transforms with offsets
btDefaultSerializerThe btDefaultSerializer is the main Bullet serialization class
btDefaultSoftBodySolver
btDefaultVehicleRaycaster
btDiscreteCollisionDetectorInterfaceThis interface is made to be used by an iterative approach to do TimeOfImpact calculations This interface allows to query for closest points and penetration depth between two (convex) objects the closest point is on the second object (B), and the normal points from the surface on B towards A
btDiscreteDynamicsWorldBtDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController
btDispatcherThe btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs
btDispatcherInfo
btDummyBarrier
btDummyCriticalSection
btDX11Buffer< ElementType >DX11 Buffer that tracks a host buffer on use to ensure size-correctness
btDX11SIMDAwareSoftBodySolver
btDX11SoftBodySolver
btDX11VertexBufferDescriptor
btDynamicsWorldThe btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc
btDynamicsWorldDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btDynamicsWorldFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btEigen
btElement
btEmptyAlgorithmEmptyAlgorithm is a stub for unsupported collision pairs
btEmptyShapeThe btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class
btFace
btGearConstraintThe btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio
btGEN_Link
btGEN_List
btGeneric6DofConstraintBtGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
btGeneric6DofConstraintDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btGeneric6DofSpringConstraintGeneric 6 DOF constraint that allows to set spring motors to any translational and rotational DOF
btGeneric6DofSpringConstraintDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btGenericMemoryPoolGeneric Pool class
btGenericPoolAllocatorGeneric Allocator with pools
btGeometryUtilThe btGeometryUtil helper class provides a few methods to convert between plane equations and vertices
btGhostObjectThe btGhostObject can keep track of all objects that are overlapping By default, this overlap is based on the AABB This is useful for creating a character controller, collision sensors/triggers, explosions etc
btGhostPairCallbackThe btGhostPairCallback interfaces and forwards adding and removal of overlapping pairs from the btBroadphaseInterface to btGhostObject
btGImpactBvhStructure for containing Boxes
btGImpactCollisionAlgorithmCollision Algorithm for GImpact Shapes
btGImpactCompoundShapeBtGImpactCompoundShape allows to handle multiple btCollisionShape objects at once
btGImpactMeshShapeThis class manages a mesh supplied by the btStridingMeshInterface interface
btGImpactMeshShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btGImpactMeshShapePartThis class manages a sub part of a mesh supplied by the btStridingMeshInterface interface
btGImpactQuantizedBvhStructure for containing Boxes
btGImpactShapeInterfaceBase class for gimpact shapes
btGImpactTriangleCallback
btGjkConvexCastGjkConvexCast performs a raycast on a convex object using support mapping
btGjkEpaPenetrationDepthSolverEpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth between two convex shapes
btGjkEpaSolver2BtGjkEpaSolver contributed under zlib by Nathanael Presson
btGjkPairDetectorBtGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
btGpu3DGridBroadphaseThe btGpu3DGridBroadphase uses GPU-style code compiled for CPU to compute overlapping pairs
btHashedOverlappingPairCacheHash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
btHashInt
btHashKey< Value >
btHashKeyPtr< Value >
btHashMap< Key, Value >The btHashMap template class implements a generic and lightweight hashmap
btHashPtr
btHashStringVery basic hashable string implementation, compatible with btHashMap
btHeightfieldTerrainShapeBtHeightfieldTerrainShape simulates a 2D heightfield terrain
btHinge2Constraint
btHingeConstraintHinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space axis defines the orientation of the hinge axis
btHingeConstraintDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btHingeConstraintFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btHullTriangle
btIDebugDrawThe btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations
btIndexedMeshThe btIndexedMesh indexes a single vertex and index array
btInternalEdge
btInternalTriangleIndexCallback
btInternalVertexPair
btIntIndexData
btJacobianEntryJacobian entry is an abstraction that allows to describe constraints it can be used in combination with a constraint solver Can be used to relate the effect of an impulse to the constraint error
btJointFeedback
btKinematicCharacterControllerBtKinematicCharacterController is an object that supports a sliding motion in a world
btKinematicClosestNotMeConvexResultCallback
btKinematicClosestNotMeRayResultCallback
btManifoldPointManifoldContactPoint collects and maintains persistent contactpoints
btManifoldResultBtManifoldResult is a helper class to manage contact results
btMaterialThis file was created by Alex Silverman
btMaterialPropertiesThis file was created by Alex Silverman
btMatrix3x3Implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3
btMatrix3x3DoubleDataFor serialization
btMatrix3x3FloatDataFor serialization
btMeshPartDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btMinkowskiPenetrationDepthSolverMinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation
btMinkowskiSumShapeThe btMinkowskiSumShape is only for advanced users. This shape represents implicit based minkowski sum of two convex implicit shapes
btMotionStateThe btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation)
btMultimaterialTriangleMeshShapeThis file was created by Alex Silverman
btMultiSapBroadphaseThe btMultiSapBroadphase is a research project, not recommended to use in production
btMultiSapBroadphasePairSortPredicate
btMultiSapBroadphase::btMultiSapProxy
btMultiSphereShapeThe btMultiSphereShape represents the convex hull of a collection of spheres
btMultiSphereShapeData
btNodeOverlapCallback
btNullPairCacheBtNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing
btOpenCLAcceleratedSoftBodyInterfaceSoftBody class to maintain information about a soft body instance within a solver
btOpenCLBuffer< ElementType >
btOpenCLSoftBodySolver
btOpenCLSoftBodySolverSIMDAware
btOpenGLInteropVertexBufferDescriptor
btOptimizedBvhThe btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface
btOptimizedBvhNodeBtOptimizedBvhNode contains both internal and leaf node information
btOptimizedBvhNodeDoubleData
btOptimizedBvhNodeFloatData
btOverlapCallback
btOverlapFilterCallback
btOverlappingPairCacheThe btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases
btOverlappingPairCallbackAdditional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache
btPairCachingGhostObject
btPairSetA pairset array
btParallelConstraintSolverThe btParallelConstraintSolver performs computations on constraint rows in parallel Using the cross-platform threading it supports Windows, Linux, Mac OSX and PlayStation 3 Cell SPUs
btParallelSolverMemoryCache
btPersistentManifoldBtPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase
btPersistentManifoldSortPredicateFunction object that routes calls to operator<
btPerturbedContactResult
btPhysicsSdk
btPlane
btPlaneShapeClass for accessing the plane equation
btPoint2PointConstraintPoint to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space
btPoint2PointConstraintDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btPoint2PointConstraintFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btPointCollector
btPointerUid
btPolarDecompositionThis class is used to compute the polar decomposition of a matrix
btPolyhedralContactClipping
btPolyhedralConvexAabbCachingShapeThe btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape
btPolyhedralConvexShapeThe btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes
btPoolAllocatorAllows to efficiently allocate a large pool of objects, instead of dynamically allocating them separately
btPositionAndRadius
btPrimitiveManagerBasePrototype Base class for primitive classification
btPrimitiveTriangle
btQuadWordBase class for btVector3 and btQuaternion
btQuantizedBvhStores an AABB tree that can be quickly traversed on CPU and Cell SPU
btQuantizedBvhDoubleData
btQuantizedBvhFloatData
btQuantizedBvhNodeBtQuantizedBvhNode is a compressed aabb node, 16 bytes
btQuantizedBvhNodeData
btQuantizedBvhTreeBasic Box tree structure
btQuaternionThe btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform
btRaycastVehicleRayCast vehicle, very special constraint that turn a rigidbody into a vehicle
btRigidBodyThe btRigidBody is the main class for rigid body objects
btRigidBody::btRigidBodyConstructionInfoThe btRigidBodyConstructionInfo structure provides information to create a rigid body
btRigidBodyDoubleDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btRigidBodyFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btRotationalLimitMotorRotation Limit structure for generic joints
btScaledBvhTriangleMeshShapeThe btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape
btScaledTriangleCallback
btScaledTriangleMeshShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btSequentialImpulseConstraintSolverThe btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method
btSerializer
btShapeHullBtShapeHull implemented by John McCutchan
btShortIntIndexData
btShortIntIndexTripletData
btSimpleBroadphaseThe SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead
btSimpleBroadphaseProxy
btSimpleDynamicsWorldThe btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds
btSimulationIslandManagerSimulationIslandManager creates and handles simulation islands, using btUnionFind
btSingleContactCallback
btSingleRayCallback
btSingleSweepCallback
btSliderConstraint
btSliderConstraintDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btSoftBodyThe btSoftBody is an class to simulate cloth and volumetric soft bodies
btSoftBodyCollisionShape
btSoftBodyConcaveCollisionAlgorithmBtSoftBodyConcaveCollisionAlgorithm supports collision between soft body shapes and (concave) trianges meshes
btSoftBodyFloatDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btSoftBodyHelpers
btSoftBodyJointData
btSoftBodyLinkData
btSoftBodyLinkDataDX11
btSoftBodyLinkDataDX11SIMDAware
btSoftBodyLinkDataOpenCL
btSoftBodyLinkDataOpenCLSIMDAware
btSoftBodyRigidBodyCollisionConfigurationBtSoftBodyRigidBodyCollisionConfiguration add softbody interaction on top of btDefaultCollisionConfiguration
btSoftBodySolver
btSoftBodySolverOutputClass to manage movement of data from a solver to a given target
btSoftBodySolverOutputCLtoCPUClass to manage movement of data from a solver to a given target
btSoftBodySolverOutputCLtoGLClass to manage movement of data from a solver to a given target
btSoftBodySolverOutputDXtoCPUClass to manage movement of data from a solver to a given target
btSoftBodySolverOutputDXtoDXClass to manage movement of data from a solver to a given target
btSoftBodyTriangleCallbackFor each triangle in the concave mesh that overlaps with the AABB of a soft body (m_softBody), processTriangle is called
btSoftBodyTriangleData
btSoftBodyTriangleDataDX11
btSoftBodyTriangleDataOpenCL
btSoftBodyVertexDataWrapper for vertex data information
btSoftBodyVertexDataDX11
btSoftBodyVertexDataOpenCL
btSoftBodyWorldInfo
btSoftClusterCollisionShape
btSoftColliders
btSoftRigidCollisionAlgorithmBtSoftRigidCollisionAlgorithm provides collision detection between btSoftBody and btRigidBody
btSoftRigidDynamicsWorld
btSoftSingleRayCallback
btSoftSoftCollisionAlgorithmCollision detection between two btSoftBody shapes
btSolve2LinearConstraintConstraint class used for lateral tyre friction
btSolverConstraint1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints
btSoftBodyTriangleDataOpenCL::btSomePairStart and length values for computation batches over link data
btSortConstraintOnIslandPredicate
btSortedOverlappingPairCacheBtSortedOverlappingPairCache maintains the objects with overlapping AABB Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
btSparseSdf< CELLSIZE >
btSphereBoxCollisionAlgorithmBtSphereBoxCollisionAlgorithm provides sphere-box collision detection
btSphereShapeThe btSphereShape implements an implicit sphere, centered around a local origin with radius
btSphereSphereCollisionAlgorithmBtSphereSphereCollisionAlgorithm provides sphere-sphere collision detection
btSphereTriangleCollisionAlgorithmBtSphereSphereCollisionAlgorithm provides sphere-sphere collision detection
btSpinlock
btSpuCollisionPairCallbackInterface for iterating all overlapping collision pairs, no matter how those pairs are stored (array, set, map etc) this is useful for the collision dispatcher
PosixThreadSupport::btSpuStatus
SequentialThreadSupport::btSpuStatus
Win32ThreadSupport::btSpuStatusPlaceholder, until libspe2 support is there
btStackAllocThe StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
btStaticPlaneShapeThe btStaticPlaneShape simulates an infinite non-moving (static) collision plane
btStaticPlaneShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btStorageResult
btStridingMeshInterfaceThe btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes
btStridingMeshInterfaceDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btSubSimplexClosestResult
btSubsimplexConvexCastBtSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" GJK based Ray Cast, optimized version Objects should not start in overlap, otherwise results are not defined
btSymMatrix< T >BtSoftBody implementation by Nathanael Presson
btTetrahedronShapeExHelper class for tetrahedrons
btThreadSupportInterface
btTransformSupports rigid transforms with only translation and rotation and no scaling/shear
btTransformDoubleData
btTransformFloatDataFor serialization
btTransformUtilUtils related to temporal transforms
btTranslationalLimitMotor
btTriangle
btTriangleBufferThe btTriangleBuffer callback can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles' Example usage of this class: btTriangleBuffer triBuf; concaveShape->processAllTriangles(&triBuf,aabbMin, aabbMax); for (int i=0;i<triBuf.getNumTriangles();i++) { const btTriangle& tri = triBuf.getTriangle(i); do something useful here with the triangle }
btTriangleCallbackThe btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles
btTriangleConvexcastCallback
btTriangleIndexVertexArrayThe btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays
btTriangleIndexVertexMaterialArrayTeh btTriangleIndexVertexMaterialArray is built on TriangleIndexVertexArray The addition of a material array allows for the utilization of the partID and triangleIndex that are returned in the ContactAddedCallback
btTriangleInfoThe btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges it can be generated using
btTriangleInfoDataThose fields have to be float and not btScalar for the serialization to work properly
btTriangleInfoMapThe btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo
btTriangleInfoMapData
btTriangleMeshConvenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh
btTriangleMeshShapeThe btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead
btTriangleMeshShapeDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTriangleRaycastCallback
btTriangleShape
btTriangleShapeExHelper class for colliding Bullet Triangle Shapes
btTriIndex
btTypedConstraintTypedConstraint is the baseclass for Bullet constraints and vehicles
btTypedConstraintDataDo not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTypedObjectRudimentary class to provide type info
btUniformScalingShapeThe btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way
btUnionFindUnionFind calculates connected subsets
btUnionFindElementSortPredicate
btUniversalConstraintConstraint similar to ODE Universal Joint has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1) and Y (axis 2) Description from ODE manual : "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular
btUsageBitfield
btVector3BtVector3 can be used to represent 3D points and vectors
btVector3DoubleData
btVector3FloatData
btVector4
btVehicleRaycasterBtVehicleRaycaster is provides interface for between vehicle simulation and raycasting
btVehicleRaycaster::btVehicleRaycasterResult
btRaycastVehicle::btVehicleTuning
btVertexBufferDescriptor
btVoronoiSimplexSolverBtVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin
btWheelContactPoint
btWheelInfoBtWheelInfo contains information per wheel about friction and suspension
btWheelInfoConstructionInfo
btWin32Barrier
btWin32CriticalSection
bvhMeshShape_LocalStoreMemory
btConvexCast::CastResultRayResult stores the closest result alternatively, add a callback method to decide about closest/all results
btSparseSdf< CELLSIZE >::Cell
CheckOverlapCallback
GIM_ShapeRetriever::ChildShapeRetriever
btSoftBody::CJoint
CLFunctions
ClipVertex
btCollisionWorld::ClosestConvexResultCallback
btDiscreteCollisionDetectorInterface::ClosestPointInput
btCollisionWorld::ClosestRayResultCallback
btSoftBody::Cluster
btSoftColliders::ClusterBase
btSoftColliders::CollideCL_RS
btSoftColliders::CollideCL_SS
btSoftColliders::CollideSDF_RS
btSoftColliders::CollideVF_SS
CollisionObjectIndices
btDX11SoftBodySolver::CollisionObjectIndices
btOpenCLSoftBodySolver::CollisionObjectIndices
CollisionShape_LocalStoreMemory
CollisionShapeDescriptionEntry in the collision shape array
btDX11SoftBodySolver::CollisionShapeDescriptionEntry in the collision shape array
CollisionTask_LocalStoreMemoryMake sure no destructors are called on this memory
btGImpactCompoundShape::CompoundPrimitiveManagerCompound primitive manager
CompoundShape_LocalStoreMemory
btDX11SoftBodySolver::ComputeBoundsCB
btSoftBody::Config
CONTACT_KEY_TOKEN
CONTACT_KEY_TOKEN_COMP
btCollisionWorld::ContactResultCallbackContactResultCallback is used to report contact points
ConvexH
btCollisionWorld::ConvexResultCallbackRayResultCallback is used to report new raycast results
Coplanar
copy_elements_funcPrototype for copying elements
CProfileIteratorAn iterator to navigate through the tree
CProfileManagerThe Manager for the Profile system
CProfileNodeA node in the Profile Hierarchy Tree
CProfileSampleProfileSampleClass is a simple way to profile a function's scope Use the BT_PROFILE macro at the start of scope to time
btBox2dBox2dCollisionAlgorithm::CreateFunc
btBoxBoxCollisionAlgorithm::CreateFunc
btSoftBodyConcaveCollisionAlgorithm::CreateFunc
btSphereSphereCollisionAlgorithm::CreateFunc
btSoftSoftCollisionAlgorithm::CreateFunc
btConvexConcaveCollisionAlgorithm::CreateFunc
SpuContactManifoldCollisionAlgorithm::CreateFunc
btConvexPlaneCollisionAlgorithm::CreateFunc
btGImpactCollisionAlgorithm::CreateFunc
btConvexConvexAlgorithm::CreateFunc
btConvex2dConvex2dAlgorithm::CreateFunc
btSoftRigidCollisionAlgorithm::CreateFunc
CreateFunc
btEmptyAlgorithm::CreateFunc
btCompoundCollisionAlgorithm::CreateFunc
btSphereBoxCollisionAlgorithm::CreateFunc
btSphereTriangleCollisionAlgorithm::CreateFunc
DebugDrawcallback
DISTANCE_PLANE_3D_FUNCThis function calcs the distance from a 3D plane
btConvexHullInternal::DMul< UWord, UHWord >
DoubleBuffer< T, size >DoubleBuffer
DXFunctions
btSoftBody::eAeroModelEAeroModel
btConvexHullInternal::Edge
btConvexHullComputer::Edge
btAxisSweep3Internal< BP_FP_INT_TYPE >::Edge
EdgeFlag
btSoftBody::eFeatureEFeature
btSoftBody::Element
gjkepa2_impl::EPA
btSoftBody::ePSolverEPSolver : positions solvers
btSoftBody::eSolverPresetsESolverPresets
gjkepa2_impl::GJK::eStatus
gjkepa2_impl::EPA::eStatus
btSoftBody::Joint::eType
btSoftBody::eVSolverEVSolver : velocities solvers
btSoftBody::Face
btConvexHullInternal::Face
btSoftBody::fCollisionFCollision
fDrawFlags
btSoftBody::Feature
float3
float4
float8
Vectormath::floatInVec
btSoftBody::fMaterialFMaterial
GIM_AABBAxis aligned box
GIM_AABB_DATA
gim_array< T >Very simple array container with fast access and simd memory
gim_bitset
GIM_BOX_BOX_TRANSFORM_CACHEClass for transforming a model1 to the space of model0
GIM_BOX_TREEBasic Box tree structure
GIM_BOX_TREE_NODENode Structure for trees
GIM_BOX_TREE_SET< _GIM_PRIMITIVE_MANAGER_PROTOTYPE >Class for Box Tree Sets
GIM_BOX_TREE_TEMPLATE_SET< _GIM_PRIMITIVE_MANAGER_PROTOTYPE, _GIM_BOX_TREE_PROTOTYPE >Generic Box Tree Template
GIM_BVH_DATAGIM_BVH_DATA is an internal GIMPACT collision structure to contain axis aligned bounding box
GIM_BVH_DATA_ARRAY
GIM_BVH_TREE_NODENode Structure for trees
GIM_BVH_TREE_NODE_ARRAY
GIM_CONTACTThe GIM_CONTACT is an internal GIMPACT structure, similar to btManifoldPoint
gim_contact_array
GIM_HASH_NODE_CMP_KEY_MACROMacro for comparing the key and the element
GIM_HASH_NODE_CMP_MACROMacro for comparing Hash nodes
GIM_HASH_NODE_GET_KEYMacro for getting the key
gim_hash_table< T >A compact hash table implementation
GIM_HASH_TABLE_NODE< T >
GIM_PAIROverlapping pair
gim_pair_setA pairset array
GIM_PRIMITIVE_MANAGER_PROTOTYPEPrototype Base class for primitive classification
GIM_QUANTIZED_BVH_NODE_ARRAY
GIM_RSORT_TOKEN
GIM_RSORT_TOKEN_COMPARATORPrototype for comparators
GIM_ShapeRetrieverRetrieving shapes shapes
GIM_STANDARD_ALLOCATOR
GIM_TREE_TREE_COLLIDER< BOX_SET_CLASS0, BOX_SET_CLASS1 >GIM_BOX_SET collision methods
GIM_TRIANGLEClass for colliding triangles
GIM_TRIANGLE_CALCULATION_CACHE
GIM_TRIANGLE_CONTACTStructure for collision
GIM_TRIANGLE_CONTACT_DATAStructure for collision
gjkepa2_impl::GJK
GrahamVector3
ConvexH::HalfEdge
btAxisSweep3Internal< BP_FP_INT_TYPE >::Handle
HeapManager
HullDesc
HullLibraryCan create a convex hull from a collection of vertices, using the ComputeHull method
HullResult
btDbvt::IClone
btDbvt::ICollide
btSoftBody::AJoint::IControl
btSoftBody::ImplicitFn
btSoftBody::Impulse
InplaceSolverIslandCallback
btConvexHullInternal::Int128
int2
int3
int4
integer_comparatorPrototype for comparators
btDX11SoftBodySolver::IntegrateCB
btConvexHullInternal::IntermediateHull
btSparseSdf< CELLSIZE >::IntFrac
btSimulationIslandManager::IslandCallback
btDbvt::IWriter
btSoftBody::Joint
DXFunctions::KernelDesc
btAlignedObjectArray< T >::less
less_comparatorMacros for sorting
btSoftBody::Link
btSoftBodyLinkData::LinkDescriptionClass describing a link for input into the system
btSoftBodyLinkData::LinkNodePairClass representing a link as a set of three indices into the vertex array
btSoftBody::LJoint
btCollisionWorld::LocalConvexResult
btCollisionWorld::LocalRayResult
btCollisionWorld::LocalShapeInfoLocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
LocalSupportVertexCallbackIt's not nice to have all this virtual function overhead, so perhaps we can also gather the points once but then we are duplicating
btSoftBody::Material
Vectormath::Aos::Matrix3
Vectormath::Aos::Matrix4
memcopy_elements_funcPrototype for copying elements
MiniCLKernel
MiniCLKernelDesc
MiniCLTask_LocalStoreMemory
MiniCLTaskDesc
MiniCLTaskSchedulerMiniCLTaskScheduler handles SPU processing of collision pairs
gjkepa2_impl::MinkowskiDiff
btSoftBody::Node
NodeLinks
btSoftBody::Note
btSoftBodyLinkDataDX11SIMDAware::NumBatchesVerticesPair
btSoftBodyLinkDataOpenCLSIMDAware::NumBatchesVerticesPair
btSoftBodySolverOutputDXtoDX::OutputToVertexArrayCB
PfxParallelBatch
PfxParallelGroup
PfxPostSolverIO
PfxSetupContactConstraintsIO
PfxSolveConstraintsIO
PfxSolverBody
PfxSortData16
PHullResult
PlaneFlag
plRayCastResult
Vectormath::Aos::Point3
btConvexHullInternal::Point32
btConvexHullInternal::Point64
btConvexHullInternal::PointR128
btConvexHullInternal::Pool< T >
btConvexHullInternal::PoolArray< T >
btSoftBody::Pose
PosixBarrier
PosixCriticalSection
PosixThreadSupport
btDX11SoftBodySolver::PrepareLinksCB
Vectormath::Aos::Quat
QuickSortCompare
btConvexHullInternal::Rational128
btConvexHullInternal::Rational64
btWheelInfo::RaycastInfo
btSoftBody::RayFromToCasterRayFromToCaster takes a ray from, ray to (instead of direction!)
btCollisionWorld::RayResultCallbackRayResultCallback is used to report new raycast results
btSoftBody::RContact
btAlignedAllocator< T, Alignment >::rebind< O >
RemovePairContainingProxy
RemovingOverlapCallback
btDiscreteCollisionDetectorInterface::Result
SampleTask_LocalStoreMemory
btSoftBody::SContact
btSoftBody::sCti
SequentialThreadSupport::SequentialThreadConstructionInfo
SequentialThreadSupportThe SequentialThreadSupport is a portable non-parallel implementation of the btThreadSupportInterface This is useful for debugging and porting SPU Tasks to other platforms
gjkepa2_impl::EPA::sFace
gjkepa2_impl::EPA::sHorizon
gjkepa2_impl::EPA::sList
btSoftBody::sMedium
SoftBodyClusterData
SoftBodyConfigData
SoftBodyFaceData
SoftBodyLinkData
SoftBodyMaterialData
SoftBodyNodeData
SoftBodyPoseData
SoftBodyTetraData
SoftRigidAnchorData
btDX11SoftBodySolver::SolveCollisionsAndUpdateVelocitiesCB
btDX11SoftBodySolver::SolvePositionsFromLinksKernelCB
btDX11SIMDAwareSoftBodySolver::SolvePositionsFromLinksKernelCB
btSoftBody::SolverState
btSoftBody::AJoint::Specs
btSoftBody::Joint::Specs
btSoftBody::LJoint::Specs
SphereTriangleDetectorSphere-triangle to match the btDiscreteCollisionDetectorInterface
SpuClosestPointInput
SpuCollisionObjectWrapper
SpuCollisionPairInput
SpuCollisionTaskProcessSpuCollisionTaskProcess handles SPU processing of collision pairs
SpuContactManifoldCollisionAlgorithmSpuContactManifoldCollisionAlgorithm provides contact manifold and should be processed on SPU
SpuContactResultSpuContactResult exports the contact points using double-buffered DMA transfers, only when needed So when an existing contact point is duplicated, no transfer/refresh is performed
SpuConvexPenetrationDepthSolverConvexPenetrationDepthSolver provides an interface for penetration depth calculation
SpuConvexPolyhedronVertexData
SpuGatherAndProcessPairsTaskDescTask Description for SPU collision detection
SpuGatherAndProcessWorkUnitInputMidphaseWorkUnitInput stores individual primitive versus mesh collision detection input, to be processed by the SPU
SpuGatheringCollisionDispatcherSpuGatheringCollisionDispatcher can use SPU to gather and calculate collision detection Time of Impact, Closest Points and Penetration Depth
SpuMinkowskiPenetrationDepthSolverMinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation
spuNodeCallback
SpuSampleTaskDesc
SpuSampleTaskProcessSpuSampleTaskProcess handles SPU processing of collision pairs
btSoftBody::sRayCast
btGjkEpaSolver2::sResults
SSEFloat
gjkepa2_impl::GJK::sSimplex
btDbvt::sStkCLN
btDbvt::sStkNN
btDbvt::sStkNP
btDbvt::sStkNPS
gjkepa2_impl::GJK::sSV
SupportVertexCallback
btConvexConcaveCollisionAlgorithm::SwappedCreateFunc
btSoftBodyConcaveCollisionAlgorithm::SwappedCreateFunc
btCompoundCollisionAlgorithm::SwappedCreateFunc
btSoftBody::Tetra
GIM_ShapeRetriever::TetraShapeRetriever
PosixThreadSupport::ThreadConstructionInfoSetup and initialize SPU/CELL/Libspe2
Vectormath::Aos::Transform3
TrbDynBody
TrbState
btSoftBodyTriangleData::TriangleDescription
btSoftBodyTriangleData::TriangleNodeSetClass representing a triangle as a set of three indices into the vertex array
GIM_ShapeRetriever::TriangleShapeRetriever
btGImpactMeshShapePart::TrimeshPrimitiveManagerTrimesh primitive manager
uint2
uint3
uint4
uint_key_funcPrototype for getting the integer representation of an object
btOpenCLSoftBodySolver::UIntVector3
btDX11SoftBodySolver::UIntVector3
btDX11SoftBodySolver::UpdatePositionsFromVelocitiesCB
btDX11SoftBodySolver::UpdateSoftBodiesCB
btDX11SoftBodySolver::UpdateVelocitiesFromPositionsWithoutVelocitiesCB
btDX11SoftBodySolver::UpdateVelocitiesFromPositionsWithVelocitiesCB
Vectormath::Aos::Vector3
Vectormath::Aos::Vector4
btConvexHullInternal::Vertex
btSoftBodyVertexData::VertexDescriptionClass describing a vertex for input into the system
VertFlag
btDX11SoftBodySolver::VSolveLinksCB
Win32ThreadSupport::Win32ThreadConstructionInfoSetup and initialize SPU/CELL/Libspe2
Win32ThreadSupportWin32ThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication