Detects whether each character is inside a LadderVolume and writes the climb axis into CharacterMovementComponent (onLadder / ladderAxis / ladderTopY). Must tick BEFORE CharacterMovementSystem, same contract as Character
A skinned submesh handed to the cloth system by the layer that owns the mesh (Physics cannot see the renderer's meshes or the animator). Positions are the bind pose in mesh space; indices is the triangle list over them
The pose to skin against this frame: the animator's final skinning palette (bind → posed, mesh space), the entity's world position and rotation, and its uniform scale.
Creates one Jolt soft body per Cloth entity (grid + XPBD edge/ shear/bend constraints from SoftBodySharedSettings::CreateConstraints), mirrors world-space vertex bounds into the component every frame, and removes the bod
The channel a body identifies as (object channels) or a query traces against (trace channels). Object channels describe what a collider IS; trace channels describe a gameplay line-of-sight style query that is independent
A body's object channel plus its per-channel response to every other channel. Block/Overlap/Ignore mirror UE's per-channel model; ResolvePair collapses two containers into the single response that governs a contact.
Triangle geometry pulled off a mesh asset for collision, in the asset's own unscaled space. The cooked shape is scaled at body creation instead, so ten crates at ten sizes still share one cooked mesh.
The seam that lets Physics cook collision from a mesh asset without reaching up into Game: Game installs a resolver at image load, Physics calls it at body creation. A null resolver simply means no mesh colliders resolve
Cooked collision shapes shared by cache key. A triangle mesh costs multiple megabytes and a measurable slice of level load to build; a hundred instances of one prop must not each cook their own copy of it. Lookup and ins
The dt-correct planar (XZ) velocity step shared by CharacterMovementSystem, the client's prediction replay and the server's pawn step — one formula, or reconciliation fights the simulation. Grounded: friction redirects the current velocity toward the input, maxAcceleration closes the speed gap, and speed above the desired cap (sprint release, external launch) bleeds off at brakingDeceleration instead of clamping in one frame. No input: proportional friction plus constant braking, never through zero. Airborne: acceleration scaled by airControl, capped so air input steers but never gains speed beyond entry momentum or walk speed.
Where the cloth's vertices come from: a procedural grid at the entity, or one submesh of the entity's skinned mesh, whose vertices follow the skin and simulate within Max Distance of it.
Cloth simulation on Jolt's XPBD soft body. The system builds a horizontal segmentsX × segmentsY vertex grid at the entity's world transform (local XZ plane), optionally pins the first row (the local -Z edge), and lets Jo
A climbable region. Placed as a box centered on the owning entity's transform; a character whose feet fall inside it can enter Ladder movement and climb along climbAxis (world space, usually up). CharacterLadderSystem te
A per-bone-chain physical-animation profile: the motor gains that drive the simulated bodies toward the animated pose. strength is the motor spring frequency in Hz (higher = tracks the animation tighter, recovers faste
Motor gains for one sub-chain of the driven chain: the named bone plus (when includeChildren) its descendants take these instead of the component profile. Overrides apply in order, so a broad spine entry can be narrowed
Blends simulated physics onto an animated skeleton over a bone chain — hit reactions that recover. The named chain root plus (optionally) its descendants are simulated as a powered ragdoll: motors pull the bodies toward
Queued hit-reaction impulses drained each tick after the bodies are materialized. boneIndex == -1 targets the chain root body. hasPoint=false applies at the body's center of mass.
Points a skeletal-mesh actor at its authored .physasset. The physics asset owns the collision bodies and constraints; RagdollSystem builds the Jolt ragdoll from it (via RagdollBuilder::BuildFromAsset) instead of auto-g
Per-bone tweaks applied on top of the auto-rig defaults. All fields are multiplicative / delta-style (massScale = 1.0 means "use builder default"; swingDeg = 0 means "use builder default 45°"). Designers override sparsel
Queued hit-reaction impulses. Gameplay code calls Ragdoll.ApplyImpulse / ApplyImpulseAtBone / EnablePhysics(impulse, point) and the request lands here. RagdollSystem drains the queue each tick AFTER making sure the ragdo
One authored wheel. A vehicle carries any number of these — a six-wheel truck, a three-wheel trike, a rover — and each says where it sits, what it does and how its suspension and tyre behave. visualChildIndex names the
The convex hull of a point cloud as outward-wound face polygons (coplanar triangles already merged). Built by Jolt's hull builder inside the Physics image, which is why a module like Destruction asks here instead of link
UE's collision-complexity vocabulary. The default keeps the two channels separate: the authored primitives answer simple queries (a character walking into a crate) and the render triangles answer complex ones (a bullet t
One authored collision volume in the mesh's own unscaled local space. Which dimensions are read depends on Shape: Box uses HalfExtents, Sphere uses Radius, Capsule uses Radius + HalfHeight along its local Y, Convex uses
UE's collision sub-mesh naming convention, and the only way an artist can say "this is collision" from inside the DCC. All four prefixes name the primitive the sub-mesh stands for; reading UCX_ alone meant the box, spher
Whether this mesh gets a clustered GI card set at build time, authored on the asset instead of through the _nocards name suffix. The suffix survives as a fallback, but it is a DCC-side convention: it cannot be set on a
Bounds on an automatic convex decomposition. MaxHulls is the one an artist actually tunes: every hull is a separate Jolt shape inside the compound, so a prop decomposed into forty pieces costs forty narrow-phase tests.
A named transform on the mesh. BoneName is empty for a static mesh; on a skeletal mesh it names the bone the socket rides, and the socket's transform is then relative to that bone's animated pose.
A bone added to the imported skeleton (UE's Virtual Bone): parented to SourceBone and driven onto TargetBone's pose every frame. Applied to the skeleton when the model loads (Skeleton::AddVirtualBone).
A painted cloth mask for one submesh of a skinned model: per vertex, the fraction of the cloth component's Max Distance that vertex may drift from its skinned position (0 = skinned rigidly, 1 = fully free). Indexed like
A material slot's authored binding. Slot is the name the import carried out of the DCC (MmodelMaterialSlot::name / Material::GetName), Material is the .mat the artist chose for it. This is what replaces "find a .mat wh
Turns render geometry into the authored primitives a mesh's collision setup stores. Everything here runs at AUTHOR time (the mesh editor's Generate buttons), never at body creation — the cook path consumes the result.
One authored collision body in a physics asset. It attaches to a named skeleton bone and its shape lives in the bone's local frame (bind pose + LocalPosition/LocalRotation). Dimensions are interpreted per Shape: Capsule
A joint between two bodies. BodyB is the constrained child, BodyA the parent frame. Limits are stored in degrees so the authored numbers match what the editor's details rail shows.
Two bodies that never touch each other, by body name: UE's "disable collision" between a pair of physics bodies. A parent and its child body never collide already, so a pair only matters for bodies further apart.
A serialized per-mesh physics asset (.physasset, MDF). Authored against a skeletal mesh, it names the collision bodies, their shapes and the constraints that wire them into a ragdoll. The RagdollBuilder turns this into
Live per-body solver tuning that RigidBodyComponent authors at creation: gravity scale, velocity caps and whether the body may sleep. Kept apart from PhysicsWorld so gameplay code that owns a body (a scripted actor, a ve
Toggles that drive PhysicsWorld::DrawDebug(). PhysicsSystem::Update mirrors the p.Debug* console variables into this struct once per tick, so the cost of a disabled aspect is one if (!flag) return;. A tool wanting fi
Snapshot of physics-side counts and timing, refreshed once per PhysicsSystem::Update tick. Cheap to read (POD, no atomics) — the UI pulls it directly without locking.
What a constraint was carrying when its break threshold fired. Both the delegate on PhysicsSystem and the bus event carry this, so a listener can bind whichever reaches it: an actor subsystem takes the delegate, a decoup
How this collider blends its friction / restitution against whatever it touches. Applied through ContactSettings in MowoContactListener; when the two colliders disagree the more assertive mode wins.
Physics materials as .physmat assets: a designer authors "Ice" once and every collider that references it gets the same friction, restitution, density, combine modes and surface type. Colliders keep their inline fields
Which motion types a query is allowed to see. DynamicOnly covers everything that can move — kinematic platforms included — because "did I hit the level or something in it" is the question gameplay actually asks.
Which collision shapes a query may see. A mesh or heightfield body is the complex collision of a level; everything built from primitives and hulls is the simple collision gameplay bodies use. Bullets want complex, charac
Whether a query reports the inside face of a triangle or the interior of a convex shape it starts in. Default keeps each query kind's own behaviour: rays and sweeps skip back faces, overlaps do not.
Everything a query filters on, in one place. The legacy entry points took a layer mask and a single ignored body, which is why a scanner could not skip its own carrier plus the prop in its hands, and why "by channel" onl
Many rays, one filter, one setup. A scanner fan pays for filter construction, the narrow-phase lookup and the job dispatch ONCE for the whole sweep instead of once per ray, and the rays fan out across the worker pool. Fi
A collision shape built ahead of its body. Opaque on purpose: the Jolt shape stays inside the Physics image, a consumer only carries the handle from the worker that cooked it to PhysicsWorld::CreateBodyFromShape / Create
The result of a background cook. The worker fills it in and flips Ready; the game thread polls IsReady (or WaitReady) and takes the shape. A cook that failed (a degenerate mesh, an unsupported hull) is Ready with an inva
Builds Jolt shapes on the engine's job system at background priority, so a streaming world's colliders no longer cost the game thread their hull and BVH builds. Inputs are copied, the caller's buffers are free on return.
One body's replicable state. key is whatever the caller replicates the body under (an entity id's low bits, a net id): Jolt body ids are not stable across machines, so the wire never carries one.
Per-body replication state: a bandwidth-lean wire format with delta against a baseline the receiver already holds, and the client-side correction that pulls a predicted body onto the authoritative one. The server replica
Delta of a whole-world snapshot against an earlier one: zero runs of the XOR of the two byte streams stay implicit, so a world where few bodies moved costs little. Lossless; the receiver needs the same baseline.
The last capacity whole-world states, by tick. A tick's snapshot is the world BEFORE that tick is simulated, so restoring tick N and stepping runs tick N again. Capturing a tick drops every snapshot at or after it: a s
Restore tick fromTick, replay up to toTick, recording every recomputed tick back into the ring. applyInputs runs before each step with the tick it belongs to: the place a replay re-applies the forces, impulses and
Physics→render interpolation: the fixed-step sim advances in 1/60 chunks while the frame time is variable, so dynamic bodies would judder at any refresh ≠ 60. Every dynamic body keeps its previous and current physics tra
A body this system owns on behalf of a collider whose entity carries no RigidBody — UE's implicit static: collision enabled, simulation off. The pose and the shape identity are kept so a prop dragged in the editor takes
Free functions
Signature
Description
using CollisionCallback = std::function<void(uint64_t entityId, const CollisionInfo& info)>
A chunk of solid voxels a body collides against without a triangle in sight. The grid is dimsX x dimsY x dimsZ cells of voxelSize metres whose minimum corner sits at origin; the solid set is a bit per cell, x fastest
A primitive body created straight through the world, outside any component (preview floors, tool geometry, tests). extents follows EQueryShape: a sphere reads x as the radius, a box all three as half extents, a capsule
A body built from a shape cooked ahead of time (FPhysicsShapeCooker, on a worker or inline). shape is shared, one cooked shape can back any number of bodies.
One auto-generated ragdoll body. We keep these around per-entity so the RagdollSystem can map back from a ragdoll part → skeleton bone index when reading the simulated pose back into AnimatorComponent::boneMatrices.
Owns the lifecycle of every active physics ragdoll in the World and each frame reads the simulated body transforms back into the owning entity's AnimatorComponent::boneMatrices so the skinned mesh renders the physics-dri
What a surface is made of, as far as gameplay is concerned. This is the one authored answer to "what am I standing on / what did I just hit", shared by footstep audio, impact VFX, decals and the scanner's point colouring