Struct SkinnedMeshSystem 

pub struct SkinnedMeshSystem { /* private fields */ }

Computes per-joint skinning matrices for skinned meshes.

This system defers to TransformSystem for cached world matrices.

For each SkinnedMeshComponent, it computes (mesh-local) skin matrices:

$$ SkinMat_j = inverse(M_meshWorld) * M_jointWorld(j) * IBM(j) $$

so the GPU can skin in mesh-local space, then apply the instance model matrix as usual.

Implementations

impl SkinnedMeshSystem

pub fn new() -> Self

pub fn register_skin_instance_joints( &mut self, gltf_component: ComponentId, skin_id: SkinId, joints: Vec<Option<ComponentId>>, )

pub fn instance_joints_for_skin( &self, gltf_component: ComponentId, skin_id: SkinId, ) -> Option<&[Option<ComponentId>]>

Read-only access to the resolved joint transform ComponentIds for a particular (GLTFComponent instance, SkinId) pair.

The returned slice is in the same order as VisualWorld::skin(skin_id).joint_node_indices.

Examples found in repository

examples/vtuber-joints-example.rs (line 724)

fn collect_joint_transforms(
    world: &engine::ecs::World,
    skinned_mesh: &engine::ecs::system::SkinnedMeshSystem,
    visuals: &engine::graphics::VisualWorld,
    gltf_component: engine::ecs::ComponentId,
    root: engine::ecs::ComponentId,
) -> Vec<(usize, engine::ecs::ComponentId)> {
    fn find_first_skin_id_in_subtree(
        world: &engine::ecs::World,
        root: engine::ecs::ComponentId,
    ) -> Option<engine::graphics::SkinId> {
        let mut stack = vec![root];
        while let Some(node) = stack.pop() {
            if let Some(sm) = world.get_component_by_id_as::<SkinnedMeshComponent>(node) {
                if let Some(id) = sm.skin_id {
                    return Some(id);
                }
            }
            for &ch in world.children_of(node) {
                stack.push(ch);
            }
        }
        None
    }

    let Some(skin_id) = find_first_skin_id_in_subtree(world, root) else {
        return Vec::new();
    };
    let Some(skin) = visuals.skin(skin_id) else {
        return Vec::new();
    };
    let Some(joints) = skinned_mesh.instance_joints_for_skin(gltf_component, skin_id) else {
        return Vec::new();
    };

    let joint_count = skin.joint_count().min(joints.len());
    let mut out: Vec<(usize, engine::ecs::ComponentId)> = Vec::with_capacity(joint_count);
    for i in 0..joint_count {
        let Some(joint_tx) = joints[i] else {
            continue;
        };
        let node_index = skin.joint_node_indices[i];
        out.push((node_index, joint_tx));
    }

    out
}

pub fn transform_subtree_changed(&mut self, world: &World, root: ComponentId)

Notify the system that a transform subtree changed.

This walks the subtree and marks any skins referencing affected joint transforms dirty.

Trait Implementations

impl Debug for SkinnedMeshSystem

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

Formats the value using the given formatter.

impl Default for SkinnedMeshSystem

fn default() -> SkinnedMeshSystem

Returns the “default value” for a type.

impl System for SkinnedMeshSystem

fn tick( &mut self, world: &mut World, visuals: &mut VisualWorld, _input: &InputState, _dt_sec: f32, )