gltf_kun 0.0.10

Graph-based glTF processing library.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use petgraph::graph::NodeIndex;

use crate::graph::{
    gltf::{Accessor, GltfEdge, GltfWeight},
    Edge, Extensions, Graph, GraphNodeEdges, GraphNodeWeight, Weight,
};

pub use gltf::animation::Interpolation;

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AnimationSamplerEdge {
    Input,
    Output,
}

impl<'a> TryFrom<&'a Edge> for &'a AnimationSamplerEdge {
    type Error = ();
    fn try_from(value: &'a Edge) -> Result<Self, Self::Error> {
        match value {
            Edge::Gltf(GltfEdge::AnimationSampler(edge)) => Ok(edge),
            _ => Err(()),
        }
    }
}

impl From<AnimationSamplerEdge> for Edge {
    fn from(edge: AnimationSamplerEdge) -> Self {
        Self::Gltf(GltfEdge::AnimationSampler(edge))
    }
}

#[derive(Clone, Debug, Default)]
pub struct AnimationSamplerWeight {
    pub extras: gltf::json::Extras,
    pub interpolation: Interpolation,
}

impl From<AnimationSamplerWeight> for Weight {
    fn from(weight: AnimationSamplerWeight) -> Self {
        Self::Gltf(GltfWeight::AnimationSampler(weight))
    }
}

impl<'a> TryFrom<&'a Weight> for &'a AnimationSamplerWeight {
    type Error = ();
    fn try_from(value: &'a Weight) -> Result<Self, Self::Error> {
        match value {
            Weight::Gltf(GltfWeight::AnimationSampler(weight)) => Ok(weight),
            _ => Err(()),
        }
    }
}

impl<'a> TryFrom<&'a mut Weight> for &'a mut AnimationSamplerWeight {
    type Error = ();
    fn try_from(value: &'a mut Weight) -> Result<Self, Self::Error> {
        match value {
            Weight::Gltf(GltfWeight::AnimationSampler(weight)) => Ok(weight),
            _ => Err(()),
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AnimationSampler(pub NodeIndex);

impl From<NodeIndex> for AnimationSampler {
    fn from(index: NodeIndex) -> Self {
        Self(index)
    }
}

impl From<AnimationSampler> for NodeIndex {
    fn from(image: AnimationSampler) -> Self {
        image.0
    }
}

impl GraphNodeWeight<AnimationSamplerWeight> for AnimationSampler {}
impl GraphNodeEdges for AnimationSampler {}
impl Extensions for AnimationSampler {}

impl AnimationSampler {
    pub fn input(&self, graph: &Graph) -> Option<Accessor> {
        self.find_edge_target(graph, &AnimationSamplerEdge::Input)
    }
    pub fn set_input(&self, graph: &mut Graph, input: Option<Accessor>) {
        self.set_edge_target(graph, AnimationSamplerEdge::Input, input);
    }

    pub fn output(&self, graph: &Graph) -> Option<Accessor> {
        self.find_edge_target(graph, &AnimationSamplerEdge::Output)
    }
    pub fn set_output(&self, graph: &mut Graph, output: Option<Accessor>) {
        self.set_edge_target(graph, AnimationSamplerEdge::Output, output);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn input() {
        let mut graph = Graph::default();
        let sampler = AnimationSampler::new(&mut graph);

        let accessor = Accessor::new(&mut graph);
        sampler.set_input(&mut graph, Some(accessor));
        assert_eq!(sampler.input(&graph), Some(accessor));

        sampler.set_input(&mut graph, None);
        assert_eq!(sampler.input(&graph), None);
    }

    #[test]
    fn output() {
        let mut graph = Graph::default();
        let sampler = AnimationSampler::new(&mut graph);

        let accessor = Accessor::new(&mut graph);
        sampler.set_output(&mut graph, Some(accessor));
        assert_eq!(sampler.output(&graph), Some(accessor));

        sampler.set_output(&mut graph, None);
        assert_eq!(sampler.output(&graph), None);
    }
}