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

use bevy::ecs::world::World;
use bevy_animation_graph::core::state_machine::high_level::State;

use crate::ui::generic_widgets::{
    asset_picker::AssetPicker, fsm::transition_data::TransitionDataWidget,
    option::CheapOptionWidget,
};

pub struct StateWidget<'a> {
    pub state: &'a mut State,
    pub world: &'a mut World,
    pub id_hash: egui::Id,
}

impl<'a> StateWidget<'a> {
    pub fn new_salted(
        state: &'a mut State,
        world: &'a mut World,
        salt: impl std::hash::Hash,
    ) -> Self {
        Self {
            state,
            world,
            id_hash: egui::Id::new(salt),
        }
    }
}

impl<'a> egui::Widget for StateWidget<'a> {
    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
        let mut response = egui::Grid::new(self.id_hash)
            .show(ui, |ui| {
                let mut response = ui.label("id:");
                response |= ui.label(format!("{}", self.state.id.uuid().hyphenated()));
                ui.end_row();

                response |= ui.label("label:");
                response |= ui.text_edit_singleline(&mut self.state.label);
                ui.end_row();

                response |= ui.label("graph:");
                let path = self
                    .state
                    .graph
                    .path()
                    .map_or("<no asset path>".into(), |ap| ap.to_string());
                let r = ui.menu_button(path, |ui| {
                    ui.add(AssetPicker::new_salted(
                        &mut self.state.graph,
                        self.world,
                        ui.id().with("fsm state graph"),
                    ))
                });
                response |= r.response;
                if r.inner.is_some_and(|r| r.changed()) {
                    response.mark_changed();
                }
                ui.end_row();

                response
            })
            .inner;

        response |=
            CheapOptionWidget::new_salted(&mut self.state.state_transition, "state transition")
                .with_checkbox_label(Some("enable state transition:".into()))
                .ui(ui, |ui, data| {
                    egui::Frame::new()
                        .stroke(egui::Stroke {
                            width: 1.,
                            color: ui.visuals().weak_text_color(),
                        })
                        .fill(ui.visuals().faint_bg_color)
                        .outer_margin(3.)
                        .inner_margin(4.)
                        .corner_radius(5.)
                        .show(ui, |ui| {
                            ui.add(TransitionDataWidget::new_salted(
                                data,
                                self.world,
                                "transition data",
                            ))
                        })
                        .inner
                });

        response
    }
}