Types

This class is not enabled yet (work-in-progress) to more aggressively activate objects.

The class implements the sweep and prune broadphase. It uses quantized integers to represent the begin and end points for each of the 3 axis. Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead. The AxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. For large worlds and many objects, use 32BitAxisSweep3 or DbvtBroadphase instead. 32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance.

The class implements the sweep and prune broadphase. It uses quantized integers to represent the begin and end points for each of the 3 axis. Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead. The AxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. For large worlds and many objects, use AxisSweep3_32Bit or DbvtBroadphase instead. AxisSweep3_32Bit has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance.

Box-Box collision detection.

BoxBoxDetector wraps the ODE box-box collision detector re-distributed under the Zlib license with permission from Russell L. Smith ODE box-box collision detection is adapted to work with Bullet

The BoxShape 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 CollisionObject or RigidBody it will be an oriented box in world space.

Dispatcher uses these types. IMPORTANT NOTE: The types are ordered polyhedral, implicit convex and concave to facilitate type checking. CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code

The BroadphasePair class contains a pair of aabb-overlapping objects. A Dispatcher can search a CollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes.

The BroadphaseProxy is the main class that can be used with the Bullet broadphases. It stores collision shape type information, collision filter information and a client object, typically a CollisionObject or RigidBody.

The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree). This btDbvt is used for soft body collision detection and for the DbvtBroadphase. It has a fast insert, remove and update of nodes. Unlike the QuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure.

The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt). One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases AxisSweep3 and BigAxisSweep3.

The BUSimplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use ConvexHullShape instead.

BvhSubtreeInfo provides info to gather a subtree of limited size.

The BvhTriangleMeshShape is a static-triangle mesh shape with several optimizations, such as bounding volume hierarchy and cache friendly traversal for PlayStation 3 Cell SPU. It is recommended to enable UseQuantizedAabbCompression for better memory usage. It takes a triangle mesh as input, for example a TriangleMesh or TriangleIndexVertexArray. The BvhTriangleMeshShape class allows for triangle mesh deformations by a refit or PartialRefit method. Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk. See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example.

The CapsuleShape represents a capsule around the Y axis, there is also the CapsuleShapeX aligned around the X axis and CapsuleShapeZ 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. The CapsuleShape is a convex hull of two spheres. The MultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres.

CapsuleShapeX represents a capsule around the X 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.

CapsuleShapeZ 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.

CastResult stores the closest result alternatively, add a callback method to decide about closest/all results

CollisionAlgorithm is an collision interface that is compatible with the Broadphase and Dispatcher. It is persistent over frames.

Used by the CollisionDispatcher to register and create instances for CollisionAlgorithm.

CollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. Time of Impact, Closest Points and Penetration Depth.

Optional filtering to cull potential collisions.

CollisionObject can be used to manage collision detection objects. CollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. They can be added to the CollisionWorld.

Interface for iterating all overlapping collision pairs, no matter how those pairs are stored (array, set, map etc) this is useful for the collision dispatcher.

The CollisionShape class provides an interface for collision shapes that can be shared among CollisionObjects.

CollisionWorld is interface and container for the collision detection.

CompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes. Place holder, not fully implemented yet.

The CompoundShape allows to store multiple other CollisionShapes This allows for moving concave collision objects. This is more general then the static concave BvhTriangleMeshShape. It has an (optional) dynamic aabb tree to accelerate early rejection tests. @todo: This aabb tree can also be use to speed up ray tests on CompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25 Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of CompoundShape)

The ConcaveShape class provides an interface for non-moving (static) concave shapes. It has been implemented by the StaticPlaneShape, BvhTriangleMeshShape and HeightfieldTerrainShape.

The ConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The ConeShapeX is aligned around the X axis and ConeShapeZ around the Z axis.

ConeShape implements a Cone shape, around the X axis

ConeShape implements a Cone shape, around the Z axis

ContinuousConvexCollision implements angular and linear time of impact for convex objects. Based on Brian Mirtich's Conservative Advancement idea (PhD thesis). Algorithm operates in worldspace, in order to keep inbetween motion globally consistent. It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops

The ConvexHullShape implements an implicit convex hull of an array of vertices. Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using LocalGetSupportingVertex.

ConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations.

The ConvexInternalShape is an internal base class, shared by most convex shape implementations.

SphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response.

RayResultCallback is used to report new raycast results.

The ConvexShape is an abstract shape interface, implemented by all convex shapes such as BoxShape, ConvexHullShape etc. It describes general convex shapes using the LocalGetSupportingVertex interface, used by collision detectors such as GjkPairDetector.

For each triangle in the concave mesh that overlaps with the AABB of a convex (_convexProxy), processTriangle is called.

The ConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as ConvexHullShape. A small benefit of this class is that it uses the StridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing ConvexHullShape instead.

The CylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. CylinderShapeX is aligned with the X axis and CylinderShapeZ around the Z axis.

The DebugDraw class allows hooking up a debug renderer to visually debug simulations. Typical use case: create a debug drawer object, and assign it to a CollisionWorld or DynamicsWorld using set_DebugDrawer and call DebugDrawWorld. A class that inherited from the DebugDraw has to implement the drawLine method at a minimum.

CollisionConfiguration allows to configure Bullet collision detection todo: describe the meaning

This 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. distance is between closest points on B and closest point on A. So you can calculate closest point on A by taking closestPointInA = closestPointInB + _distance * _normalOnSurfaceB

EmptyAlgorithm is a stub for unsupported collision pairs. The dispatcher can dispatch a persistent EmptyAlgorithm to avoid a search every frame.

The EmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class. It can be replaced by another shape during runtime, but the inertia tensor should be recomputed.

The GhostObject 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. We plan on adding rayTest and other queries for the GhostObject

