Struct CharacterRig 

pub struct CharacterRig {
    pub target: SkinnedMeshHandle,
    pub skinned_index: usize,
    pub base_model: Mat4,
    pub position: [f32; 3],
    pub half_height: f32,
    pub radius: f32,
    pub yaw: f32,
    pub desired_move: [f32; 3],
    pub jump_velocity: f32,
    pub grounded: bool,
    pub moved: bool,
}

Runtime-only link between a skinned mesh and its character capsule.

GraphicsSystem publishes one CharacterRig per SkinnedMesh that declares a capsule, carrying the authored model transform and capsule dimensions. PhysicsSystem creates the kinematic capsule from it, then each frame consumes the target’s RootMotionEvent events, resolves the displacement against the scene, and writes the new position back here; GraphicsSystem moves the rendered mesh to follow. The one-frame producer/consumer hand-offs are invisible at animation rates.

Not authored in world files: it has no args.

Fields

target: SkinnedMeshHandle

The SkinnedMesh resource this rig moves.

skinned_index: usize

Index of the mesh’s skinned draw object in the render backend.

base_model: Mat4

The mesh’s authored model matrix. Root-motion deltas are mapped through its rotation/scale, and the moved mesh keeps its orientation.

position: [f32; 3]

Current mesh-origin position in world space. Seeded to the authored position; overwritten by PhysicsSystem as the capsule moves.

half_height: f32

Capsule half-height (cylindrical section) in world units.

radius: f32

Capsule radius in world units.

yaw: f32

Runtime facing yaw in radians, applied on top of the authored rotation (about world Y). Written by a character controller; 0 keeps the authored facing.

desired_move: [f32; 3]

World-space drive velocity in units per second, added to the root-motion displacement each physics step. Written every frame by a direct-drive character controller; stays zero otherwise.

jump_velocity: f32

One-shot takeoff velocity in units per second. Consumed by PhysicsSystem on the next step: applied if the capsule is grounded, discarded either way.

grounded: bool

Whether the capsule rested on ground after the last move.

moved: bool

Set by PhysicsSystem when position changed and by a controller when yaw changed; cleared by GraphicsSystem once the render transform caught up.

Implementations

impl CharacterRig

pub fn new( target: SkinnedMeshHandle, skinned_index: usize, base_model: Mat4, half_height: f32, radius: f32, ) -> Self

A rig at its authored placement. base_model is the mesh’s model matrix; its translation column doubles as the starting position.

pub fn model(&self) -> Mat4

The current model matrix: the authored rotation/scale, turned by the runtime facing yaw, at the live position.

pub fn world_delta(&self, local: [f32; 3]) -> [f32; 3]

Map a mesh-local displacement into world space through the authored rotation/scale (the linear part of base_model) and the runtime facing yaw.

Trait Implementations

impl Clone for CharacterRig

fn clone(&self) -> CharacterRig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for CharacterRig

const NAME: &'static str = "CharacterRig"

The registry name a world authors this component under.

fn from_baked(_bytes: &[u8]) -> Result<Self, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

fn inject_name(&mut self, _id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

impl ComponentSlot for CharacterRig

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<Self>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<Self>

Mutably borrow this type’s column out of the storage.

impl Debug for CharacterRig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<CharacterRig> for ComponentAsset

fn from(c: CharacterRig) -> Self

Converts to this type from the input type.

impl RuntimeComponent for CharacterRig