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

use std::num::NonZeroU16;
use std::sync::Arc;
pub type IndexType = u16;
pub type OptionalIndexType = Option<NonZeroU16>;

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

mod blend;
mod core;
mod data;
mod graph;
mod graph_definition;
mod interpreter;
mod layer_builder;

pub mod io;
pub mod processors;
pub mod state_machine;

pub use crate::blend::*;
pub use crate::core::*;
pub use crate::data::*;
pub use crate::graph::*;
pub use crate::graph_definition::*;
pub use crate::interpreter::*;
pub use crate::layer_builder::*;

pub use anyhow;
pub use serde;
pub use serde_derive;
pub use serde_json;
pub use glam;
#[cfg(feature = "compiler")]
pub use uuid;

use processors::FlowEvents;

#[derive(Default, Clone)]
pub struct DefaultRunContext {
    pub events: FlowEvents,
    pub layers: LayerBuilder,
    pub tree: BlendTree,
    pub delta_time: f64,
}

impl DefaultRunContext {
    pub fn new(delta_time: f64) -> Self {
        DefaultRunContext {
            events: Default::default(),
            layers: Default::default(),
            tree: Default::default(),
            delta_time,
        }
    }

    pub fn run_without_blend(&mut self, graph: &mut Graph) {
        let defintion = Arc::clone(graph.definition());
        let _runner = Interpreter::run(
            graph,
            &defintion,
            &mut self.events,
            &mut self.layers,
            self.delta_time,
        );
    }

    pub fn run_and_append(&mut self, graph: &mut Graph) {
        self.run_without_blend(graph);
        self.tree.append(graph, &self.layers).expect("Valid blend");
    }

    pub fn run(&mut self, graph: &mut Graph) {
        self.clear();
        self.run_and_append(graph);
    }

    pub fn clear(&mut self) {
        self.tree.clear();
        self.layers.clear();
        self.events.clear();
    }
}