Physics

Physics module API reference: 47 headers · 129 types · 1393 symbols.

Generated from physics.json · Nov 4, 2026Version 1.0.0
Build name
MowoEngine.Physics
Source
Engine/Source/Runtime/Physics/Public
Category
Runtime
Contents
47 headers · 129 types · 1393 symbols

Physics/CharacterController.h

KindTypeSummary
classCharacterController

Physics/CharacterLadderSystem.h

KindTypeSummary
classCharacterLadderSystemDetects 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

Physics/CharacterMoveState.h

KindTypeSummary
structFCharacterMoveState

Physics/CharacterMovementSystem.h

KindTypeSummary
classCharacterMovementSystem

Physics/ClothSystem.h

KindTypeSummary
structFClothSkinnedSourceA 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
structFClothSkinPaletteThe 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.
classClothSystemCreates 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

Physics/CollisionChannel.h

KindTypeSummary
enumECollisionChannelThe 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
enumECollisionResponse
enumECollisionPresetNamed response sets a designer picks instead of authoring raw layer bits.
structFCollisionResponseContainerA 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.
classCollisionProfiles

Free functions

SignatureDescription
static constexpr uint32_t kCollisionChannelCount = 9

Physics/CollisionCooking.h

KindTypeSummary
structFCollisionMeshDataTriangle 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.
classFCollisionMeshProviderThe 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
classFCollisionShapeCacheCooked 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

Physics/Components/CharacterControllerComponent.h

KindTypeSummary
structCharacterControllerComponent

Physics/Components/CharacterMovementComponent.h

KindTypeSummary
enumEMovementModeCustom hands the step to the function FCustomMovementModes holds under CharacterMovementComponent::customMode.
structCharacterMovementComponent

Free functions

SignatureDescription
inline Vec3 StepCharacterPlanarVelocity(const Vec3& current, const Vec3& desired, bool grounded, const CharacterMovementComponent& mm, float dt)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.

Physics/Components/ClothComponent.h

KindTypeSummary
enumEClothSourceWhere 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.
structClothComponentCloth 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

Physics/Components/ColliderComponent.h

KindTypeSummary
enumShape
enumECompoundMode
structColliderShape
structColliderComponent

Physics/Components/ConstraintComponent.h

KindTypeSummary
enumConstraintType
enumEConstraintPathRotation
enumEConstraintAxisMotionPer-axis freedom of a 6DOF joint, UE's ELinearConstraintMotion / EAngularConstraintMotion vocabulary.
enumEConstraintMotorModeWhat a motor drives toward on its axis. Position holds an offset / angle; Velocity keeps a rate (a turntable, a conveyor, a wheel).
structConstraintComponent

Physics/Components/ContactModifierComponent.h

KindTypeSummary
structContactModifierComponent

Physics/Components/ForceFieldComponent.h

Physics/Components/LadderVolumeComponent.h

KindTypeSummary
structLadderVolumeComponentA 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

Physics/Components/PhysicalAnimationComponent.h

KindTypeSummary
structFPhysicalAnimationProfileA 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
structFPhysicalAnimationOverrideMotor 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
structPhysicalAnimationComponentBlends 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
structPhysicalAnimationComponent::PendingImpulseQueued 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.

Physics/Components/PhysicsAssetComponent.h

KindTypeSummary
structPhysicsAssetComponentPoints 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

Physics/Components/RagdollComponent.h

KindTypeSummary
enumRagdollModeDrives a character's animated skeleton with a physics ragdoll.
structRagdollBoneOverridePer-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
structRagdollComponent
structRagdollComponent::PendingImpulseQueued 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

Physics/Components/RigidBodyComponent.h

KindTypeSummary
enumBodyType
structRigidBodyComponent

Physics/Components/VehicleComponent.h

KindTypeSummary
structFVehicleWheelSetupOne 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
structFVehicleWheelStateWhat the simulation reports per wheel, in the chassis' local frame.
structVehicleComponent

Physics/ConstraintFrames.h

KindTypeSummary
classFConstraintFrames

Physics/ConvexHull.h

KindTypeSummary
classFConvexHullThe 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

Physics/CustomMovementMode.h

KindTypeSummary
classFCustomMovementModes

Physics/MeshCollision.h

KindTypeSummary
enumEMeshCollisionShape
enumEMeshCollisionComplexityUE'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
structFMeshCollisionPrimitiveOne 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
classFMeshCollisionNamingUE'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
enumEMeshCardSetModeWhether 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
structFMeshDecompositionSettingsBounds 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.
structFMeshSocketA 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.
structFMeshVirtualBoneA 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).
structFMeshClothMaskA 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
structFMeshMaterialSlotBindingA 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
classFMeshAssetMetaEverything authored ON a model that the model file itself cannot hold.

Physics/MeshCollisionBuild.h

KindTypeSummary
classFMeshCollisionGeneratorTurns 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.

Physics/PhysicalAnimationSystem.h

KindTypeSummary
classPhysicalAnimationSystemDrives a bone chain with motor-powered physics blended onto the animated pose, so hit reactions knock a limb off the animation and then recover.