The GhostPairCallback interfaces and forwards adding and removal of overlapping pairs from the BroadphaseInterface to GhostObject.

GjkConvexCast performs a raycast on a convex object using support mapping.

GJK-EPA collision solver by Nathanael Presson Nov.2006

EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth between two convex shapes.

GjkEpaSolver contributed under zlib by Nathanael Presson.

GjkPairDetector uses GJK to implement the DiscreteCollisionDetectorInterface

Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com

HeightfieldTerrainShape simulates a 2D heightfield terrain.

The IBroadphase provides an interface to detect aabb-overlapping object pairs. Some implementations for this broadphase interface include AxisSweep3, 32BitAxisSweep3 and DbvtBroadphase. The actual overlapping pair management, storage, adding and removing of pairs is dealt by the OverlappingPairCache class.

CollisionConfiguration allows to configure Bullet collision detection stack allocator size, default collision algorithms and persistent manifold pool size.

ConvexCast is an interface for Casting

IConvexPenetrationDepthSolver provides an interface for penetration depth calculation.

The Dispatcher interface can be used in combination with broadphase to dispatch calculations for overlapping pairs. For example for pairwise collision detection, calculating contact points stored in PersistentManifold or user callbacks (game logic).

The IndexedMesh indexes a single vertex and index array. Multiple IndexedMesh objects can be passed into a TriangleIndexVertexArray using AddIndexedMesh. Instead of the number of indices, we pass the number of triangles.

The OverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to OverlappingPairCache.

ISimplexSolver can incrementally calculate distance between origin and up to 4 vertices Used by GJK or Linear Casting. Can be implemented by the Johnson-algorithm or alternative approaches based on voronoi regions or barycentric coordinates

The TriangleCallback provides a callback for each overlapping triangle when calling ProcessAllTriangles. This callback is called by ProcessAllTriangles for all ConcaveShape derived class, such as BvhTriangleMeshShape, StaticPlaneShape and HeightfieldTerrainShape.

LocalShapeInfo gives extra information for complex shapes Currently, only TriangleMeshShape is available, so it just contains triangleIndex and subpart

It's not nice to have all this virtual function overhead, so perhaps we can also gather the points once, but then we are duplicating.

ManifoldContactPoint collects and maintains persistent contactpoints. Used to improve stability and performance of rigidbody dynamics response.

ManifoldResult is a helper class to manage contact results.

MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation. Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.

The MinkowskiSumShape is only for advanced users. This shape represents implicit based minkowski sum of two convex implicit shapes.

The MultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes. It is possible to animate the spheres for deformation, but call 'RecalcLocalAabb' after changing any sphere position/radius

User can override this nearcallback for collision filtering and more finegrained control over collision detection.

NullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.

OptimizedBvh store an AABB tree that can be quickly traversed on CPU (and SPU,GPU in future).

OptimizedBvhNode contains both internal and leaf node information. Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.

The OverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the IBroadphase broadphases. The HashedOverlappingPairCache and SortedOverlappingPairCache classes are two implementations.

PersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. Those contact points are created by the collision narrow phase. The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) reduces the cache to 4 points, when more then 4 points are added, using following rules: the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points note that some pairs of objects might have more then one contact manifold.

PHYScalarType enumerates possible scalar types. See the StridingMeshInterface for its use.

The PolyhedralConvexShape is an internal interface class for polyhedral convex shapes.

The QuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. It is used by the BvhTriangleMeshShape as midphase, and by the MultiSapBroadphase. It is recommended to use quantization for better performance and lower memory requirements.

QuantizedBvhNode is a compressed aabb node, 16 bytes. Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).

RayResultCallback is used to report new raycast results.

The ShapeHull class takes a ConvexShape, builds a simplified convex hull using ConvexHull and provides triangle indices and vertices. It can be useful for to simplify a complex convex object and for visualization of a non-polyhedral convex object. It approximates the convex hull using the supporting vertex of 42 directions.

SimulationIslandManager creates and handles simulation islands, using UnionFind.

SphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response.

The SphereShape implements an implicit sphere, centered around a local origin with radius.

SphereSphereCollisionAlgorithm provides sphere-sphere collision detection. Other features are frame-coherency (persistent data) and collision response. Also provides the most basic sample for custom/user CollisionAlgorithm

SphereSphereCollisionAlgorithm provides sphere-sphere collision detection. Other features are frame-coherency (persistent data) and collision response. Also provides the most basic sample for custom/user CollisionAlgorithm

Sphere-triangle to match the DiscreteCollisionDetectorInterface.

The StaticPlaneShape simulates an infinite non-moving (static) collision plane.

The StridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with BvhTriangleMeshShape and some other collision shapes. Using index striding of 3 it can use triangle arrays, using index striding of 1 it can handle triangle strips. It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory.

SubsimplexConvexCast 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.

The TriangleBuffer callback can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles'

The TriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. Additional meshes can be added using AddIndexedMesh. No duplcate is made of the vertex/index data, it only indexes into external vertex/index arrays. So keep those arrays around during the lifetime of this TriangleIndexVertexArray.

The TriangleMesh class is a convenience class derived from TriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the BvhTriangleMeshShape. It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. If you want to share triangle/index data between graphics mesh and collision mesh (BvhTriangleMeshShape), you can directly use TriangleIndexVertexArray or derive your own class from StridingMeshInterface. Performance of TriangleMesh and TriangleIndexVertexArray used in a BvhTriangleMeshShape is the same.

The TriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use BvhTriangleMeshShape instead.

The UniformScalingShape allows to re-use uniform scaled instances of ConvexShape in a memory efficient way. Istead of using UniformScalingShape, it is better to use the non-uniform SetLocalScaling method on convex shapes that implement it.

UnionFind calculates connected subsets Implements weighted Quick Union with path compression optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable)