Struct Pose 

pub struct Pose { /* private fields */ }

A mutable snapshot of a skeleton’s joint poses with world-space helpers.

Obtain one from AnimationPlayer::compute_pose. Optionally modify joints for IK, then call skinning_matrices to get the final matrices ready for a SkinningBatch.

let mut pose = player.compute_pose();
let foot   = skeleton.joint_index_by_name("foot_l").unwrap();
let lower  = skeleton.joint_index_by_name("lower_leg_l").unwrap();
let upper  = skeleton.joint_index_by_name("upper_leg_l").unwrap();

// analytic two-bone IK — you supply the math, Pose handles local/world conversion
let (r_upper, r_lower) = two_bone_ik(
    pose.world_position(upper),
    pose.world_position(lower),
    target_foot_pos,
);
pose.set_world_rotation(upper, r_upper);
pose.set_world_rotation(lower, r_lower);

let matrices = pose.skinning_matrices();

Implementations

impl Pose

pub fn world_position(&mut self, joint: usize) -> Vec3

World-space position of joint (origin of its local frame).

pub fn world_rotation(&mut self, joint: usize) -> Quat

World-space rotation of joint.

pub fn world_matrix(&mut self, joint: usize) -> Mat4

Full world-space matrix of joint — position, rotation, and scale in one shot. Multiply by the entity’s own world matrix to get game-world space.

pub fn set_world_rotation(&mut self, joint: usize, rotation: Quat)

Set joint’s orientation in world space. Converts to local (parent-relative) rotation automatically — no matrix math on your side.

pub fn set_world_position(&mut self, joint: usize, position: Vec3)

Set joint’s position in world space. Converts to local (parent-relative) translation automatically.

pub fn local(&self, joint: usize) -> Transform

Local (parent-relative) transform of joint.

pub fn set_local(&mut self, joint: usize, t: Transform)

Directly set joint’s local (parent-relative) transform. Use when you already have the correct local-space value.

pub fn skeleton(&self) -> &Skeleton

Access the underlying skeleton — for name lookups, joint count, etc.

pub fn skinning_matrices(&self) -> Vec<Mat4>

Compute skinning matrices from the current (possibly IK-modified) pose, ready to write into a SkinnedBatchRenderer.