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
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 bevy_animation_graph::core::{id::BoneId, skeleton::Skeleton};

use crate::ui::generic_widgets::uuid::UuidWidget;

pub struct BoneIdWidget<'a> {
    pub bone_id: &'a mut BoneId,
    pub id_hash: egui::Id,
    pub skeleton: Option<&'a Skeleton>,
}

impl<'a> BoneIdWidget<'a> {
    pub fn new_salted(bone_id: &'a mut BoneId, salt: impl std::hash::Hash) -> Self {
        Self {
            bone_id,
            id_hash: egui::Id::new(salt),
            skeleton: None,
        }
    }

    pub fn with_skeleton(mut self, skeleton: Option<&'a Skeleton>) -> Self {
        self.skeleton = skeleton;
        self
    }
}

impl<'a> egui::Widget for BoneIdWidget<'a> {
    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
        ui.push_id(self.id_hash, |ui| {
            ui.with_layout(egui::Layout::top_down(egui::Align::Center), |ui| {
                let mut response = ui
                    .horizontal(|ui| {
                        let picker_response =
                            self.skeleton.map(|skn| picker(ui, self.bone_id, skn));

                        let mut uuid = self.bone_id.id();
                        let mut response =
                            ui.add(UuidWidget::new_salted(&mut uuid, "bone id uuid"));
                        if let Some(picker_response) = picker_response {
                            response |= picker_response;
                        }
                        *self.bone_id = BoneId::from_uuid(uuid);

                        response
                    })
                    .inner;

                if let Some(skeleton) = self.skeleton
                    && let Some(bone_path) = skeleton.id_to_path(*self.bone_id)
                {
                    response |= ui.label(bone_path.to_slashed_string());
                } else {
                    response |= ui.label("No label available");
                }

                response
            })
            .inner
        })
        .inner
    }
}

fn picker(ui: &mut egui::Ui, bone_id: &mut BoneId, skeleton: &Skeleton) -> egui::Response {
    let mut changed = false;
    let mut popup_response = ui
        .menu_button("🔍", |ui| {
            for available_bone_id in skeleton.iter_bones() {
                let Some(available_bone_path) = skeleton.id_to_path(available_bone_id) else {
                    continue;
                };
                let label = available_bone_path.to_slashed_string();
                if ui.button(label).clicked() {
                    *bone_id = available_bone_id;
                    changed = true;
                }
            }
        })
        .response;

    if changed {
        popup_response.mark_changed();
    }

    popup_response
}

pub struct BoneIdReadonlyWidget<'a> {
    pub bone_id: &'a BoneId,
    pub id_hash: egui::Id,
    pub skeleton: Option<&'a Skeleton>,
}

impl<'a> BoneIdReadonlyWidget<'a> {
    pub fn new_salted(bone_id: &'a BoneId, salt: impl std::hash::Hash) -> Self {
        Self {
            bone_id,
            id_hash: egui::Id::new(salt),
            skeleton: None,
        }
    }

    pub fn with_skeleton(mut self, skeleton: Option<&'a Skeleton>) -> Self {
        self.skeleton = skeleton;
        self
    }
}

impl<'a> egui::Widget for BoneIdReadonlyWidget<'a> {
    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
        ui.push_id(self.id_hash, |ui| {
            ui.with_layout(egui::Layout::top_down(egui::Align::Center), |ui| {
                let mut response = ui.label(format!("{}", self.bone_id.id().hyphenated()));

                if let Some(skeleton) = self.skeleton
                    && let Some(bone_path) = skeleton.id_to_path(*self.bone_id)
                {
                    response |= ui.label(bone_path.to_slashed_string());
                } else {
                    response |= ui.label("No label available");
                }

                response
            })
            .inner
        })
        .inner
    }
}