Module `graph`

Code-authored skeletal animation state machines and asynchronous clip pooling.

Build an AnimationGraph with AnimationGraphBuilder, then create an AnimationGraphPlayer for each animated skeleton. The player evaluates synchronously from retained pose buffers while AnimationPool loads clip resources on an application-owned async worker. Client code selects one durable AnimationStateId with normal Rust control flow, then the player reconciles its current playback toward that requested state. Connect state handles with AnimationGraphState::to, then use AnimationGraphTransitionConditionBuilder::when or AnimationGraphTransitionConditionBuilder::anytime to choose whether a one-shot transition clip can be interrupted.

Connection order

During application setup, build the immutable graph and create one AnimationPool with the application's ResourceManager.
Spawn the AnimationLoadWorker returned by AnimationPool::new on the same async runtime that serves resource requests. The pool only enqueues work, so clips remain in Loading until this worker runs.
Create one AnimationGraphPlayer per animated instance with AnimationPool::create_player. The pool loads the initial clip, whose skeleton becomes the canonical target for every graph clip. As the player enters each state, it also requests clips in directly reachable states.
Each application tick, call AnimationPool::update once, select an authored AnimationStateId, call AnimationGraphPlayer::advance, apply its root motion to the owning object, and send AnimationGraphPose::global_pose to rendering.

The graph player owns its evaluation buffers. The renderer's UpdatePose message owns its matrix vector, so copying at that cross-system boundary is currently intentional. See crates/byte-engine/examples/animation_graph.rs for the complete headed application sequence.

Quick Reference

Item	Kind	Description
`AnimationStateId`	struct	The `AnimationStateId` struct identifies one client-requestable state inside its originating [`AnimationGraph`].
`AnimationLease`	struct	The `AnimationLease` struct keeps a stable clip identity across arena residency and eviction.
`AnimationClip`	struct	The `AnimationClip` struct identifies the leased resource and playback behavior used by one state.
`AnimationTransition`	struct	The `AnimationTransition` struct configures how the player blends toward a requested state.
`AnimationGraph`	struct	The `AnimationGraph` struct stores immutable routes used to reconcile requested animation states.
`AnimationGraphBuilder`	struct	The `AnimationGraphBuilder` struct assembles named clip states and their ordered reconciliation routes.
`AnimationGraphStateBuilder`	struct	The `AnimationGraphStateBuilder` struct assigns a clip to a named graph state.
`AnimationGraphState`	struct	The `AnimationGraphState` struct connects a state to other states during graph authoring.
`AnimationGraphTransitionBuilder`	struct	The `AnimationGraphTransitionBuilder` struct assigns a clip to a route between two states.
`AnimationGraphTransitionConditionBuilder`	struct	The `AnimationGraphTransitionConditionBuilder` struct holds unfinished one-shot route authoring so callers can choose its interruption policy.
`AnimationGraphPlayer`	struct
`AnimationGraphPose`	struct
`AnimationLoadWorker`	struct
`AnimationPool`	struct
`AnimationPoolConfig`	struct
`RootMotionSettings`	struct
`RootMotionTranslation`	struct
`AnimationPlayback`	enum	The `AnimationPlayback` enum selects whether a state clip repeats or stops at its final pose.
`AnimationGraphBuildError`	enum	The `AnimationGraphBuildError` enum reports invalid graph authoring input.
`AnimationEvaluation`	enum
`AnimationGraphPlayerError`	enum
`AnimationPoolEvent`	enum
`AnimationPoolRequest`	enum
`RootMotionRotation`	enum
`ANIMATION_LOAD_QUEUE_CAPACITY`	const	Bounds asynchronous animation load requests independently from the clip byte budget.
`ANIMATION_POOL_EVENT_CAPACITY`	const	Bounds retained load outcomes so diagnostics cannot outgrow the clip pool.

Structs

`AnimationStateId`