Physics/PhysicsAsset.h

KindTypeSummary
enumEPhysicsBodyShape
enumEPhysicsConstraintType
structFPhysicsBodyDefOne 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
structFPhysicsConstraintDefA 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.
structFPhysicsCollisionPairTwo 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.
classFPhysicsAssetA 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

Physics/PhysicsBodyTuning.h

KindTypeSummary
classFPhysicsBodyTuningLive 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

Physics/PhysicsDebug.h

KindTypeSummary
structPhysicsDebugSettingsToggles 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
structPhysicsStatsSnapshot 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.

Physics/PhysicsEvents.h

KindTypeSummary
structFConstraintBreakInfoWhat 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
classConstraintBrokenEventExported so every module resolves the same type id — an unexported event struct gets one per DLL and a subscriber in Game never hears Physics.

Physics/PhysicsForceFields.h

Physics/PhysicsHandles.h

KindTypeSummary
classFPhysicsBodyId
classFPhysicsSubShapeIdNames the exact triangle, heightfield square or compound leaf a query struck. Empty (all bits set) means the body as a whole.
enumEPhysicsMotionTypeSame order as Jolt's EMotionType (static_asserted inside Physics).
classFPhysicsConstraintHandleA constraint Physics created on a caller's behalf. Opaque: the caller hands it back to PhysicsWorld to drive, measure or remove the joint.
structhash

Free functions

SignatureDescription
template<typename T> concept CPhysicsBodyIdBits = !std::is_same_v<std::remove_cvref_t<T>, FPhysicsBodyId> && requires(const T& id)
template<typename T> concept CPhysicsSubShapeIdBits = !std::is_same_v<std::remove_cvref_t<T>, FPhysicsSubShapeId> && std::is_default_constructible_v<T> && requires(const T& id, T& mutableId, uint32_t value)

Physics/PhysicsLayers.h

KindTypeSummary
classCollisionMatrixConfigurable collision matrix — determines which layer pairs can collide

Free functions

SignatureDescription
static constexpr uint16_t Static = 0Legacy constants for backward compatibility. uint16_t is the width of Jolt's object layer (static_asserted inside Physics).
static constexpr uint16_t Dynamic = 1
static constexpr uint16_t Player = 2
static constexpr uint16_t Trigger = 3
static constexpr uint32_t MaxLayers = 16

Physics/PhysicsMaterial.h

KindTypeSummary
structPhysicsMaterial
enumPhysicsMaterial::CombineModeHow 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/PhysicsMaterialAsset.h

KindTypeSummary
classFPhysicsMaterialAssetPhysics 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

Physics/PhysicsMath.h

KindTypeSummary
classFPhysicsMath

Physics/PhysicsQuery.h

KindTypeSummary
enumEQueryMobilityWhich 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.
enumEQueryComplexityWhich 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
enumEQueryBackFacesWhether 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.
enumEQueryShapeThe swept / overlapped volume. Primitives only: the shape is built per call, so a mesh here would cook a triangle soup on every trace.
structFQueryFilterEverything 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
structFQueryHit
structFTraceBatchItem
classFTraceBatchMany 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

Physics/PhysicsShapeCook.h

KindTypeSummary
classFPhysicsPreparedShapeA 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
structFPhysicsCompoundPartOne primitive of a compound shape.
classFPhysicsShapeCookTicketThe 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
structFPhysicsShapeCookTicket::FState
classFPhysicsShapeCookerBuilds 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.

Physics/PhysicsSnapshot.h

KindTypeSummary
structFPhysicsBodyStateOne 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.
structFPhysicsBodyBinding
structFPhysicsReconcileSettings
classFPhysicsBodyReplicationPer-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
classFPhysicsSnapshotCodecDelta 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.
classFPhysicsSnapshotRingThe 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
structFPhysicsResimResult
classFPhysicsResimulatorRestore 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/PhysicsSystem.h

KindTypeSummary
structCollisionInfo
classPhysicsSystem
structPhysicsSystem::FBodyInterpPhysics→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
structPhysicsSystem::FImplicitStaticBodyA 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

SignatureDescription
using CollisionCallback = std::function<void(uint64_t entityId, const CollisionInfo& info)>

Physics/PhysicsVoxel.h

KindTypeSummary
structFVoxelColliderDescA 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

Physics/PhysicsWorld.h

KindTypeSummary
structPhysicsConfig
structRaycastHit
structFPhysicsBodyDescA 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
structFPhysicsShapeBodyDescA 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.
classPhysicsWorld

Physics/RagdollBuilder.h

KindTypeSummary
structRagdollBodyMappingOne 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.
classRagdollBuilder

Physics/RagdollSystem.h

KindTypeSummary
classRagdollSystemOwns 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

Physics/RootMotionSource.h

Physics/SurfaceType.h

KindTypeSummary
enumESurfaceTypeWhat 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
classFSurfaceType

Physics/VehicleSystem.h

KindTypeSummary
classVehicleSystem

Page feedback

Was this page helpful?