bevy_animation_graph_editor 0.10.0

Animation graph editor for the Bevy game engine
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

pub mod paths;

pub struct TreeWidget<I, L, R> {
    pub tree: Tree<I, L>,
    pub id_hash: egui::Id,
    pub renderer: R,
}

impl<I, L, R> TreeWidget<I, L, R> {
    pub fn new_salted(tree: Tree<I, L>, renderer: R, salt: impl std::hash::Hash) -> Self {
        Self {
            tree,
            id_hash: egui::Id::new(salt),
            renderer,
        }
    }
}

impl<I, L, R> TreeWidget<I, L, R>
where
    R: TreeRenderer<I, L>,
    <R as TreeRenderer<I, L>>::Output: Default,
{
    pub fn show(self, ui: &mut egui::Ui, handle_result: impl FnOnce(R::Output)) -> egui::Response {
        ui.push_id(self.id_hash, |ui| {
            let mut output = R::Output::default();
            let response = self.tree.picker_selector(&mut output, ui, &self.renderer);
            handle_result(output);
            response
        })
        .inner
    }
}

pub struct Tree<I, L = I>(pub Vec<TreeInner<I, L>>);

pub enum TreeInner<I, L = I> {
    Leaf(L),
    Node(I, Vec<TreeInner<I, L>>),
}

pub trait TreeRenderer<I, L> {
    type Output;

    fn render_inner(
        &self,
        data: &I,
        children: &[TreeInner<I, L>],
        result: &mut Self::Output,
        ui: &mut egui::Ui,
        render_child: impl Fn(&TreeInner<I, L>, &mut Self::Output, &mut egui::Ui) -> egui::Response,
    ) -> egui::Response;

    fn render_leaf(&self, data: &L, result: &mut Self::Output, ui: &mut egui::Ui)
    -> egui::Response;
}

impl<I, L> Tree<I, L> {
    pub fn picker_selector<O, R>(
        &self,
        result: &mut O,
        ui: &mut egui::Ui,
        renderer: &R,
    ) -> egui::Response
    where
        R: TreeRenderer<I, L, Output = O>,
    {
        self.0
            .iter()
            .map(|subtree| subtree.picker_selector(result, ui, renderer))
            .reduce(|l, r| l | r)
            .unwrap_or_else(|| ui.allocate_response(egui::Vec2::ZERO, egui::Sense::hover()))
    }
}

impl<I, L> TreeInner<I, L> {
    pub fn picker_selector<O, R>(
        &self,
        result: &mut O,
        ui: &mut egui::Ui,
        renderer: &R,
    ) -> egui::Response
    where
        R: TreeRenderer<I, L, Output = O>,
    {
        match self {
            TreeInner::Leaf(data) => renderer.render_leaf(data, result, ui),
            TreeInner::Node(data, subtrees) => {
                renderer.render_inner(data, subtrees, result, ui, |subtree, result, ui| {
                    subtree.picker_selector(result, ui, renderer)
                })
            }
        }
    }
}