animgraph 0.1.0

Animation data flow library using hierarchical state machines
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
129
130
131
132
133
134
135
136
137
138
139

use std::ops::Range;

use serde_derive::{Deserialize, Serialize};

use crate::{
    state_machine::NodeIndex, BlendSampleId, BlendTree, Graph, GraphNodeConstructor, IndexType,
    PoseGraph, PoseNode, PoseParent,
};

use super::{GraphNode, GraphVisitor};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TreeNode {
    pub children: Range<IndexType>,
}

impl GraphNodeConstructor for TreeNode {
    fn identity() -> &'static str {
        "tree"
    }

    fn construct_entry(self, metrics: &crate::GraphMetrics) -> anyhow::Result<crate::GraphNodeEntry> {
        metrics.validate_children(&self.children, Self::identity())?;
        Ok(crate::GraphNodeEntry::PoseParent(Box::new(self)))
    }
}

impl Default for TreeNode {
    fn default() -> Self {
        Self {
            children: Default::default(),
        }
    }
}

impl GraphNode for TreeNode {
    fn visit(&self, visitor: &mut GraphVisitor) {
        visitor.visit(self.children.clone());
    }
}

impl PoseParent for TreeNode {
    fn apply_parent(
        &self,
        tasks: &mut BlendTree,
        mut child_task: BlendSampleId,
        graph: &Graph,
    ) -> anyhow::Result<BlendSampleId> {
        for child in self.children.clone() {
            if let Some(parent) = graph.pose_parent(NodeIndex(child)) {
                child_task = parent.apply_parent(tasks, child_task, graph)?;
            }
        }

        Ok(child_task)
    }

    fn as_pose(&self) -> Option<&dyn PoseNode> {
        Some(self)
    }
}

impl PoseNode for TreeNode {
    fn sample(
        &self,
        tasks: &mut BlendTree,
        graph: &Graph,
    ) -> anyhow::Result<Option<BlendSampleId>> {
        for index in self.children.clone() {
            if let Some(mut child_task) = graph.sample_pose(tasks, NodeIndex(index))? {
                for sibling in index+1..self.children.end {
                    if let Some(parent) = graph.pose_parent(NodeIndex(sibling)) {
                        child_task = parent.apply_parent(tasks, child_task, graph)?;
                    }
                }
                return Ok(Some(child_task));
            }
        }
        Ok(None)
    }
}

#[cfg(feature = "compiler")]
pub mod compile {

    use serde_json::Value;

    use crate::{
        compiler::prelude::{
            Extras, IOType, Node, NodeCompilationError, NodeCompiler, NodeSerializationContext,
            NodeSettings,
        },
        GraphNodeConstructor, IndexType, model::NodeChildRange,
    };

    pub use super::TreeNode;

    #[derive(Debug, Clone, Default)]
    pub struct TreeSettings;

    impl NodeSettings for TreeSettings {
        fn name() -> &'static str {
            TreeNode::identity()
        }

        fn input() -> &'static [(&'static str, IOType)] {
            &[]
        }

        fn output() -> &'static [(&'static str, IOType)] {
            &[]
        }

        fn build(self) -> anyhow::Result<Extras> {
            Ok(Extras::default())
        }

        fn child_range() -> NodeChildRange {
            NodeChildRange::UpTo(IndexType::MAX as usize)
        }

    }

    impl NodeCompiler for TreeNode {
        type Settings = TreeSettings;

        fn build<'a>(
            context: &NodeSerializationContext<'a>,
        ) -> Result<Value, NodeCompilationError> {
            context.serialize_node(TreeNode {
                children: context.children(),
            })
        }
    }

    pub fn tree(nodes: impl Into<Vec<Node>>) -> Node {
        Node::new(vec![], nodes.into(), TreeSettings).expect("Valid")
    }
}