bevy_animation_graph_editor 0.8.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
129

use std::any::Any;

use bevy::math::Vec2;
use bevy_inspector_egui::reflect_inspector::InspectorUi;
use egui::Widget;
use egui_dock::egui;

use crate::ui::utils::popup::CustomPopup;

use super::{EguiInspectorExtension, MakeBuffer, WidgetHash};

pub struct Vec2PlaneInspector;

impl EguiInspectorExtension for Vec2PlaneInspector {
    type Base = Vec2;
    type Buffer = ();

    fn mutable(
        value: &mut Self::Base,
        (): &mut Self::Buffer,
        ui: &mut egui::Ui,
        _options: &dyn Any,
        id: egui::Id,
        _env: InspectorUi<'_, '_>,
    ) -> bool {
        let mut changed = false;

        ui.push_id(id, |ui| {
            let mut should_open_picker = false;

            ui.horizontal(|ui| {
                if egui::DragValue::new(&mut value.x).ui(ui).changed() {
                    changed = true;
                }
                if egui::DragValue::new(&mut value.y).ui(ui).changed() {
                    changed = true;
                }

                if ui.button("⌖").clicked() {
                    should_open_picker = true;
                }
            });

            CustomPopup::new()
                .with_allow_opening(false)
                .with_force_open(should_open_picker)
                .with_save_on_click(Some(()))
                .show_if_saved(ui, |ui, ()| {
                    let desired_size = egui::Vec2::new(150., 150.);
                    let (_, area_rect) = ui.allocate_space(desired_size);

                    let response = ui.interact(
                        area_rect,
                        ui.id().with("vec2 plane editor"),
                        egui::Sense::click_and_drag(),
                    );

                    if let Some(interact_pos) = response.interact_pointer_pos()
                        && (response.clicked() || response.dragged_by(egui::PointerButton::Primary))
                    {
                        let clipped_pos = area_rect.clamp(interact_pos);
                        let bevy_vec = Vec2::new(
                            (clipped_pos.x - area_rect.left()) / area_rect.width() * 2. - 1.,
                            -((clipped_pos.y - area_rect.top()) / area_rect.height() * 2. - 1.),
                        );
                        *value = bevy_vec;
                        changed = true;
                    }

                    let scaled_vec = Vec2::new(
                        ((value.x + 1.) / 2.) * area_rect.width() + area_rect.left(),
                        ((-value.y + 1.) / 2.) * area_rect.height() + area_rect.top(),
                    );

                    let axes_color = egui::Color32::GRAY;

                    ui.painter()
                        .rect_filled(area_rect, 3., egui::Color32::BLACK);

                    ui.painter().line_segment(
                        [area_rect.left_center(), area_rect.right_center()],
                        egui::Stroke {
                            width: 1.,
                            color: axes_color,
                        },
                    );

                    ui.painter().line_segment(
                        [area_rect.center_top(), area_rect.center_bottom()],
                        egui::Stroke {
                            width: 1.,
                            color: axes_color,
                        },
                    );

                    ui.painter().circle_filled(
                        egui::Pos2::new(scaled_vec.x, scaled_vec.y),
                        2.,
                        egui::Color32::RED,
                    );
                });
        });

        changed
    }

    fn readonly(
        value: &Self::Base,
        _buffer: &Self::Buffer,
        ui: &mut egui::Ui,
        _options: &dyn Any,
        _id: egui::Id,
        _env: InspectorUi<'_, '_>,
    ) {
        ui.label(format!("({}, {})", value.x, value.y));
    }
}

impl WidgetHash for Vec2 {
    // HACK: We really should not call this operation a widget "hash", but rather
    // a cache unique identifier generation or something along those lines
    fn widget_hash(&self) -> u64 {
        unsafe { std::mem::transmute(self.to_array()) }
    }
}

impl MakeBuffer<()> for Vec2 {
    fn make_buffer(&self) {}
}