Struct AnimationSystem 

pub struct AnimationSystem { /* private fields */ }

Skeletal animation playback behavior. Constructed internally by World::start when the world declares any Animation or AnimationGraph; never a world-declared asset, so it carries no config.

Implementations

impl AnimationSystem

pub fn apply_runtime_commands(&mut self)

Drain pending runtime commands against the system’s own clock. Uses the same start / elapsed bookkeeping step uses, so the binary-only DebugHook::tick drive can apply commands from outside the per-system step. The library never calls this; step runs after the hook on the same frame, so the start anchor set here is shared.

impl AnimationSystem

pub fn new() -> Self

Fresh playback state with no clips. Clips and graphs are drained from the world’s components in System::init.

pub fn reload_entries(&self) -> &[AnimationReloadEntry]

The file-backed clips captured at init under cn debug. The editor crate’s hot-reload drive reads these to re-import each clip from source. Empty when hot-reload is off or every clip is inline.

pub fn apply_reloaded_clip( &mut self, target: SkinnedMeshHandle, clip_index: usize, clip: AnimationClip, weight: f32, ) -> bool

Swap a freshly re-imported clip into the bucket slot identified by target + clip_index, restoring its declared weight. Returns false if the target bucket disappeared or the slot index is out of range (a half-applied reload is impossible: nothing is mutated on miss). The editor crate calls this after decoding the source GLB; the runtime crate does no decoding of its own.

Trait Implementations

impl Debug for AnimationSystem

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

Formats the value using the given formatter.

impl Default for AnimationSystem

fn default() -> Self

Returns the “default value” for a type.

impl System for AnimationSystem

fn access(&self) -> Access

The data step may touch, consulted once when the schedule is built (after init, so a data-dependent system can compute it from its compiled state). The default claims everything: an undeclared system is ordered against all others and never runs concurrently, which is always safe. Declaring narrower access is what admits a system to shared waves and to debug-build access validation.

fn init(&mut self, ctx: &mut PipelineContext<'_>)

Run once at World::start, before the first step.

fn step(&mut self, ctx: &mut PipelineContext<'_>) -> StepResult

Run once per tick.