struct AnimationStateId {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:44-47

The AnimationStateId struct identifies one client-requestable state inside its originating AnimationGraph.

Trait Implementations

`impl ArchivePointee for AnimationStateId`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationStateId`

`impl Clone for AnimationStateId`

```
fn clone(&self) -> AnimationStateId
```
Related: AnimationStateId

`impl Copy for AnimationStateId`

`impl Debug for AnimationStateId`

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

`impl Downcast for AnimationStateId`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationStateId`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationStateId`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationStateId`

`impl<K> Equivalent for AnimationStateId`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Hash for AnimationStateId`

fn hash<__H: hash::Hasher>(&self, state: &mut __H)

`impl Instrument for AnimationStateId`

`impl LayoutRaw for AnimationStateId`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationStateId`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationStateId`

fn eq(&self, other: &AnimationStateId) -> bool

Related: AnimationStateId

`impl Pointable for AnimationStateId`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationStateId`

```
type Metadata = ()
```

`impl Read for AnimationStateId`

`impl StructuralPartialEq for AnimationStateId`

`impl WithSubscriber for AnimationStateId`

`AnimationLease`

struct AnimationLease {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:60-62

The AnimationLease struct keeps a stable clip identity across arena residency and eviction.

Implementations

```
fn new(resource_id: impl Into<Arc<str>>) -> Self
```
Creates a lease handle for a clip that the pool may load, evict, and load again.
```
fn resource_id(&self) -> &str
```
Returns the resource ID used when an evicted lease needs another asynchronous load.

Trait Implementations

`impl ArchivePointee for AnimationLease`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationLease`

`impl Clone for AnimationLease`

```
fn clone(&self) -> AnimationLease
```
Related: AnimationLease

`impl Debug for AnimationLease`

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

`impl Downcast for AnimationLease`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationLease`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationLease`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationLease`

`impl<K> Equivalent for AnimationLease`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Hash for AnimationLease`

fn hash<__H: hash::Hasher>(&self, state: &mut __H)

`impl Instrument for AnimationLease`

`impl LayoutRaw for AnimationLease`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationLease`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationLease`

fn eq(&self, other: &AnimationLease) -> bool

Related: AnimationLease

`impl Pointable for AnimationLease`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationLease`

```
type Metadata = ()
```

`impl Read for AnimationLease`

`impl StructuralPartialEq for AnimationLease`

`impl WithSubscriber for AnimationLease`

`AnimationClip`

struct AnimationClip {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:80-83

The AnimationClip struct identifies the leased resource and playback behavior used by one state.

Implementations

```
fn looping(resource_id: impl Into<Arc<str>>) -> Self
```
Creates a clip that restarts from its first sample after reaching its duration.
```
fn once(resource_id: impl Into<Arc<str>>) -> Self
```
Creates a clip that holds its final sample after reaching its duration.
```
fn resource_id(&self) -> &str
```
Returns the resource ID requested by an AnimationPool.
```
const fn playback(&self) -> AnimationPlayback
```
Related: AnimationPlayback

Returns the playback behavior used after the clip reaches its duration.

Trait Implementations

`impl ArchivePointee for AnimationClip`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationClip`

`impl Clone for AnimationClip`

```
fn clone(&self) -> AnimationClip
```
Related: AnimationClip

`impl Debug for AnimationClip`

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

`impl Downcast for AnimationClip`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationClip`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationClip`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationClip`

`impl<K> Equivalent for AnimationClip`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationClip`

`impl LayoutRaw for AnimationClip`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationClip`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationClip`

fn eq(&self, other: &AnimationClip) -> bool

Related: AnimationClip

`impl Pointable for AnimationClip`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationClip`

```
type Metadata = ()
```

`impl Read for AnimationClip`

`impl StructuralPartialEq for AnimationClip`

`impl WithSubscriber for AnimationClip`

`AnimationTransition`

struct AnimationTransition {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:115-117

The AnimationTransition struct configures how the player blends toward a requested state.

Implementations

```
const fn new() -> Self
```
Creates an immediate transition toward a requested state.
```
const fn inertialize(self, duration: MediaTime) -> Self
```
Related: MediaTime

Smooths the transition with critically damped inertialization for the supplied duration.

Trait Implementations

`impl ArchivePointee for AnimationTransition`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationTransition`

`impl Clone for AnimationTransition`

```
fn clone(&self) -> AnimationTransition
```
Related: AnimationTransition

`impl Copy for AnimationTransition`

`impl Debug for AnimationTransition`

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

`impl Default for AnimationTransition`

```
fn default() -> Self
```

`impl Downcast for AnimationTransition`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationTransition`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationTransition`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationTransition`

`impl<K> Equivalent for AnimationTransition`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationTransition`

`impl LayoutRaw for AnimationTransition`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationTransition`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationTransition`

fn eq(&self, other: &AnimationTransition) -> bool

Related: AnimationTransition

`impl Pointable for AnimationTransition`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationTransition`

```
type Metadata = ()
```

`impl Read for AnimationTransition`

`impl<R> ReadPrimitive for AnimationTransition`

`impl StructuralPartialEq for AnimationTransition`

`impl WithSubscriber for AnimationTransition`

`AnimationGraph`

struct AnimationGraph {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:194-198

The AnimationGraph struct stores immutable routes used to reconcile requested animation states.

Build the graph once with AnimationGraphBuilder, then share it between any number of AnimationGraphPlayer instances. Client code selects one of the graph's durable AnimationStateId values before each evaluation.

Implementations

```
fn builder() -> AnimationGraphBuilder
```
Related: AnimationGraphBuilder

Starts a builder for an animation reconciliation graph.
```
const fn initial_state(&self) -> AnimationStateId
```
Related: AnimationStateId

Returns the graph's initial state.
```
fn state_count(&self) -> usize
```
Returns the number of authored states.

Trait Implementations

`impl ArchivePointee for AnimationGraph`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraph`

`impl Downcast for AnimationGraph`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraph`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationGraph`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Instrument for AnimationGraph`

`impl LayoutRaw for AnimationGraph`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraph`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraph`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraph`

```
type Metadata = ()
```

`impl Read for AnimationGraph`

`impl WithSubscriber for AnimationGraph`

`AnimationGraphBuilder`

struct AnimationGraphBuilder {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:269-272

The AnimationGraphBuilder struct assembles named clip states and their ordered reconciliation routes.

Implementations

```
fn new() -> Self
```
Creates an empty animation graph builder.
```
fn state(&self, name: impl Into<String>) -> AnimationGraphStateBuilder<'_>
```
Related: AnimationGraphStateBuilder

Names a state. Call AnimationGraphStateBuilder::with next to assign its clip.
```
fn build(&self, initial: AnimationGraphState<'_>) -> Result<AnimationGraph, AnimationGraphBuildError>
```
Related: AnimationGraphState, AnimationGraph, AnimationGraphBuildError

Validates the graph and selects the initial state.

Trait Implementations

`impl ArchivePointee for AnimationGraphBuilder`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphBuilder`

`impl Default for AnimationGraphBuilder`

```
fn default() -> Self
```

`impl Downcast for AnimationGraphBuilder`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraphBuilder`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl Instrument for AnimationGraphBuilder`

`impl LayoutRaw for AnimationGraphBuilder`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphBuilder`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphBuilder`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphBuilder`

```
type Metadata = ()
```

`impl Read for AnimationGraphBuilder`

`impl<R> ReadPrimitive for AnimationGraphBuilder`

`impl WithSubscriber for AnimationGraphBuilder`

`AnimationGraphStateBuilder<'builder>`

struct AnimationGraphStateBuilder<'builder> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:280-284

The AnimationGraphStateBuilder struct assigns a clip to a named graph state.

Implementations

```
fn with(self, clip: AnimationClip) -> AnimationGraphState<'builder>
```
Related: AnimationClip, AnimationGraphState

Assigns the clip played while this state is active.

Trait Implementations

`impl ArchivePointee for AnimationGraphStateBuilder<'builder>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphStateBuilder<'builder>`

`impl Downcast for AnimationGraphStateBuilder<'builder>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl Instrument for AnimationGraphStateBuilder<'builder>`

`impl LayoutRaw for AnimationGraphStateBuilder<'builder>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphStateBuilder<'builder>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphStateBuilder<'builder>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphStateBuilder<'builder>`

```
type Metadata = ()
```

`impl Read for AnimationGraphStateBuilder<'builder>`

`impl WithSubscriber for AnimationGraphStateBuilder<'builder>`

`AnimationGraphState<'builder>`

struct AnimationGraphState<'builder> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:287-290

The AnimationGraphState struct connects a state to other states during graph authoring.

Implementations

```
const fn id(self) -> AnimationStateId
```
Related: AnimationStateId

Returns the durable state ID that client code can request after the graph is built.
```
fn to(self, target: Self) -> AnimationGraphTransitionBuilder<'builder>
```
Related: AnimationGraphTransitionBuilder

Starts an authored route that reconciles toward target.

Trait Implementations

`impl ArchivePointee for AnimationGraphState<'builder>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphState<'builder>`

`impl Clone for AnimationGraphState<'_>`

```
fn clone(&self) -> Self
```

`impl Copy for AnimationGraphState<'_>`

`impl Downcast for AnimationGraphState<'builder>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl Instrument for AnimationGraphState<'builder>`

`impl LayoutRaw for AnimationGraphState<'builder>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphState<'builder>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphState<'builder>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphState<'builder>`

```
type Metadata = ()
```

`impl Read for AnimationGraphState<'builder>`

`impl WithSubscriber for AnimationGraphState<'builder>`

`AnimationGraphTransitionBuilder<'builder>`

struct AnimationGraphTransitionBuilder<'builder> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:301-304

The AnimationGraphTransitionBuilder struct assigns a clip to a route between two states.

Implementations

```
fn when(self, transition: AnimationTransition) -> AnimationGraphState<'builder>
```
Related: AnimationTransition, AnimationGraphState

Adds a direct route without playing an intermediate clip.
```
fn with(self, clip: AnimationClip) -> AnimationGraphTransitionConditionBuilder<'builder>
```
Related: AnimationClip, AnimationGraphTransitionConditionBuilder

Assigns the one-shot clip played between the source and target states.

Trait Implementations

`impl ArchivePointee for AnimationGraphTransitionBuilder<'builder>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphTransitionBuilder<'builder>`

`impl Downcast for AnimationGraphTransitionBuilder<'builder>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl Instrument for AnimationGraphTransitionBuilder<'builder>`

`impl LayoutRaw for AnimationGraphTransitionBuilder<'builder>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphTransitionBuilder<'builder>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphTransitionBuilder<'builder>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphTransitionBuilder<'builder>`

```
type Metadata = ()
```

`impl Read for AnimationGraphTransitionBuilder<'builder>`

`impl WithSubscriber for AnimationGraphTransitionBuilder<'builder>`

`AnimationGraphTransitionConditionBuilder<'builder>`

struct AnimationGraphTransitionConditionBuilder<'builder> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph.rs:307-311

The AnimationGraphTransitionConditionBuilder struct holds unfinished one-shot route authoring so callers can choose its interruption policy.

Implementations

```
fn when(self, transition: AnimationTransition) -> AnimationGraphState<'builder>
```
Related: AnimationTransition, AnimationGraphState

Adds a one-shot route that must complete before reconciling another request.
```
fn anytime(self, transition: AnimationTransition) -> AnimationGraphState<'builder>
```
Related: AnimationTransition, AnimationGraphState

Adds a one-shot route that can reconcile another request before it completes.

Trait Implementations

`impl ArchivePointee for AnimationGraphTransitionConditionBuilder<'builder>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphTransitionConditionBuilder<'builder>`

`impl Downcast for AnimationGraphTransitionConditionBuilder<'builder>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl Instrument for AnimationGraphTransitionConditionBuilder<'builder>`

`impl LayoutRaw for AnimationGraphTransitionConditionBuilder<'builder>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphTransitionConditionBuilder<'builder>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphTransitionConditionBuilder<'builder>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphTransitionConditionBuilder<'builder>`

```
type Metadata = ()
```

`impl Read for AnimationGraphTransitionConditionBuilder<'builder>`

`impl WithSubscriber for AnimationGraphTransitionConditionBuilder<'builder>`

`AnimationGraphPlayer<'graph>`

struct AnimationGraphPlayer<'graph> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:203-207

The AnimationGraphPlayer struct retains local playback while the pool resolves all graph data asynchronously.

Create players with AnimationPool::create_player. Call AnimationPool::update once per tick, then call Self::advance with the client-selected state. The initial clip supplies the canonical skeleton used by every graph clip.

Implementations

```
fn state(&self) -> Option<AnimationStateId>
```
Related: AnimationStateId

Returns the currently playing destination state after the initial clip has loaded.
```
fn advance(&mut self, delta: MediaTime, requested: AnimationStateId, pool: &mut AnimationPool) -> Result<AnimationEvaluation<'_>, AnimationGraphPlayerError>
```
Related: MediaTime, AnimationStateId, AnimationPool, AnimationEvaluation, AnimationGraphPlayerError

Initializes from the initial clip when ready, then evaluates locally toward requested.

Trait Implementations

`impl ArchivePointee for AnimationGraphPlayer<'graph>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphPlayer<'graph>`

`impl Downcast for AnimationGraphPlayer<'graph>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraphPlayer<'graph>`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationGraphPlayer<'graph>`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Instrument for AnimationGraphPlayer<'graph>`

`impl LayoutRaw for AnimationGraphPlayer<'graph>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphPlayer<'graph>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphPlayer<'graph>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphPlayer<'graph>`

```
type Metadata = ()
```

`impl Read for AnimationGraphPlayer<'graph>`

`impl WithSubscriber for AnimationGraphPlayer<'graph>`

`AnimationGraphPose<'a>`

struct AnimationGraphPose<'a> {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:161-166

The AnimationGraphPose struct borrows the latest player pose and frame root motion.

Implementations

```
fn skeleton(&self) -> &'a Skeleton
```
Returns the canonical skeleton that defines the pose's node and matrix order.
```
fn local_pose(&self) -> &'a [LocalTransform]
```
Returns blendable local transforms with extracted root motion removed when configured.
```
fn global_pose(&self) -> &'a [Matrix]
```
Returns renderer-facing global skeleton matrices.
```
const fn root_motion(&self) -> RootMotionDelta
```
Related: RootMotionDelta

Returns this frame's root translation and rotation delta.

Trait Implementations

`impl ArchivePointee for AnimationGraphPose<'a>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphPose<'a>`

`impl Downcast for AnimationGraphPose<'a>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraphPose<'a>`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationGraphPose<'a>`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Instrument for AnimationGraphPose<'a>`

`impl LayoutRaw for AnimationGraphPose<'a>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphPose<'a>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationGraphPose<'a>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphPose<'a>`

```
type Metadata = ()
```

`impl Read for AnimationGraphPose<'a>`

`impl WithSubscriber for AnimationGraphPose<'a>`

`AnimationLoadWorker`

struct AnimationLoadWorker {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph/runtime.rs:477-481

The AnimationLoadWorker struct resolves animation resources away from synchronous pose evaluation.

Implementations

```
async fn run(self)
```
Loads queued clips until the animation pool drops its command channel.

Trait Implementations

`impl ArchivePointee for AnimationLoadWorker`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationLoadWorker`

`impl Downcast for AnimationLoadWorker`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationLoadWorker`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationLoadWorker`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Instrument for AnimationLoadWorker`

`impl LayoutRaw for AnimationLoadWorker`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationLoadWorker`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationLoadWorker`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationLoadWorker`

```
type Metadata = ()
```

`impl Read for AnimationLoadWorker`

`impl WithSubscriber for AnimationLoadWorker`

`AnimationPool`

struct AnimationPool {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph/runtime.rs:136-148

The AnimationPool struct owns a preallocated word arena and byte-bounded LRU clip cache.

Graph clips keep stable AnimationLease handles across eviction. During evaluation, the player pins resident arena regions so admission cannot reuse their words until sampling completes.

Implementations

```
fn create_player<'graph>(&mut self, graph: &'graph AnimationGraph, root_motion: Option<RootMotionSettings<'_>>) -> AnimationGraphPlayer<'graph>
```
Related: AnimationGraph, RootMotionSettings, AnimationGraphPlayer

Creates a local player and queues the initial clip that supplies its canonical skeleton.

Continue calling Self::update once per tick, then pass this pool to

AnimationGraphPlayer::advance so requested clips can load through the

same asynchronous worker.

Trait Implementations

`impl ArchivePointee for AnimationPool`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationPool`

`impl Downcast for AnimationPool`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationPool`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl Instrument for AnimationPool`

`impl LayoutRaw for AnimationPool`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationPool`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationPool`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationPool`

```
type Metadata = ()
```

`impl Read for AnimationPool`

`impl WithSubscriber for AnimationPool`

`AnimationPoolConfig`

struct AnimationPoolConfig {
    // [REDACTED: Private Fields]
}

Defined in crates/byte-engine/src/animation/graph/runtime.rs:7-9

The AnimationPoolConfig struct sets the decoded clip memory available to an AnimationPool.

Implementations

```
const fn new(byte_budget: NonZeroUsize) -> Self
```
Creates a strict byte budget for decoded animation resources.
```
const fn byte_budget(self) -> usize
```
Returns the maximum estimated decoded bytes retained by the pool cache.

Trait Implementations

`impl ArchivePointee for AnimationPoolConfig`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationPoolConfig`

`impl Clone for AnimationPoolConfig`

```
fn clone(&self) -> AnimationPoolConfig
```
Related: AnimationPoolConfig

`impl Copy for AnimationPoolConfig`

`impl Debug for AnimationPoolConfig`

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

`impl Downcast for AnimationPoolConfig`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationPoolConfig`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationPoolConfig`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationPoolConfig`

`impl<K> Equivalent for AnimationPoolConfig`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationPoolConfig`

`impl LayoutRaw for AnimationPoolConfig`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationPoolConfig`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationPoolConfig`

fn eq(&self, other: &AnimationPoolConfig) -> bool

Related: AnimationPoolConfig

`impl Pointable for AnimationPoolConfig`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationPoolConfig`

```
type Metadata = ()
```

`impl Read for AnimationPoolConfig`

`impl StructuralPartialEq for AnimationPoolConfig`

`impl WithSubscriber for AnimationPoolConfig`

`RootMotionSettings<'a>`

struct RootMotionSettings<'a> {
    pub node_name: &'a str,
    pub translation: RootMotionTranslation,
    pub rotation: RootMotionRotation,
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:115-122

The RootMotionSettings struct defines which motion a canonical-skeleton node contributes to its owning object.

Fields

node_name: &'a str

Names the unique node that contains the authored motion.
translation: RootMotionTranslation

Selects node-local translation axes to extract.
rotation: RootMotionRotation

Selects whether to extract node-local rotation.

Implementations

```
const fn full(node_name: &'a str) -> Self
```
Selects all translation and rotation from a dedicated authored root node.

Trait Implementations

`impl ArchivePointee for RootMotionSettings<'a>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for RootMotionSettings<'a>`

`impl Clone for RootMotionSettings<'a>`

fn clone(&self) -> RootMotionSettings<'a>

Related: RootMotionSettings

`impl Copy for RootMotionSettings<'a>`

`impl Debug for RootMotionSettings<'a>`

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

`impl Downcast for RootMotionSettings<'a>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for RootMotionSettings<'a>`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for RootMotionSettings<'a>`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for RootMotionSettings<'a>`

`impl<K> Equivalent for RootMotionSettings<'a>`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for RootMotionSettings<'a>`

`impl LayoutRaw for RootMotionSettings<'a>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for RootMotionSettings<'a>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for RootMotionSettings<'a>`

fn eq(&self, other: &RootMotionSettings<'a>) -> bool

Related: RootMotionSettings

`impl Pointable for RootMotionSettings<'a>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for RootMotionSettings<'a>`

```
type Metadata = ()
```

struct RootMotionTranslation();

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:80

The RootMotionTranslation struct selects node-local translation axes for root motion.

Implementations

```
const NONE: Self
```
```
const X: Self
```
```
const Y: Self
```
```
const Z: Self
```
```
const XYZ: Self
```
```
const fn union(self, other: Self) -> Self
```
Combines translation axes for clips that move along more than one local axis.

Trait Implementations

`impl ArchivePointee for RootMotionTranslation`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for RootMotionTranslation`

`impl Clone for RootMotionTranslation`

fn clone(&self) -> RootMotionTranslation

Related: RootMotionTranslation

`impl Copy for RootMotionTranslation`

`impl Debug for RootMotionTranslation`

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

`impl Downcast for RootMotionTranslation`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for RootMotionTranslation`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for RootMotionTranslation`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for RootMotionTranslation`

`impl<K> Equivalent for RootMotionTranslation`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for RootMotionTranslation`

`impl LayoutRaw for RootMotionTranslation`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for RootMotionTranslation`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for RootMotionTranslation`

fn eq(&self, other: &RootMotionTranslation) -> bool

Related: RootMotionTranslation

`impl Pointable for RootMotionTranslation`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for RootMotionTranslation`

```
type Metadata = ()
```

enum AnimationPlayback {
    Loop,
    Once,
}

Defined in crates/byte-engine/src/animation/graph.rs:51-56

The AnimationPlayback enum selects whether a state clip repeats or stops at its final pose.

Variants

Loop

Restarts the clip from its first sample after it reaches its duration.
Once

Holds the clip's final sample after it reaches its duration.

Trait Implementations

`impl ArchivePointee for AnimationPlayback`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationPlayback`

`impl Clone for AnimationPlayback`

```
fn clone(&self) -> AnimationPlayback
```
Related: AnimationPlayback

`impl Copy for AnimationPlayback`

`impl Debug for AnimationPlayback`

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

`impl Downcast for AnimationPlayback`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationPlayback`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationPlayback`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationPlayback`

`impl<K> Equivalent for AnimationPlayback`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationPlayback`

`impl LayoutRaw for AnimationPlayback`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationPlayback`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationPlayback`

fn eq(&self, other: &AnimationPlayback) -> bool

Related: AnimationPlayback

`impl Pointable for AnimationPlayback`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationPlayback`

```
type Metadata = ()
```

enum AnimationGraphBuildError {
    InitialStateOutOfRange {
        state: usize,
        state_count: usize,
    },
    EmptyStateName {
        state: usize,
    },
    EmptyResourceId {
        state: usize,
    },
    DuplicateStateName {
        name: String,
    },
    TransitionSourceOutOfRange {
        state: usize,
        state_count: usize,
    },
    TransitionTargetOutOfRange {
        state: usize,
        state_count: usize,
    },
    TransitionStateMustPlayOnce {
        state: usize,
    },
    TransitionStateCompletionOutOfRange {
        state: usize,
        completion: usize,
        state_count: usize,
    },
    NegativeTransitionDuration,
}

Defined in crates/byte-engine/src/animation/graph.rs:544-597

The AnimationGraphBuildError enum reports invalid graph authoring input.

Variants

InitialStateOutOfRange

The selected initial state is outside the graph being built.
EmptyStateName

A state cannot be identified because its name is empty.
EmptyResourceId

A state cannot load its clip because its resource ID is empty.
DuplicateStateName

A state name cannot identify one state because another state uses it.
TransitionSourceOutOfRange

A transition cannot start because its source is outside the graph.
TransitionTargetOutOfRange

A transition cannot complete because its target is outside the graph.
TransitionStateMustPlayOnce

A transition state cannot complete because its clip uses looping playback.
TransitionStateCompletionOutOfRange

A transition state cannot complete because its completion state is outside the graph.
NegativeTransitionDuration

A transition cannot be built with a duration before MediaTime::ZERO.

Trait Implementations

`impl ArchivePointee for AnimationGraphBuildError`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphBuildError`

`impl Clone for AnimationGraphBuildError`

fn clone(&self) -> AnimationGraphBuildError

Related: AnimationGraphBuildError

`impl Debug for AnimationGraphBuildError`

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

`impl Display for AnimationGraphBuildError`

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

`impl Downcast for AnimationGraphBuildError`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraphBuildError`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationGraphBuildError`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationGraphBuildError`

`impl<K> Equivalent for AnimationGraphBuildError`

```
fn equivalent(&self, key: &K) -> bool
```

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphBuildError`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationGraphBuildError`

fn eq(&self, other: &AnimationGraphBuildError) -> bool

Related: AnimationGraphBuildError

`impl Pointable for AnimationGraphBuildError`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphBuildError`

```
type Metadata = ()
```

```
fn to_string(&self) -> String
```

`impl WithSubscriber for AnimationGraphBuildError`

`AnimationEvaluation<'a>`

enum AnimationEvaluation<'a> {
    Waiting,
    Ready(AnimationGraphPose<'a>),
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:191-196

The AnimationEvaluation enum reports whether the initial clip has supplied a canonical skeleton and pose.

Variants

Waiting

Keep the renderable's existing pose while the initial clip loads asynchronously.
Ready

Apply root motion and submit the evaluated pose during the current tick.

Trait Implementations

`impl ArchivePointee for AnimationEvaluation<'a>`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationEvaluation<'a>`

`impl Downcast for AnimationEvaluation<'a>`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationEvaluation<'a>`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationEvaluation<'a>`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Instrument for AnimationEvaluation<'a>`

`impl LayoutRaw for AnimationEvaluation<'a>`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationEvaluation<'a>`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl Pointable for AnimationEvaluation<'a>`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationEvaluation<'a>`

```
type Metadata = ()
```

enum AnimationGraphPlayerError {
    RootMotionNodeNotFound {
        name: String,
    },
    DuplicateRootMotionNodeName {
        name: String,
    },
    StateFromDifferentGraph,
    NegativeDelta,
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:617-632

The AnimationGraphPlayerError enum reports invalid player inputs.

Variants

RootMotionNodeNotFound

Choose a root-motion node that exists in the canonical skeleton.
DuplicateRootMotionNodeName

Choose a root-motion node name that is unique in the canonical skeleton.
StateFromDifferentGraph

Request a state created by the same graph as this player.
NegativeDelta

Pass a nonnegative frame duration to AnimationGraphPlayer::advance.

Trait Implementations

`impl ArchivePointee for AnimationGraphPlayerError`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationGraphPlayerError`

`impl Clone for AnimationGraphPlayerError`

fn clone(&self) -> AnimationGraphPlayerError

Related: AnimationGraphPlayerError

`impl Debug for AnimationGraphPlayerError`

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

`impl Display for AnimationGraphPlayerError`

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

`impl Downcast for AnimationGraphPlayerError`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationGraphPlayerError`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationGraphPlayerError`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationGraphPlayerError`

`impl<K> Equivalent for AnimationGraphPlayerError`

```
fn equivalent(&self, key: &K) -> bool
```

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationGraphPlayerError`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationGraphPlayerError`

fn eq(&self, other: &AnimationGraphPlayerError) -> bool

Related: AnimationGraphPlayerError

`impl Pointable for AnimationGraphPlayerError`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationGraphPlayerError`

```
type Metadata = ()
```

```
fn to_string(&self) -> String
```

`impl WithSubscriber for AnimationGraphPlayerError`

`AnimationPoolEvent`

enum AnimationPoolEvent {
    LoadFailed {
        resource_id: String,
        error: String,
    },
    Oversized {
        resource_id: String,
        resident_bytes: usize,
        byte_budget: usize,
    },
    Evicted {
        resource_id: String,
    },
}

Defined in crates/byte-engine/src/animation/graph/runtime.rs:107-129

The AnimationPoolEvent enum reports load outcomes that require application-level handling.

Variants

LoadFailed

Handle a resource that could not be loaded.
Oversized

Increase the pool budget or use a smaller animation resource.
Evicted

Request the resource again before its next use.

Trait Implementations

`impl ArchivePointee for AnimationPoolEvent`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationPoolEvent`

`impl Clone for AnimationPoolEvent`

```
fn clone(&self) -> AnimationPoolEvent
```
Related: AnimationPoolEvent

`impl Debug for AnimationPoolEvent`

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

`impl Downcast for AnimationPoolEvent`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationPoolEvent`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationPoolEvent`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationPoolEvent`

`impl<K> Equivalent for AnimationPoolEvent`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationPoolEvent`

`impl LayoutRaw for AnimationPoolEvent`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationPoolEvent`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationPoolEvent`

fn eq(&self, other: &AnimationPoolEvent) -> bool

Related: AnimationPoolEvent

`impl Pointable for AnimationPoolEvent`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationPoolEvent`

```
type Metadata = ()
```

enum AnimationPoolRequest {
    Ready,
    Loading,
    WaitingForCapacity,
    Failed,
}

Defined in crates/byte-engine/src/animation/graph/runtime.rs:94-103

The AnimationPoolRequest enum reports whether a lease can be sampled immediately.

Variants

Ready

Acquire and sample the requested clip.
Loading

Wait while the requested clip loads asynchronously.
WaitingForCapacity

Retry when loading or residency capacity becomes available.
Failed

Handle the load failure or call AnimationPool::retry.

Trait Implementations

`impl ArchivePointee for AnimationPoolRequest`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for AnimationPoolRequest`

`impl Clone for AnimationPoolRequest`

```
fn clone(&self) -> AnimationPoolRequest
```
Related: AnimationPoolRequest

`impl Copy for AnimationPoolRequest`

`impl Debug for AnimationPoolRequest`

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

`impl Downcast for AnimationPoolRequest`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for AnimationPoolRequest`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for AnimationPoolRequest`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for AnimationPoolRequest`

`impl<K> Equivalent for AnimationPoolRequest`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for AnimationPoolRequest`

`impl LayoutRaw for AnimationPoolRequest`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for AnimationPoolRequest`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for AnimationPoolRequest`

fn eq(&self, other: &AnimationPoolRequest) -> bool

Related: AnimationPoolRequest

`impl Pointable for AnimationPoolRequest`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for AnimationPoolRequest`

```
type Metadata = ()
```

enum RootMotionRotation {
    None,
    Full,
}

Defined in crates/byte-engine/src/animation/graph/runtime/player.rs:106-111

The RootMotionRotation enum selects whether node-local rotation drives the owning object.

Variants

None

Keeps rotation in the visual pose.
Full

Extracts the node's full rotation.

Trait Implementations

`impl ArchivePointee for RootMotionRotation`

```
type ArchivedMetadata = ()
```

fn pointer_metadata(_: &<T as ArchivePointee>::ArchivedMetadata) -> <T as Pointee>::Metadata

`impl<ST> CastableFrom for RootMotionRotation`

`impl Clone for RootMotionRotation`

```
fn clone(&self) -> RootMotionRotation
```
Related: RootMotionRotation

`impl Copy for RootMotionRotation`

`impl Debug for RootMotionRotation`

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

`impl Downcast for RootMotionRotation`

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

```
fn as_any(&self) -> &dyn Any
```

fn as_any_mut(&mut self) -> &mut dyn Any

`impl DowncastSend for RootMotionRotation`

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

`impl DowncastSync for RootMotionRotation`

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

`impl Eq for RootMotionRotation`

`impl<K> Equivalent for RootMotionRotation`

```
fn equivalent(&self, key: &K) -> bool
```

`impl Instrument for RootMotionRotation`

`impl LayoutRaw for RootMotionRotation`

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

`impl<T, N1> Niching for RootMotionRotation`

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

fn resolve_niched(out: Place<NichedOption<T, N1>>)

`impl PartialEq for RootMotionRotation`

fn eq(&self, other: &RootMotionRotation) -> bool

Related: RootMotionRotation

`impl Pointable for RootMotionRotation`

```
const ALIGN: usize
```
```
type Init = T
```

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

```
unsafe fn drop(ptr: usize)
```

`impl Pointee for RootMotionRotation`

```
type Metadata = ()
```

const ANIMATION_LOAD_QUEUE_CAPACITY: usize = 64usize;

Defined in crates/byte-engine/src/animation/graph.rs:37

Bounds asynchronous animation load requests independently from the clip byte budget.

`ANIMATION_POOL_EVENT_CAPACITY`

const ANIMATION_POOL_EVENT_CAPACITY: usize = 64usize;

Defined in crates/byte-engine/src/animation/graph.rs:40

Bounds retained load outcomes so diagnostics cannot outgrow the clip pool.