scena 1.7.2

A Rust-native scene-graph renderer with typed scene state, glTF assets, and explicit prepare/render lifecycles.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::diagnostics::LookupError;
use crate::geometry::SkinningMatrix;

use super::{NodeKey, Scene};

#[derive(Debug, Clone, PartialEq)]
pub struct SceneSkinBinding {
    joints: Vec<NodeKey>,
    inverse_bind_matrices: Vec<SkinningMatrix>,
}

impl Scene {
    pub fn skin_binding(&self, node: NodeKey) -> Option<&SceneSkinBinding> {
        self.skin_bindings.get(&node)
    }

    pub fn skin_matrices(&self, node: NodeKey) -> Option<Vec<SkinningMatrix>> {
        let binding = self.skin_bindings.get(&node)?;
        let mesh_inverse = SkinningMatrix::inverse_from_transform(self.world_transform(node)?);
        binding
            .joints
            .iter()
            .zip(binding.inverse_bind_matrices.iter().copied())
            .map(|(joint, inverse_bind)| {
                let joint_world = SkinningMatrix::from_transform(self.world_transform(*joint)?);
                Some(mesh_inverse.then(joint_world).then(inverse_bind))
            })
            .collect()
    }

    pub(crate) fn set_initial_skin_binding(&mut self, node: NodeKey, binding: SceneSkinBinding) {
        self.skin_bindings.insert(node, binding);
    }

    pub fn set_skin_binding(
        &mut self,
        node: NodeKey,
        binding: SceneSkinBinding,
    ) -> Result<(), LookupError> {
        if !self.nodes.contains_key(node) {
            return Err(LookupError::NodeNotFound(node));
        }
        if binding.joints.len() != binding.inverse_bind_matrices.len() {
            return Err(LookupError::InvalidSkinBinding {
                joint_count: binding.joints.len(),
                inverse_bind_count: binding.inverse_bind_matrices.len(),
            });
        }
        for joint in &binding.joints {
            if !self.nodes.contains_key(*joint) {
                return Err(LookupError::NodeNotFound(*joint));
            }
        }
        if self.skin_bindings.get(&node) == Some(&binding) {
            return Ok(());
        }
        self.skin_bindings.insert(node, binding);
        self.structure_revision = self.structure_revision.saturating_add(1);
        Ok(())
    }
}

impl SceneSkinBinding {
    pub fn new(joints: Vec<NodeKey>, inverse_bind_matrices: Vec<SkinningMatrix>) -> Self {
        Self {
            joints,
            inverse_bind_matrices,
        }
    }

    pub fn joints(&self) -> &[NodeKey] {
        &self.joints
    }

    pub fn inverse_bind_matrices(&self) -> &[SkinningMatrix] {
        &self.inverse_bind_matrices
    }
}