Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

►Nstd
Chash< JPH::StaticArray< T, N > >	Declare std::hash for StaticArray
Chash< JPH::String >	Declare std::hash for String, for some reason on Linux based platforms template deduction takes the wrong variant
►CAABBTreeBuilder	Helper class to build an AABB tree
CNode	A node in the tree, contains the AABox for the tree and any child nodes or triangles
CAABBTreeBuilderStats
CAABBTreeToBuffer	Conversion algorithm that converts an AABB tree to an optimized binary buffer
CAABox	Axis aligned box
CAABoxCast	Structure that holds AABox moving linearly through 3d space
CAddConvexRadius	Structure that adds a convex radius
CAllHitCollisionCollector	Simple implementation that collects all hits and optionally sorts them on distance
CAllocatorHasReallocate	Default implementation of AllocatorHasReallocate which tells if an allocator has a reallocate function
CAllocatorHasReallocate< STLAllocator< T > >	The STLAllocator implements the reallocate function if the alignment of the class is smaller or equal to the default alignment for the platform
CAngleConstraintPart
CAnyHitCollisionCollector	Simple implementation that collects any hit
CArray
CAxisConstraintPart
CBody
CBodyActivationListener
CBodyCreationSettings	Settings for constructing a rigid body
CBodyDrawFilter	Class function to filter out bodies for debug rendering, returns true if body should be rendered
CBodyFilter	Class function to filter out bodies, returns true if test should collide with body
CBodyID	ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding race conditions
CBodyInterface
CBodyLockBase	Base class for locking bodies for the duration of the scope of this class (do not use directly)
CBodyLockInterface	Base class interface for locking a body. Usually you will use BodyLockRead / BodyLockWrite / BodyLockMultiRead / BodyLockMultiWrite instead
CBodyLockInterfaceLocking	Implementation that uses the body manager to lock the correct mutex for a body
CBodyLockInterfaceNoLock	Implementation that performs no locking (assumes the lock has already been taken)
CBodyLockMultiBase	Base class for locking multiple bodies for the duration of the scope of this class (do not use directly)
CBodyLockMultiRead
CBodyLockMultiWrite	Specialization that locks multiple bodies for writing to
CBodyLockRead
CBodyLockWrite	Specialization that locks a body for writing to
►CBodyManager	Class that contains all bodies
CBodyStats	Helper struct that counts the number of bodies of each type
CDrawSettings	Draw settings
CBodyPair	Structure that holds a body pair
CBodyWithMotionProperties
►CBoxShape	A box, centered around the origin
CBox
CBoxShapeSettings	Class that constructs a BoxShape
►CBroadPhase	Used to do coarse collision detection operations to quickly prune out bodies that will not collide
CUpdateState	Context used during broadphase update
CBroadPhaseBruteForce	Test BroadPhase implementation that does not do anything to speed up the operations. Can be used as a reference implementation
CBroadPhaseCastResult	Structure that holds a ray cast or other object cast hit
CBroadPhaseLayer
CBroadPhaseLayerFilter	Filter class for broadphase layers
CBroadPhaseLayerInterface	Interface that the application should implement to allow mapping object layers to broadphase layers
CBroadPhaseLayerInterfaceMask
CBroadPhaseLayerInterfaceTable
CBroadPhaseQuadTree	Fast SIMD based quad tree BroadPhase that is multithreading aware and tries to do a minimal amount of locking
CBroadPhaseQuery
CBVec16	A vector consisting of 16 bytes
CByteBuffer	Simple byte buffer, aligned to a cache line
CCalculateSolverSteps	Class used to calculate the total number of velocity and position steps
►CCapsuleShape	A capsule, implemented as a line segment with convex radius
CCapsuleNoConvex
CCapsuleWithConvex
CCapsuleShapeSettings	Class that constructs a CapsuleShape
CCastConvexVsTriangles	Collision detection helper that casts a convex object vs one or more triangles
CCastSphereVsTriangles	Collision detection helper that casts a sphere vs one or more triangles
CCharacter
CCharacterBase	Base class for character class
CCharacterBaseSettings	Base class for configuration of a character
CCharacterContactListener	This class receives callbacks when a virtual character hits something
CCharacterContactSettings	This class contains settings that allow you to override the behavior of a character's collision response
CCharacterSettings	Contains the configuration of a character
►CCharacterVirtual
CContact
CExtendedUpdateSettings	Settings struct with settings for ExtendedUpdate
CCharacterVirtualSettings	Contains the configuration of a character
CCharacterVsCharacterCollision
CCharacterVsCharacterCollisionSimple
CClosestHitCollisionCollector	Simple implementation that collects the closest / deepest hit
CCollideConvexVsTriangles	Collision detection helper that collides a convex object vs one or more triangles
CCollidePointResult	Structure that holds the result of colliding a point against a shape
CCollideSettingsBase	Settings to be passed with a collision query
CCollideShapeResult	Class that contains all information of two colliding shapes
CCollideShapeSettings	Settings to be passed with a collision query
CCollideSoftBodyVertexIterator
CCollideSoftBodyVerticesVsTriangles	Collision detection helper that collides soft body vertices vs triangles
CCollideSphereVsTriangles	Collision detection helper that collides a sphere vs one or more triangles
CCollisionCollector	Virtual interface that allows collecting multiple collision results
CCollisionCollectorTraitsCastRay	Traits to use for CastRay
CCollisionCollectorTraitsCastShape	Traits to use for CastShape
CCollisionCollectorTraitsCollideShape	Traits to use for CollideShape
CCollisionDispatch	Dispatch function, main function to handle collisions between shapes
►CCollisionEstimationResult	A structure that contains the estimated contact and friction impulses and the resulting body velocities
CImpulse
CCollisionGroup
CColor	Class that holds an RGBA color with 8-bits per component
►CCompoundShape	Base class for a compound shape
CCastRayVisitor
CCastRayVisitorCollector
CCastShapeVisitor
CCollectTransformedShapesVisitor
CCollideCompoundVsShapeVisitor
CCollidePointVisitor
CCollideShapeVsCompoundVisitor
CGetIntersectingSubShapesVisitor
CSubShape
►CCompoundShapeSettings	Base class settings to construct a compound shape
CSubShapeSettings
CConeConstraint
CConeConstraintSettings	Cone constraint settings, used to create a cone constraint
CConstraint	Base class for all physics constraints. A constraint removes one or more degrees of freedom for a rigid body
CConstraintManager	A constraint manager manages all constraints of the same type
CConstraintSettings	Class used to store the configuration of a constraint. Allows run-time creation of constraints
►CContactConstraintManager
CContactAllocator	Contacts are allocated in a lock free hash map
CContactListener
CContactManifold	Manifold class, describes the contact surface between two bodies
CContactSettings
►CConvexHullBuilder	A convex hull builder that tries to create hulls as accurately as possible. Used for offline processing
CEdge	Class that holds the information of an edge
CFace	Class that holds the information of one face
CConvexHullBuilder2D	A convex hull builder that tries to create 2D hulls as accurately as possible. Used for offline processing
►CConvexHullShape	A convex hull
CCHSGetTrianglesContext
CHullNoConvex
CHullWithConvex
CHullWithConvexScaled
CConvexHullShapeSettings	Class that constructs a ConvexHullShape
►CConvexShape	Base class for all convex shapes. Defines a virtual interface
CCSGetTrianglesContext
CSupport	Function that provides an interface for GJK
CSupportBuffer	Buffer to hold a Support object, used to avoid dynamic memory allocations
CConvexShapeSettings	Class that constructs a ConvexShape (abstract)
►CCylinderShape	A cylinder
CCylinder
CCylinderShapeSettings	Class that constructs a CylinderShape
►CDebugRenderer
CGeometry	A geometry primitive containing triangle batches for various lods
CLOD	A single level of detail
CTriangle	A single triangle
CVertex	Vertex format used by the triangle renderer
CDebugRendererPlayback	Class that can read a recorded stream from DebugRendererRecorder and plays it back trough a DebugRenderer
►CDebugRendererRecorder	Implementation of DebugRenderer that records the API invocations to be played back later
CFrame	All information for a single frame
CGeometryBlob	Holds a single geometry draw call
CLineBlob	Holds a single line segment
CTextBlob	Holds a single text entry
CTriangleBlob	Holds a single triangle
CDebugRendererSimple
CDecoratedShape	Base class for shapes that decorate another shape with extra functionality (e.g. scale, translation etc.)
CDecoratedShapeSettings	Class that constructs a DecoratedShape
CDefaultBroadPhaseLayerFilter	Default filter class that uses the pair filter in combination with a specified layer to filter layers
CDefaultObjectLayerFilter	Default filter class that uses the pair filter in combination with a specified layer to filter layers
CDistanceConstraint	This constraint is a stiff spring that holds 2 points at a fixed distance from each other
CDistanceConstraintSettings	Distance constraint settings, used to create a distance constraint
CDMat44	Holds a 4x4 matrix of floats with the last column consisting of doubles
CDouble3	Class that holds 3 doubles. Used as a storage class. Convert to DVec3 for calculations
CDualAxisConstraintPart
CDummyCalculateSolverSteps	Dummy class to replace the steps calculator when we don't need the result
CDVec3
CDynMatrix	Dynamic resizable matrix class
CEllipse
CEmptyShape
CEmptyShapeSettings	Class that constructs an EmptyShape
►CEPAConvexHullBuilder	A convex hull builder specifically made for the EPA penetration depth calculation. It trades accuracy for speed and will simply abort of the hull forms defects due to numerical precision problems
CEdge	Class that holds the information of an edge
CPoints	Specialized points list that allows direct access to the size
CTriangle	Class that holds the information of one triangle
CTriangleFactory	Factory that creates triangles in a fixed size buffer
CTriangleQueue	Specialized triangles list that keeps them sorted on closest distance to origin
CEPAPenetrationDepth
CFactory	This class is responsible for creating instances of classes based on their name or hash and is mainly used for deserialization of saved data
CFixedConstraint
CFixedConstraintSettings	Fixed constraint settings, used to create a fixed constraint
►CFixedSizeFreeList
CBatch	A batch of objects that can be destructed
CFloat2	Class that holds 2 floats, used as a storage class mainly
CFloat3	Class that holds 3 floats. Used as a storage class. Convert to Vec3 for calculations
CFloat4	Class that holds 4 float values. Convert to Vec4 to perform calculations
CFPExceptionDisableDivByZero
CFPExceptionDisableInvalid
CFPExceptionDisableOverflow
CFPExceptionsEnable	Dummy implementations
CGearConstraint
CGearConstraintPart
CGearConstraintSettings	Gear constraint settings
CGetTrianglesContextMultiVertexList	Implementation of GetTrianglesStart/Next that uses a multiple fixed lists of vertices for the triangles. These are transformed into world space when getting the triangles
CGetTrianglesContextVertexList	Implementation of GetTrianglesStart/Next that uses a fixed list of vertices for the triangles. These are transformed into world space when getting the triangles
CGJKClosestPoint
CGroupFilter	Abstract class that checks if two CollisionGroups collide
CGroupFilterTable
CHash	Fallback hash function that calls T::GetHash()
CHash< const char * >	A hash function for character pointers
CHash< double >	A hash function for doubles
CHash< float >	A hash function for floats
CHash< std::string_view >	A hash function for std::string_view
CHash< String >	A hash function for String
CHash< T * >	A fallback function for generic pointers
►CHashTable
Cconst_iterator	Const iterator
Citerator	Non-const iterator
►CHeightFieldShape
CDecodingContext
CHSGetTrianglesContext
CHeightFieldShapeSettings	Class that constructs a HeightFieldShape
CHingeConstraint	A hinge constraint constrains 2 bodies on a single point and allows only a single axis of rotation
CHingeConstraintSettings	Hinge constraint settings, used to create a hinge constraint
CHingeRotationConstraintPart
CIgnoreMultipleBodiesFilter	A simple body filter implementation that ignores multiple, specified bodies
CIgnoreSingleBodyFilter	A simple body filter implementation that ignores a single, specified body
CIgnoreSingleBodyFilterChained	Ignores a single body and chains the filter to another filter
CIndependentAxisConstraintPart
CIndexedTriangle	Triangle with 32-bit indices and material index
CIndexedTriangleNoMaterial	Triangle with 32-bit indices
CInternalEdgeRemovingCollector
CIObjectStreamIn	Interface class for reading from an object stream
CIObjectStreamOut	Interface class for writing to an object stream
CIslandBuilder	Keeps track of connected bodies and builds islands for multithreaded velocity/position update
►CJobSystem
CBarrier	A job barrier keeps track of a number of jobs and allows waiting until they are all completed
CJob	A class that contains information for a single unit of work
CJobHandle
►CJobSystemSingleThreaded	Implementation of a JobSystem without threads, runs jobs as soon as they are added
CBarrierImpl
CJobSystemThreadPool
CJobSystemWithBarrier
►CLargeIslandSplitter
CSplit	Describes a split of constraints and contacts
CSplits	Structure that describes the resulting splits from the large island splitter
CLFHMAllocator	Allocator for a lock free hash map
CLFHMAllocatorContext
►CLinearCurve
CPoint	A point on the curve
►CLockFreeHashMap
CIterator	Non-const iterator
CKeyValue	A key / value pair that is inserted in the map
CMassProperties	Describes the mass and inertia properties of a body. Used during body construction only
CMat44	Holds a 4x4 matrix of floats, but supports also operations on the 3x3 upper left part of the matrix
CMatrix	Templatized matrix class
►CMeshShape
CMSGetTrianglesContext
CMeshShapeSettings	Class that constructs a MeshShape
CMinkowskiDifference	Structure that performs a Minkowski difference A - B
CMortonCode
CMotionProperties	The Body class only keeps track of state for static bodies, the MotionProperties class keeps the additional state needed for a moving Body. It has a 1-on-1 relationship with the body
CMotorcycleController	Runtime controller class
CMotorcycleControllerSettings
CMotorSettings
CMutableCompoundShape
CMutableCompoundShapeSettings	Class that constructs a MutableCompoundShape
CMutex
CMutexArray
CNarrowPhaseQuery
►CNodeCodecQuadTreeHalfFloat
CDecodingContext	This class decodes and decompresses quad tree nodes
CEncodingContext	This class encodes and compresses quad tree nodes
CHeader	Header for the tree
CNode	Node structure
CNonCopyable	Class that makes another class non-copyable. Usage: Inherit from NonCopyable
CObjectLayerFilter	Filter class for object layers
CObjectLayerPairFilter	Filter class to test if two objects can collide based on their object layer. Used while finding collision pairs
CObjectLayerPairFilterMask
CObjectLayerPairFilterTable
CObjectStream	Base class for object stream input and output streams
CObjectStreamBinaryIn	Implementation of ObjectStream binary input stream
CObjectStreamBinaryOut	Implementation of ObjectStream binary output stream
CObjectStreamIn
CObjectStreamOut
CObjectStreamTextIn	Implementation of ObjectStream text input stream
CObjectStreamTextOut	Implementation of ObjectStream text output stream
CObjectVsBroadPhaseLayerFilter	Class to test if an object can collide with a broadphase layer. Used while finding collision pairs
CObjectVsBroadPhaseLayerFilterMask
CObjectVsBroadPhaseLayerFilterTable
COffsetCenterOfMassShape	This shape will shift the center of mass of a child shape, it can e.g. be used to lower the center of mass of an unstable object like a boat to make it stable
COffsetCenterOfMassShapeSettings	Class that constructs an OffsetCenterOfMassShape
COrientedBox	Oriented box
CPathConstraint	Path constraint, used to constrain the degrees of freedom between two bodies to a path
CPathConstraintPath	The path for a path constraint. It allows attaching two bodies to each other while giving the second body the freedom to move along a path relative to the first
►CPathConstraintPathHermite	A path that follows a Hermite spline
CPoint
CPathConstraintSettings
CPhysicsLock
CPhysicsMaterial
CPhysicsMaterialSimple	Sample implementation of PhysicsMaterial that just holds the needed properties directly
►CPhysicsScene	Contains the creation settings of a set of bodies
CConnectedConstraint	A constraint and how it is connected to the bodies in the scene
CPhysicsSettings
CPhysicsStepListener	A listener class that receives a callback before every physics simulation step
CPhysicsStepListenerContext	Context information for the step listener
►CPhysicsSystem
CBodiesToSleep
►CPhysicsUpdateContext	Information used during the Update call
CBodyPairQueue
►CStep	Structure that contains data needed for each collision step
CCCDBody	Contains the information needed to cast a body through the scene to do continuous collision detection
CPlane	An infinite plane described by the formula X . Normal + Constant = 0
►CPlaneShape
CPSGetTrianglesContext
CPlaneShapeSettings	Class that constructs a PlaneShape
CPointConstraint	A point constraint constrains 2 bodies on a single point (removing 3 degrees of freedom)
CPointConstraintPart
CPointConstraintSettings	Point constraint settings, used to create a point constraint
CPointConvexSupport	Class that wraps a point so that it can be used with convex collision detection
CPolygonConvexSupport	Class that wraps a polygon so that it can used with convex collision detection
►CPolyhedronSubmergedVolumeCalculator
CPoint	A helper class that contains cached information about a polyhedron vertex
CProfileMeasurement	Create this class on the stack to start sampling timing information of a particular scope
CProfiler	Singleton class for managing profiling information
CProfileSample
CProfileThread	Collects all samples of a single thread
CPulleyConstraint	A pulley constraint
CPulleyConstraintSettings
►CQuadTree
CAddState	Temporary data structure to pass information between AddBodiesPrepare and AddBodiesFinalize/Abort
CTracking	Data to track location of a Body in the tree
CUpdateState
CQuat
CRackAndPinionConstraint
CRackAndPinionConstraintPart
CRackAndPinionConstraintSettings	Rack and pinion constraint (slider & gear) settings
CRagdoll	Runtime ragdoll information
►CRagdollSettings	Contains the structure of a ragdoll
CAdditionalConstraint	A constraint that connects two bodies in a ragdoll (for non parent child related constraints)
CPart	A single rigid body sub part of the ragdoll
CRayCast
CRayCastResult	Specialization of cast result against a shape
CRayCastSettings	Settings to be passed with a ray cast
CRayCastT	Structure that holds a single ray cast
CRayInvDirection	Helper structure holding the reciprocal of a ray for Ray vs AABox testing
CRef
CRefConst
CRefTarget
CRefTargetVirtual	Pure virtual version of RefTarget
CResult	Helper class that either contains a valid result or an error
CReversedShapeFilter	Helper class to reverse the order of the shapes in the ShouldCollide function
CRotatedTranslatedShape
CRotatedTranslatedShapeSettings	Class that constructs a RotatedTranslatedShape
CRotationEulerConstraintPart
CRotationQuatConstraintPart
CRRayCast
CRShapeCast
►CRTTI
CBaseClass	Base class information
CScaledShape	A shape that scales a child shape in local space of that shape. The scale can be non-uniform and can even turn it inside out when one or three components of the scale are negative
CScaledShapeSettings	Class that constructs a ScaledShape
CScopeExit	Class that calls a function when it goes out of scope
CSemaphore
CSerializableAttribute	Attributes are members of classes that need to be serialized
CSerializableObject
►CShape	Base class for all shapes (collision volume of a body). Defines a virtual interface for collision detection
CGetTrianglesContext	An opaque buffer that holds shape specific information during GetTrianglesStart/Next
CStats	Class that holds information about the shape that can be used for logging / data collection purposes
CShapeCast
CShapeCastResult	Result of a shape cast test
CShapeCastSettings	Settings to be passed with a shape cast
CShapeCastT	Structure that holds a single shape cast (a shape moving along a linear path in 3d space with no rotation)
CShapeFilter	Filter class
CShapeFunctions	Function table for functions on shapes
CShapeSettings
CSharedLock	Helper class that is similar to std::shared_lock
CSharedMutex
CSimShapeFilter	Filter class used during the simulation (PhysicsSystem::Update) to filter out collisions at shape level
CSimShapeFilterWrapper
CSimShapeFilterWrapperUnion
CSixDOFConstraint	6 Degree Of Freedom Constraint. Allows control over each of the 6 degrees of freedom
CSixDOFConstraintSettings	6 Degree Of Freedom Constraint setup structure. Allows control over each of the 6 degrees of freedom
►CSkeletalAnimation	Resource for a skinned animation
CAnimatedJoint	Contains the animation for a single joint
CJointState	Contains the current state of a joint, a local space transformation relative to its parent joint
CKeyframe	Contains the state of a single joint at a particular time
►CSkeleton	Resource that contains the joint hierarchy for a skeleton
CJoint	Declare internal structure for a joint
►CSkeletonMapper	Class that is able to map a low detail (ragdoll) skeleton to a high detail (animation) skeleton and vice versa
CChain	A joint chain that starts with a 1-on-1 mapped joint and ends with a 1-on-1 mapped joint with intermediate joints that cannot be mapped
CLocked	Joints that should have their translation locked (fixed)
CMapping	A joint that maps 1-on-1 to a joint in the other skeleton
CUnmapped	Joints that could not be mapped from skeleton 1 to 2
►CSkeletonPose	Instance of a skeleton, contains the pose the current skeleton is in
CDrawSettings	Draw settings
CSliderConstraint	A slider constraint allows movement in only 1 axis (and no rotation). Also known as a prismatic constraint
CSliderConstraintSettings	Slider constraint settings, used to create a slider constraint
CSoftBodyContactListener
CSoftBodyContactSettings
CSoftBodyCreationSettings
CSoftBodyManifold	An interface to query which vertices of a soft body are colliding with other bodies
CSoftBodyMotionProperties	This class contains the runtime information of a soft body
►CSoftBodyShape	Shape used exclusively for soft bodies. Adds the ability to perform collision checks against soft bodies
CSBSGetTrianglesContext
►CSoftBodySharedSettings
CDihedralBend
CEdge	An edge keeps two vertices at a constant distance using a spring: |x1 - x2| = rest length
CFace	A face defines the surface of the body
CInvBind	An inverse bind matrix take a skinned vertex from its bind pose into joint local space
CLRA
COptimizationResults	Information about the optimization of the soft body, the indices of certain elements may have changed
CSkinned	A constraint that skins a vertex to joints and limits the distance that the simulated vertex can travel from this vertex
CSkinWeight	A joint and its skin weight
CVertex	A vertex is a particle, the data in this structure is only used during creation of the soft body and not during simulation
CVertexAttributes
CVolume	Volume constraint, keeps the volume of a tetrahedron constant
CSoftBodyUpdateContext	Temporary data used by the update of a soft body
CSoftBodyVertex
CSoftBodyWithMotionPropertiesAndShape
CSpecifiedBroadPhaseLayerFilter	Allows objects from a specific broad phase layer only
CSpecifiedObjectLayerFilter	Allows objects from a specific layer only
CSphere
►CSphereShape
CSphereNoConvex
CSphereWithConvex
CSphereShapeSettings	Class that constructs a SphereShape
CSpringPart	Class used in other constraint parts to calculate the required bias factor in the lagrange multiplier for creating springs
CSpringSettings	Settings for a linear or angular spring
CStateRecorder
CStateRecorderFilter	User callbacks that allow determining which parts of the simulation should be saved by a StateRecorder
CStateRecorderImpl	Implementation of the StateRecorder class that uses a stringstream as underlying store and that implements checking if the state doesn't change upon reading
►CStaticArray	Simple variable length array backed by a fixed size buffer
CStorage
CStaticCompoundShape
CStaticCompoundShapeSettings	Class that constructs a StaticCompoundShape. Note that if you only want a compound of 1 shape, use a RotatedTranslatedShape instead
►CSTLAlignedAllocator	STL allocator that takes care that memory is aligned to N bytes
Crebind	Converting to allocator for other type
►CSTLAllocator	STL allocator that forwards to our allocation functions
Crebind	Converting to allocator for other type
►CSTLTempAllocator	STL allocator that wraps around TempAllocator
Crebind	Converting to allocator for other type
CStreamIn	Simple binary input stream
CStreamInWrapper	Wrapper around std::istream
CStreamOut	Simple binary output stream
CStreamOutWrapper	Wrapper around std::ostream
CStridedPtr
CSubShapeID	A sub shape id contains a path to an element (usually a triangle or other primitive type) of a compound shape
CSubShapeIDCreator
CSubShapeIDPair	A pair of bodies and their sub shape ID's. Can be used as a key in a map to find a contact point
CSwingTwistConstraint
CSwingTwistConstraintPart
CSwingTwistConstraintSettings
►CTaperedCapsuleShape	A capsule with different top and bottom radii
CTaperedCapsule
CTaperedCapsuleShapeSettings	Class that constructs a TaperedCapsuleShape
►CTaperedCylinderShape	A cylinder with different top and bottom radii
CTaperedCylinder
CTCSGetTrianglesContext
CTaperedCylinderShapeSettings	Class that constructs a TaperedCylinderShape
CTempAllocator
CTempAllocatorImpl	Default implementation of the temp allocator that allocates a large block through malloc upfront
CTempAllocatorImplWithMallocFallback	Implementation of the TempAllocator that tries to allocate from a large preallocated block, but falls back to malloc when it is exhausted
CTempAllocatorMalloc
CTrackedVehicleController	Runtime controller class for vehicle with tank tracks
CTrackedVehicleControllerSettings
CTransformedConvexObject
CTransformedShape
CTriangle	A simple triangle and its material
►CTriangleCodecIndexed8BitPackSOA4Flags
CDecodingContext	This class is used to decode and decompress triangle data packed by the EncodingContext
CEncodingContext	This class is used to encode and compress triangle data into a byte buffer
CTriangleBlock	A block of 4 triangles
CTriangleBlockHeader	A triangle header, will be followed by one or more TriangleBlocks
CTriangleHeader
CValidationContext	This class is used to validate that the triangle data will not be degenerate after compression
CVertexData	A single packed vertex
CTriangleConvexSupport	Class that wraps a triangle so that it can used with convex collision detection
CTriangleGrouper	A class that groups triangles in batches of N (according to closeness)
CTriangleGrouperClosestCentroid
CTriangleGrouperMorton
►CTriangleShape	A single triangle, not the most efficient way of creating a world filled with triangles but can be used as a query shape for example
CTriangleNoConvex
CTriangleWithConvex
CTSGetTrianglesContext
CTriangleShapeSettings	Class that constructs a TriangleShape
►CTriangleSplitter	A class that splits a triangle list into two parts for building a tree
CRange	Helper struct to indicate triangle range before and after the split
CStats
CTriangleSplitterBinning	Binning splitter approach taken from: Realtime Ray Tracing on GPU with BVH-based Packet Traversal by Johannes Gunther et al
CTriangleSplitterFixedLeafSize
CTriangleSplitterLongestAxis	Splitter using center of bounding box with longest axis
CTriangleSplitterMean	Splitter using mean of axis with biggest centroid deviation
CTriangleSplitterMorton	Splitter using Morton codes, see: http://devblogs.nvidia.com/parallelforall/thinking-parallel-part-iii-tree-construction-gpu/
CTwoBodyConstraint	Base class for all constraints that involve 2 bodies. Body1 is usually considered the parent, Body2 the child
CTwoBodyConstraintSettings	Base class for settings for all constraints that involve 2 bodies
CUniqueLock	Helper class that is similar to std::unique_lock
CUnorderedMap
CUnorderedMapDetail	Internal helper class to provide context for UnorderedMap
CUnorderedSet
CUnorderedSetDetail	Internal helper class to provide context for UnorderedSet
CUVec4
CVec3
CVec4
CVector	Templatized vector class
CVehicleAntiRollBar
CVehicleCollisionTester	Class that does collision detection between wheels and ground
CVehicleCollisionTesterCastCylinder	Collision tester that tests collision using a cylinder shape
CVehicleCollisionTesterCastSphere	Collision tester that tests collision using a sphere cast
CVehicleCollisionTesterRay	Collision tester that tests collision using a raycast
CVehicleConstraint
CVehicleConstraintSettings
CVehicleController	Runtime data for interface that controls acceleration / deceleration of the vehicle
CVehicleControllerSettings	Basic settings object for interface that controls acceleration / deceleration of the vehicle
CVehicleDifferentialSettings
CVehicleEngine	Runtime data for engine
CVehicleEngineSettings	Generic properties for a vehicle engine
CVehicleTrack	Runtime data for tank tracks
CVehicleTrackSettings	Generic properties for tank tracks
CVehicleTransmission	Runtime data for transmission
CVehicleTransmissionSettings	Configuration for the transmission of a vehicle (gear box)
CWheel	Base class for runtime data for a wheel, each VehicleController can implement a derived class of this
CWheeledVehicleController	Runtime controller class
CWheeledVehicleControllerSettings
CWheelSettings	Base class for wheel settings, each VehicleController can implement a derived class of this
CWheelSettingsTV	WheelSettings object specifically for TrackedVehicleController
CWheelSettingsWV	WheelSettings object specifically for WheeledVehicleController
CWheelTV	Wheel object specifically for TrackedVehicleController
CWheelWV	Wheel object specifically for WheeledVehicleController