Struct AnimationGraph 

pub struct AnimationGraph {
    pub asset_id: AssetId,
    pub target: Option<SkinnedMeshHandle>,
    pub parameters: Vec<AnimationParam>,
    pub initial: String,
    pub states: Vec<AnimationState>,
    pub transitions: Vec<AnimationTransition>,
    pub ik_chains: Vec<AnimationIkChain>,
}

An animation state machine for one SkinnedMesh.

While a plain set of Animation clips blends every clip all the time, a graph plays exactly one state at a time and moves between states along declared transitions, crossfading poses over each transition’s duration_secs. Transitions fire when their conditions – comparisons against the graph’s named float parameters – pass. Gameplay systems write parameter values each frame (the anim-param debug command does the same from a cn debug session).

A graph owns its target: every Animation targeting the graph’s mesh must be referenced by exactly one state, and at most one graph may target a given mesh (both are build errors otherwise). Clip weight and fade_in_secs have no effect under a graph.

Transitions are checked in declaration order and the first match wins. A state with no outgoing transitions (or none passing) keeps playing; looping states wrap, non-looping states hold their final pose.

AnimationGraph {
    initial: "idle".into(),
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

target: Option<SkinnedMeshHandle>

The SkinnedMesh asset this graph animates.

parameters: Vec<AnimationParam>

Named float parameters transitions compare against.

initial: String

Name of the state the graph starts in. Defaults to the first state.

states: Vec<AnimationState>

The graph’s states. At least one is required.

transitions: Vec<AnimationTransition>

Directed transitions between states.

ik_chains: Vec<AnimationIkChain>

Two-bone IK chains applied on top of every state’s pose; see AnimationIkChain.

Implementations

impl AnimationGraph

pub fn compile( &self, resolve_clip: impl Fn(AssetId) -> Option<(usize, f32, bool)>, ) -> Result<CompiledGraph, String>

Compile the authored graph into the runtime representation, resolving state and parameter names to indices and clip references through resolve_clip, which maps an Animation asset id to its index, duration, and looping flag in the target’s clip list. Structural problems (unknown names, missing clips, non-positive rates) are reported as errors; the build validates the same rules earlier, so a runtime failure here means the world blob and the clip list disagree.

Trait Implementations

impl Clone for AnimationGraph

fn clone(&self) -> AnimationGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for AnimationGraph

const NAME: &'static str = "AnimationGraph"

The registry name a world authors this component under.

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.

fn from_baked(bytes: &[u8]) -> Result<AnimationGraph, 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).

impl ComponentSlot for AnimationGraph

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for AnimationGraph

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

Formats the value using the given formatter.

impl Default for AnimationGraph

fn default() -> AnimationGraph

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AnimationGraph

where AnimationGraph: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<AnimationGraph, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AnimationGraph> for ComponentAsset

fn from(c: AnimationGraph) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for AnimationGraph

impl Serialize for AnimationGraph

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.