| CAABBTreeBuilder | Helper class to build an AABB tree |
| CAABBTreeBuilderStats | |
| CAABBTreeToBuffer< TriangleCodec, NodeCodec > | 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< ConvexObject > | Structure that adds a convex radius |
| CRagdollSettings::AdditionalConstraint | A constraint that connects two bodies in a ragdoll (for non parent child related constraints) |
| CQuadTree::AddState | Temporary data structure to pass information between AddBodiesPrepare and AddBodiesFinalize/Abort |
| CAngleConstraintPart | |
| CSkeletalAnimation::AnimatedJoint | Contains the animation for a single joint |
| CAxisConstraintPart | |
| CRTTI::BaseClass | Base class information |
| CFixedSizeFreeList< Object >::Batch | A batch of objects that can be destructed |
| CBodyActivationListener | |
| ►CBodyCreationSettings | Settings for constructing a rigid body |
| CRagdollSettings::Part | A single rigid body sub part of the ragdoll |
| CBodyID | ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding race conditions |
| CBodyPair | Structure that holds a body pair |
| CPhysicsUpdateContext::BodyPairQueue | |
| CBodyManager::BodyStats | Helper struct that counts the number of bodies of each type |
| ►CBroadPhaseCastResult | Structure that holds a ray cast or other object cast hit |
| CRayCastResult | Specialization of cast result against a shape |
| CBroadPhaseLayer | |
| ►CByteBufferVector | |
| CByteBuffer | Simple byte buffer, aligned to a cache line |
| CCalculateSolverSteps | Class used to calculate the total number of velocity and position steps |
| CCastConvexVsTriangles | Collision detection helper that casts a convex object vs one or more triangles |
| CCompoundShape::CastRayVisitor | |
| CCompoundShape::CastRayVisitorCollector | |
| CCompoundShape::CastShapeVisitor | |
| CCastSphereVsTriangles | Collision detection helper that casts a sphere vs one or more triangles |
| CPhysicsUpdateContext::Step::CCDBody | Contains the information needed to cast a body through the scene to do continuous collision detection |
| CSkeletonMapper::Chain | 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 |
| 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 |
| CConvexHullShape::CHSGetTrianglesContext | |
| ►CCollectorType | |
| CAllHitCollisionCollector< CollectorType > | Simple implementation that collects all hits and optionally sorts them on distance |
| CAnyHitCollisionCollector< CollectorType > | Simple implementation that collects any hit |
| CClosestHitCollisionCollector< CollectorType > | Simple implementation that collects the closest / deepest hit |
| CCompoundShape::CollectTransformedShapesVisitor | |
| CCompoundShape::CollideCompoundVsShapeVisitor | |
| 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 |
| CCompoundShape::CollidePointVisitor | |
| ►CCollideSettingsBase | Settings to be passed with a collision query |
| CCollideShapeSettings | Settings to be passed with a collision query |
| CShapeCastSettings | Settings to be passed with a shape cast |
| ►CCollideShapeResult | Class that contains all information of two colliding shapes |
| CShapeCastResult | Result of a shape cast test |
| CCompoundShape::CollideShapeVsCompoundVisitor | |
| 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< ResultTypeArg, TraitsType > | Virtual interface that allows collecting multiple collision results |
| CInternalEdgeRemovingCollector | |
| 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 |
| CCollisionGroup | |
| CColor | Class that holds an RGBA color with 8-bits per component |
| CPhysicsScene::ConnectedConstraint | A constraint and how it is connected to the bodies in the scene |
| CCharacterVirtual::Contact | |
| CContactListener | |
| CContactManifold | Manifold class, describes the contact surface between two bodies |
| CContactSettings | |
| CConvexShape::CSGetTrianglesContext | |
| CDebugRendererPlayback | Class that can read a recorded stream from DebugRendererRecorder and plays it back trough a DebugRenderer |
| CHeightFieldShape::DecodingContext | |
| CNodeCodecQuadTreeHalfFloat< Alignment >::DecodingContext | This class decodes and decompresses quad tree nodes |
| CTriangleCodecIndexed8BitPackSOA4Flags::DecodingContext | This class is used to decode and decompress triangle data packed by the EncodingContext |
| CSoftBodySharedSettings::DihedralBend | |
| 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 |
| CBodyManager::DrawSettings | Draw settings |
| CSkeletonPose::DrawSettings | Draw settings |
| CDualAxisConstraintPart | |
| CDummyCalculateSolverSteps | Dummy class to replace the steps calculator when we don't need the result |
| CDVec3 | |
| CDynMatrix | Dynamic resizable matrix class |
| CEPAConvexHullBuilder::Edge | Class that holds the information of an edge |
| CSoftBodySharedSettings::Edge | An edge keeps two vertices at a constant distance using a spring: |x1 - x2| = rest length |
| CEllipse | |
| CNodeCodecQuadTreeHalfFloat< Alignment >::EncodingContext | This class encodes and compresses quad tree nodes |
| CTriangleCodecIndexed8BitPackSOA4Flags::EncodingContext | This class is used to encode and compress triangle data into a byte buffer |
| CEPAPenetrationDepth | |
| CCharacterVirtual::ExtendedUpdateSettings | Settings struct with settings for ExtendedUpdate |
| CSoftBodySharedSettings::Face | A face defines the surface of the body |
| 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 |
| 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 | |
| CFPExceptionsEnable | Dummy implementations |
| CDebugRendererRecorder::Frame | All information for a single frame |
| CGearConstraintPart | |
| CDebugRendererRecorder::GeometryBlob | Holds a single geometry draw call |
| CCompoundShape::GetIntersectingSubShapesVisitor< BoxType > | |
| CShape::GetTrianglesContext | An opaque buffer that holds shape specific information during GetTrianglesStart/Next |
| 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 |
| Cstd::hash< JPH::Ref< T > > | Declare std::hash for Ref |
| Cstd::hash< JPH::RefConst< T > > | Declare std::hash for RefConst |
| Cstd::hash< JPH::StaticArray< T, N > > | Declare std::hash for StaticArray |
| Cstd::hash< JPH::String > | Declare std::hash for String, for some reason on Linux based platforms template deduction takes the wrong variant |
| Cstd::hash< JPH::SubShapeIDPair > | Declare std::hash for SubShapeIDPair, note that std::hash is platform dependent and we need this one to be consistent because we sort on it in the ContactConstraintManager |
| CNodeCodecQuadTreeHalfFloat< Alignment >::Header | Header for the tree |
| CHingeRotationConstraintPart | |
| CHeightFieldShape::HSGetTrianglesContext | |
| CCollisionEstimationResult::Impulse | |
| CIndependentAxisConstraintPart | |
| ►CIndexedTriangleNoMaterial | Triangle with 32-bit indices |
| CIndexedTriangle | Triangle with 32-bit indices and material index |
| CSoftBodySharedSettings::InvBind | An inverse bind matrix take a skinned vertex from its bind pose into joint local space |
| CLockFreeHashMap< Key, Value >::Iterator | Non-const iterator |
| CJobSystem::Job | A class that contains information for a single unit of work |
| CSkeleton::Joint | Declare internal structure for a joint |
| ►CSkeletalAnimation::JointState | Contains the current state of a joint, a local space transformation relative to its parent joint |
| CSkeletalAnimation::Keyframe | Contains the state of a single joint at a particular time |
| CLockFreeHashMap< Key, Value >::KeyValue | A key / value pair that is inserted in the map |
| CLinearCurve | |
| CDebugRendererRecorder::LineBlob | Holds a single line segment |
| CSkeletonMapper::Locked | Joints that should have their translation locked (fixed) |
| CDebugRenderer::LOD | A single level of detail |
| CSoftBodySharedSettings::LRA | |
| CSkeletonMapper::Mapping | A joint that maps 1-on-1 to a joint in the other skeleton |
| 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< Rows, Cols > | Templatized matrix class |
| CMatrix< 2, 2 > | |
| CMinkowskiDifference< ConvexObjectA, ConvexObjectB > | 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 |
| CSoftBodyMotionProperties | This class contains the runtime information of a soft body |
| CMotorSettings | |
| CMeshShape::MSGetTrianglesContext | |
| CNodeCodecQuadTreeHalfFloat< Alignment >::Node | Node structure |
| CNodeCodecQuadTreeHalfFloat< Alignment > | |
| ►CNonCopyable | Class that makes another class non-copyable. Usage: Inherit from NonCopyable |
| ►CBodyLockBase< false, const Body > | |
| CBodyLockRead | |
| ►CBodyLockBase< true, Body > | |
| CBodyLockWrite | Specialization that locks a body for writing to |
| ►CBodyLockMultiBase< false, const Body > | |
| CBodyLockMultiRead | |
| ►CBodyLockMultiBase< true, Body > | |
| CBodyLockMultiWrite | Specialization that locks multiple bodies for writing to |
| CFixedSizeFreeList< Node > | |
| CFixedSizeFreeList< Job > | |
| CLockFreeHashMap< SubShapeIDPair, CachedManifold > | |
| CLockFreeHashMap< BodyPair, CachedBodyPair > | |
| CMutexArray< SharedMutex > | |
| CAABBTreeBuilder::Node | A node in the tree, contains the AABox for the tree and any child nodes or triangles |
| ►CBody | |
| CBodyWithMotionProperties | |
| CSoftBodyWithMotionPropertiesAndShape | |
| 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 |
| CIgnoreMultipleBodiesFilter | A simple body filter implementation that ignores multiple, specified bodies |
| CIgnoreSingleBodyFilter | A simple body filter implementation that ignores a single, specified body |
| CBodyInterface | |
| CBodyLockBase< Write, BodyType > | 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< Write, BodyType > | Base class for locking multiple bodies for the duration of the scope of this class (do not use directly) |
| CBodyManager | Class that contains all bodies |
| ►CBroadPhaseLayerFilter | Filter class for broadphase layers |
| CDefaultBroadPhaseLayerFilter | Default filter class that uses the pair filter in combination with a specified layer to filter layers |
| CSpecifiedBroadPhaseLayerFilter | Allows objects from a specific broad phase layer only |
| ►CBroadPhaseLayerInterface | Interface that the application should implement to allow mapping object layers to broadphase layers |
| CBroadPhaseLayerInterfaceMask | |
| CBroadPhaseLayerInterfaceTable | |
| ►CBroadPhaseQuery | |
| ►CBroadPhase | Used to do coarse collision detection operations to quickly prune out bodies that will not collide |
| CBroadPhaseBruteForce | Test BroadPhase implementation that does not do anything to speed up the operations. Can be used as a reference implementation |
| CBroadPhaseQuadTree | Fast SIMD based quad tree BroadPhase that is multithreading aware and tries to do a minimal amount of locking |
| ►CCharacterBase | Base class for character class |
| CCharacter | |
| CCharacterVirtual | |
| ►CConstraint | Base class for all physics constraints. A constraint removes one or more degrees of freedom for a rigid body |
| ►CTwoBodyConstraint | Base class for all constraints that involve 2 bodies. Body1 is usually considered the parent, Body2 the child |
| CConeConstraint | |
| CDistanceConstraint | This constraint is a stiff spring that holds 2 points at a fixed distance from each other |
| CFixedConstraint | |
| CGearConstraint | |
| CHingeConstraint | A hinge constraint constrains 2 bodies on a single point and allows only a single axis of rotation |
| CPathConstraint | Path constraint, used to constrain the degrees of freedom between two bodies to a path |
| CPointConstraint | A point constraint constrains 2 bodies on a single point (removing 3 degrees of freedom) |
| CPulleyConstraint | A pulley constraint |
| CRackAndPinionConstraint | |
| CSixDOFConstraint | 6 Degree Of Freedom Constraint. Allows control over each of the 6 degrees of freedom |
| CSliderConstraint | A slider constraint allows movement in only 1 axis (and no rotation). Also known as a prismatic constraint |
| CSwingTwistConstraint | |
| CVehicleConstraint | |
| CConstraintManager | A constraint manager manages all constraints of the same type |
| CContactConstraintManager | |
| CConvexHullBuilder | A convex hull builder that tries to create hulls as accurately as possible. Used for offline processing |
| CConvexHullBuilder2D | A convex hull builder that tries to create 2D hulls as accurately as possible. Used for offline processing |
| CConvexHullBuilder::Edge | Class that holds the information of an edge |
| CConvexHullBuilder::Face | Class that holds the information of one face |
| ►CDebugRenderer | |
| CDebugRendererRecorder | Implementation of DebugRenderer that records the API invocations to be played back later |
| CDebugRendererSimple | |
| 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 |
| CEPAConvexHullBuilder::Triangle | Class that holds the information of one triangle |
| CEPAConvexHullBuilder::TriangleFactory | Factory that creates triangles in a fixed size buffer |
| CFixedSizeFreeList< Object > | |
| CGJKClosestPoint | |
| CIslandBuilder | Keeps track of connected bodies and builds islands for multithreaded velocity/position update |
| ►CJobSystem | |
| CJobSystemSingleThreaded | Implementation of a JobSystem without threads, runs jobs as soon as they are added |
| ►CJobSystemWithBarrier | |
| CJobSystemThreadPool | |
| ►CJobSystem::Barrier | A job barrier keeps track of a number of jobs and allows waiting until they are all completed |
| CJobSystemSingleThreaded::BarrierImpl | |
| CLFHMAllocator | Allocator for a lock free hash map |
| ►CLFHMAllocatorContext | |
| CContactConstraintManager::ContactAllocator | Contacts are allocated in a lock free hash map |
| CLargeIslandSplitter | |
| CLockFreeHashMap< Key, Value > | |
| CMutexArray< MutexType > | |
| CNarrowPhaseQuery | |
| ►CObjectLayerFilter | Filter class for object layers |
| CDefaultObjectLayerFilter | Default filter class that uses the pair filter in combination with a specified layer to filter layers |
| CSpecifiedObjectLayerFilter | Allows objects from a specific layer only |
| ►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 |
| ►CIObjectStreamIn | Interface class for reading from an object stream |
| ►CObjectStreamIn | |
| CObjectStreamBinaryIn | Implementation of ObjectStream binary input stream |
| CObjectStreamTextIn | Implementation of ObjectStream text input stream |
| ►CIObjectStreamOut | Interface class for writing to an object stream |
| ►CObjectStreamOut | |
| CObjectStreamBinaryOut | Implementation of ObjectStream binary output 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 | |
| CPhysicsSystem | |
| CPhysicsSystem::BodiesToSleep | |
| CPhysicsUpdateContext | Information used during the Update call |
| CProfileMeasurement | Create this class on the stack to start sampling timing information of a particular scope |
| CProfileSample | |
| CProfileThread | Collects all samples of a single thread |
| CProfiler | Singleton class for managing profiling information |
| CQuadTree | |
| CRagdoll | Runtime ragdoll information |
| ►CSerializableObject | |
| ►CConstraintSettings | Class used to store the configuration of a constraint. Allows run-time creation of constraints |
| ►CTwoBodyConstraintSettings | Base class for settings for all constraints that involve 2 bodies |
| CConeConstraintSettings | Cone constraint settings, used to create a cone constraint |
| CDistanceConstraintSettings | Distance constraint settings, used to create a distance constraint |
| CFixedConstraintSettings | Fixed constraint settings, used to create a fixed constraint |
| CGearConstraintSettings | Gear constraint settings |
| CHingeConstraintSettings | Hinge constraint settings, used to create a hinge constraint |
| CPathConstraintSettings | |
| CPointConstraintSettings | Point constraint settings, used to create a point constraint |
| CPulleyConstraintSettings | |
| CRackAndPinionConstraintSettings | Rack and pinion constraint (slider & gear) settings |
| CSixDOFConstraintSettings | 6 Degree Of Freedom Constraint setup structure. Allows control over each of the 6 degrees of freedom |
| CSliderConstraintSettings | Slider constraint settings, used to create a slider constraint |
| CSwingTwistConstraintSettings | |
| CVehicleConstraintSettings | |
| ►CGroupFilter | Abstract class that checks if two CollisionGroups collide |
| CGroupFilterTable | |
| ►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 |
| ►CPhysicsMaterial | |
| CPhysicsMaterialSimple | Sample implementation of PhysicsMaterial that just holds the needed properties directly |
| ►CShapeSettings | |
| ►CCompoundShapeSettings | Base class settings to construct a compound shape |
| CMutableCompoundShapeSettings | Class that constructs a MutableCompoundShape |
| CStaticCompoundShapeSettings | Class that constructs a StaticCompoundShape. Note that if you only want a compound of 1 shape, use a RotatedTranslatedShape instead |
| ►CConvexShapeSettings | Class that constructs a ConvexShape (abstract) |
| CBoxShapeSettings | Class that constructs a BoxShape |
| CCapsuleShapeSettings | Class that constructs a CapsuleShape |
| CConvexHullShapeSettings | Class that constructs a ConvexHullShape |
| CCylinderShapeSettings | Class that constructs a CylinderShape |
| CSphereShapeSettings | Class that constructs a SphereShape |
| CTaperedCapsuleShapeSettings | Class that constructs a TaperedCapsuleShape |
| CTriangleShapeSettings | Class that constructs a TriangleShape |
| ►CDecoratedShapeSettings | Class that constructs a DecoratedShape |
| COffsetCenterOfMassShapeSettings | Class that constructs an OffsetCenterOfMassShape |
| CRotatedTranslatedShapeSettings | Class that constructs a RotatedTranslatedShape |
| CScaledShapeSettings | Class that constructs a ScaledShape |
| CHeightFieldShapeSettings | Class that constructs a HeightFieldShape |
| CMeshShapeSettings | Class that constructs a MeshShape |
| ►CVehicleControllerSettings | Basic settings object for interface that controls acceleration / deceleration of the vehicle |
| CTrackedVehicleControllerSettings | |
| ►CWheeledVehicleControllerSettings | |
| CMotorcycleControllerSettings | |
| ►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 |
| ►CShape | Base class for all shapes (collision volume of a body). Defines a virtual interface for collision detection |
| ►CCompoundShape | Base class for a compound shape |
| CMutableCompoundShape | |
| CStaticCompoundShape | |
| ►CConvexShape | Base class for all convex shapes. Defines a virtual interface |
| CBoxShape | A box, centered around the origin |
| CCapsuleShape | A capsule, implemented as a line segment with convex radius |
| CConvexHullShape | A convex hull |
| CCylinderShape | A cylinder |
| CSphereShape | |
| CTaperedCapsuleShape | A capsule with different top and bottom radii |
| 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 |
| ►CDecoratedShape | Base class for shapes that decorate another shape with extra functionality (e.g. scale, translation etc.) |
| 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 |
| CRotatedTranslatedShape | |
| 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 |
| CHeightFieldShape | A height field shape. Cannot be used as a dynamic object |
| CMeshShape | |
| CSoftBodyShape | Shape used exclusively for soft bodies. Adds the ability to perform collision checks against soft bodies |
| ►CShapeFilter | Filter class |
| CReversedShapeFilter | Helper class to reverse the order of the shapes in the ShouldCollide function |
| CSharedLock< LockType > | Helper class that is similar to std::shared_lock |
| CSoftBodyUpdateContext | Temporary data used by the update of a soft body |
| ►CStreamIn | Simple binary input stream |
| ►CStateRecorder | |
| 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 |
| CStreamInWrapper | Wrapper around std::istream |
| ►CStreamOut | Simple binary output stream |
| CStateRecorder | |
| CStreamOutWrapper | Wrapper around std::ostream |
| ►CTempAllocator | |
| CTempAllocatorImpl | Default implementation of the temp allocator that allocates a large block through malloc upfront |
| CTempAllocatorMalloc | |
| ►CTriangleGrouper | A class that groups triangles in batches of N (according to closeness) |
| CTriangleGrouperClosestCentroid | |
| CTriangleGrouperMorton | |
| ►CTriangleSplitter | A class that splits a triangle list into two parts for building a tree |
| 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/ |
| CUniqueLock< LockType > | Helper class that is similar to std::unique_lock |
| ►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 |
| ►CVehicleController | Runtime data for interface that controls acceleration / deceleration of the vehicle |
| CTrackedVehicleController | Runtime controller class for vehicle with tank tracks |
| ►CWheeledVehicleController | Runtime controller class |
| CMotorcycleController | Runtime controller class |
| ►CWheel | Base class for runtime data for a wheel, each VehicleController can implement a derived class of this |
| CWheelTV | Wheel object specifically for TrackedVehicleController |
| CWheelWV | Wheel object specifically for WheeledVehicleController |
| CSoftBodySharedSettings::OptimizationResults | Information about the optimization of the soft body, the indices of certain elements may have changed |
| COrientedBox | Oriented box |
| CPhysicsLock | |
| CPhysicsSettings | |
| ►CPhysicsStepListener | A listener class that receives a callback before every physics simulation step |
| CVehicleConstraint | |
| CPlane | An infinite plane described by the formula X . Normal + Constant = 0 |
| CLinearCurve::Point | A point on the curve |
| CPathConstraintPathHermite::Point | |
| CPolyhedronSubmergedVolumeCalculator::Point | A helper class that contains cached information about a polyhedron vertex |
| CPointConstraintPart | |
| CPointConvexSupport | Class that wraps a point so that it can be used with convex collision detection |
| CPolygonConvexSupport< VERTEX_ARRAY > | Class that wraps a polygon so that it can used with convex collision detection |
| CPolyhedronSubmergedVolumeCalculator | |
| CQuat | |
| CRackAndPinionConstraintPart | |
| CTriangleSplitter::Range | Helper struct to indicate triangle range before and after the split |
| CRayCastSettings | Settings to be passed with a ray cast |
| CRayCastT< Vec, Mat, RayCastType > | Structure that holds a single ray cast |
| ►CRayCastT< RVec3, RMat44, RRayCast > | |
| CRRayCast | |
| ►CRayCastT< Vec3, Mat44, RayCast > | |
| CRayCast | |
| CRayInvDirection | Helper structure holding the reciprocal of a ray for Ray vs AABox testing |
| CSTLAlignedAllocator< T, N >::rebind< T2 > | Converting to allocator for other type |
| CSTLAllocator< T >::rebind< T2 > | Converting to allocator for other type |
| CSTLTempAllocator< T >::rebind< T2 > | Converting to allocator for other type |
| CRef< T > | |
| CRef< Geometry > | |
| ►CRef< Job > | |
| CJobSystem::JobHandle | |
| CRef< RefTargetVirtual > | |
| CRef< Shape > | |
| CRef< Skeleton > | |
| CRef< TwoBodyConstraintSettings > | |
| CRef< VehicleControllerSettings > | |
| CRefConst< T > | |
| CRefConst< Constraint > | |
| CRefConst< GroupFilter > | |
| CRefConst< PathConstraintPath > | |
| CRefConst< PhysicsMaterial > | |
| CRefConst< RagdollSettings > | |
| CRefConst< Shape > | |
| CRefConst< ShapeSettings > | |
| CRefConst< Skeleton > | |
| CRefConst< SoftBodySharedSettings > | |
| CRefConst< TwoBodyConstraintSettings > | |
| CRefConst< VehicleCollisionTester > | |
| CRefConst< WheelSettings > | |
| CRefTarget< T > | |
| ►CRefTarget< CharacterBase > | |
| CCharacterBase | Base class for character class |
| ►CRefTarget< CharacterBaseSettings > | |
| ►CCharacterBaseSettings | Base class for configuration of a character |
| CCharacterSettings | Contains the configuration of a character |
| CCharacterVirtualSettings | Contains the configuration of a character |
| ►CRefTarget< Constraint > | |
| CConstraint | Base class for all physics constraints. A constraint removes one or more degrees of freedom for a rigid body |
| ►CRefTarget< ConstraintSettings > | |
| CConstraintSettings | Class used to store the configuration of a constraint. Allows run-time creation of constraints |
| ►CRefTarget< Geometry > | |
| CDebugRenderer::Geometry | A geometry primitive containing triangle batches for various lods |
| ►CRefTarget< GroupFilter > | |
| CGroupFilter | Abstract class that checks if two CollisionGroups collide |
| ►CRefTarget< PathConstraintPath > | |
| 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 |
| ►CRefTarget< PhysicsMaterial > | |
| CPhysicsMaterial | |
| ►CRefTarget< PhysicsScene > | |
| CPhysicsScene | Contains the creation settings of a set of bodies |
| ►CRefTarget< Ragdoll > | |
| CRagdoll | Runtime ragdoll information |
| ►CRefTarget< RagdollSettings > | |
| CRagdollSettings | Contains the structure of a ragdoll |
| ►CRefTarget< Shape > | |
| CShape | Base class for all shapes (collision volume of a body). Defines a virtual interface for collision detection |
| ►CRefTarget< ShapeSettings > | |
| CShapeSettings | |
| ►CRefTarget< SkeletalAnimation > | |
| CSkeletalAnimation | Resource for a skinned animation |
| ►CRefTarget< Skeleton > | |
| CSkeleton | Resource that contains the joint hierarchy for a skeleton |
| ►CRefTarget< SkeletonMapper > | |
| CSkeletonMapper | Class that is able to map a low detail (ragdoll) skeleton to a high detail (animation) skeleton and vice versa |
| ►CRefTarget< SoftBodySharedSettings > | |
| CSoftBodySharedSettings | |
| ►CRefTarget< VehicleCollisionTester > | |
| CVehicleCollisionTester | Class that does collision detection between wheels and ground |
| ►CRefTarget< VehicleController > | |
| CVehicleController | Runtime data for interface that controls acceleration / deceleration of the vehicle |
| ►CRefTarget< VehicleControllerSettings > | |
| CVehicleControllerSettings | Basic settings object for interface that controls acceleration / deceleration of the vehicle |
| ►CRefTarget< WheelSettings > | |
| CWheelSettings | Base class for wheel settings, each VehicleController can implement a derived class of this |
| CRefTargetVirtual | Pure virtual version of RefTarget |
| CResult< Type > | Helper class that either contains a valid result or an error |
| CResult< Ref< Shape > > | |
| CRotationEulerConstraintPart | |
| CRotationQuatConstraintPart | |
| CRTTI | |
| CSoftBodyShape::SBSGetTrianglesContext | |
| CSemaphore | |
| CSerializableAttribute | Attributes are members of classes that need to be serialized |
| CShapeCastT< Vec, Mat, ShapeCastType > | Structure that holds a single shape cast (a shape moving along a linear path in 3d space with no rotation) |
| ►CShapeCastT< RVec3, RMat44, RShapeCast > | |
| CRShapeCast | |
| ►CShapeCastT< Vec3, Mat44, ShapeCast > | |
| CShapeCast | |
| CShapeFunctions | Function table for functions on shapes |
| CSkeletonPose | Instance of a skeleton, contains the pose the current skeleton is in |
| CSoftBodySharedSettings::Skinned | A constraint that skins a vertex to joints and limits the distance that the simulated vertex can travel from this vertex |
| CSoftBodySharedSettings::SkinWeight | A joint and its skin weight |
| CSoftBodyContactListener | |
| CSoftBodyContactSettings | |
| CSoftBodyCreationSettings | |
| CSoftBodyManifold | An interface to query which vertices of a soft body are colliding with other bodies |
| CSoftBodyVertex | |
| CSphere | |
| CLargeIslandSplitter::Split | Describes a split of constraints and contacts |
| CLargeIslandSplitter::Splits | Structure that describes the resulting splits from the large island splitter |
| 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 |
| CStateRecorderFilter | User callbacks that allow determining which parts of the simulation should be saved by a StateRecorder |
| ►CStaticArray< T, N > | Simple variable length array backed by a fixed size buffer |
| CEPAConvexHullBuilder::Points | Specialized points list that allows direct access to the size |
| CEPAConvexHullBuilder::TriangleQueue | Specialized triangles list that keeps them sorted on closest distance to origin |
| CStaticArray< BodyPairQueue, cMaxConcurrency > | |
| CStaticArray< CollideShapeResult, cMaxDelayedResults > | |
| CStaticArray< Float3, cMaxVoidedFeatures > | |
| CStaticArray< Impulse, ContactPoints::Capacity > | |
| CStaticArray< JobHandle, cMaxConcurrency > | |
| CStaticArray< Part, 3 > | |
| CStaticArray< RTTI::BaseClass, 4 > | |
| CStaticArray< SerializableAttribute, 32 > | |
| CStaticArray< Vec3, 32 > | |
| CStaticArray< Vec3, 64 > | |
| CStaticArray< Vec3, cMaxPointsInHull > | |
| CStaticArray< WorldContactPoint, MaxContactPoints > | |
| CShape::Stats | Class that holds information about the shape that can be used for logging / data collection purposes |
| CTriangleSplitter::Stats | |
| CPhysicsUpdateContext::Step | Structure that contains data needed for each collision step |
| CSTLAlignedAllocator< T, N > | STL allocator that takes care that memory is aligned to N bytes |
| CSTLAllocator< T > | STL allocator that forwards to our allocation functions |
| CSTLTempAllocator< T > | STL allocator that wraps around TempAllocator |
| CStaticArray< T, N >::Storage | |
| CCompoundShape::SubShape | |
| 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 |
| CCompoundShapeSettings::SubShapeSettings | |
| ►CConvexShape::Support | Function that provides an interface for GJK |
| CBoxShape::Box | |
| CCapsuleShape::CapsuleNoConvex | |
| CCapsuleShape::CapsuleWithConvex | |
| CConvexHullShape::HullNoConvex | |
| CConvexHullShape::HullWithConvex | |
| CConvexHullShape::HullWithConvexScaled | |
| CCylinderShape::Cylinder | |
| CSphereShape::SphereNoConvex | |
| CSphereShape::SphereWithConvex | |
| CTaperedCapsuleShape::TaperedCapsule | |
| CTriangleShape::TriangleNoConvex | |
| CTriangleShape::TriangleWithConvex | |
| CConvexShape::SupportBuffer | Buffer to hold a Support object, used to avoid dynamic memory allocations |
| CSwingTwistConstraintPart | |
| CDebugRendererRecorder::TextBlob | Holds a single text entry |
| CQuadTree::Tracking | Data to track location of a Body in the tree |
| CTransformedConvexObject< ConvexObject > | |
| CTransformedShape | |
| CDebugRenderer::Triangle | A single triangle |
| CTriangle | A simple triangle and its material |
| CDebugRendererRecorder::TriangleBlob | Holds a single triangle |
| CTriangleCodecIndexed8BitPackSOA4Flags::TriangleBlock | A block of 4 triangles |
| CTriangleCodecIndexed8BitPackSOA4Flags::TriangleBlockHeader | A triangle header, will be followed by one or more TriangleBlocks |
| CTriangleCodecIndexed8BitPackSOA4Flags | |
| CTriangleConvexSupport | Class that wraps a triangle so that it can used with convex collision detection |
| CTriangleCodecIndexed8BitPackSOA4Flags::TriangleHeader | |
| CTriangleShape::TSGetTrianglesContext | |
| CSkeletonMapper::Unmapped | Joints that could not be mapped from skeleton 1 to 2 |
| CBroadPhase::UpdateState | Context used during broadphase update |
| CQuadTree::UpdateState | |
| CUVec4 | |
| CUVec8 | |
| CTriangleCodecIndexed8BitPackSOA4Flags::ValidationContext | This class is used to validate that the triangle data will not be degenerate after compression |
| CVec3 | |
| CVec4 | |
| CVec8 | |
| CVector< Rows > | Templatized vector class |
| CVector< 2 > | |
| CVehicleAntiRollBar | |
| CVehicleDifferentialSettings | |
| ►CVehicleEngineSettings | Generic properties for a vehicle engine |
| CVehicleEngine | Runtime data for engine |
| ►CVehicleTrackSettings | Generic properties for tank tracks |
| CVehicleTrack | Runtime data for tank tracks |
| ►CVehicleTransmissionSettings | Configuration for the transmission of a vehicle (gear box) |
| CVehicleTransmission | Runtime data for transmission |
| CDebugRenderer::Vertex | Vertex format used by the triangle renderer |
| CSoftBodySharedSettings::Vertex | A vertex is a particle, the data in this structure is only used during creation of the soft body and not during simulation |
| CSoftBodySharedSettings::VertexAttributes | |
| CTriangleCodecIndexed8BitPackSOA4Flags::VertexData | A single packed vertex |
| CSoftBodySharedSettings::Volume | Volume constraint, keeps the volume of a tetrahedron constant |
| ►Cmutex | |
| CMutex | |
| ►Cshared_mutex | |
| CSharedMutex | |
1.10.0