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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use bevy::ecs::{
    component::Component,
    entity::Entity,
    event::Event,
    query::With,
    system::command::trigger,
    world::{CommandQueue, World},
};
use egui_dock::egui;
use egui_notify::Toasts;

use crate::ui::{
    actions::{EditorAction, PushQueue},
    core::Buffers,
    native_views::EditorViewState,
};

pub mod animation_clip_preview;
pub mod debugger;
pub mod event_sender;
pub mod event_track_editor;
pub mod fsm_editor;
pub mod fsm_picker;
pub mod graph_editor;
pub mod graph_picker;
pub mod inspector;
pub mod preview_hierarchy;
pub mod scene_picker;
pub mod scene_preview;
pub mod scene_preview_errors;

pub struct EditorWindowContext<'a> {
    pub window_entity: Entity,
    pub view_entity: Entity,
    pub notifications: &'a mut Toasts,
    pub command_queue: &'a mut CommandQueue,
    pub buffers: &'a mut Buffers,

    // Legacy stuff for backwards compat
    pub editor_actions: &'a mut PushQueue<EditorAction>,
}

impl EditorWindowContext<'_> {
    pub fn make_queue(&self) -> OwnedQueue {
        OwnedQueue {
            command_queue: CommandQueue::default(),
        }
    }

    pub fn consume_queue(&mut self, mut queue: OwnedQueue) {
        self.command_queue.append(&mut queue.command_queue);
    }
}

pub struct OwnedQueue {
    pub command_queue: CommandQueue,
}

impl OwnedQueue {
    pub fn trigger<'b>(&mut self, event: impl Event<Trigger<'b>: Default>) {
        self.command_queue.push(trigger(event));
    }
}

#[derive(Component)]
pub struct WindowState;

impl<'a> EditorWindowContext<'a> {
    pub fn trigger<'b>(&mut self, event: impl Event<Trigger<'b>: Default>) {
        self.command_queue.push(trigger(event));
    }

    pub fn get_window_state<'w, T: Component>(&self, world: &'w World) -> Option<&'w T> {
        let mut query = world.try_query_filtered::<&T, With<WindowState>>()?;
        query.get(world, self.window_entity).ok()
    }

    pub fn get_view_state<'w, T: Component>(&self, world: &'w World) -> Option<&'w T> {
        let mut query = world.try_query_filtered::<&T, With<EditorViewState>>()?;
        query.get(world, self.view_entity).ok()
    }
}

pub struct EditorWindowRegistrationContext {
    pub view: Entity,
    pub window: Entity,
}

pub trait NativeEditorWindowExtension: std::fmt::Debug + Send + Sync + 'static {
    fn ui(&self, ui: &mut egui::Ui, world: &mut World, ctx: &mut EditorWindowContext);

    fn display_name(&self) -> String;

    #[allow(unused_variables)]
    fn init(&self, world: &mut World, ctx: &EditorWindowRegistrationContext) {}

    fn closeable(&self) -> bool {
        false
    }
}

#[derive(Debug)]
pub struct NativeEditorWindow {
    window: Box<dyn NativeEditorWindowExtension>,
    pub entity: Entity,
}

impl NativeEditorWindowExtension for NativeEditorWindow {
    fn init(&self, world: &mut World, ctx: &EditorWindowRegistrationContext) {
        self.window.init(world, ctx)
    }

    fn ui(&self, ui: &mut egui::Ui, world: &mut World, ctx: &mut EditorWindowContext) {
        self.window.ui(ui, world, ctx);
    }

    fn display_name(&self) -> String {
        self.window.display_name()
    }

    fn closeable(&self) -> bool {
        self.window.closeable()
    }
}

impl NativeEditorWindow {
    pub fn create<T: NativeEditorWindowExtension>(
        world: &mut World,
        view_entity: Entity,
        ext: T,
    ) -> Self {
        let entity = world.spawn((WindowState,)).id();

        let ctx = EditorWindowRegistrationContext {
            window: entity,
            view: view_entity,
        };

        ext.init(world, &ctx);

        Self {
            window: Box::new(ext),
            entity,
        }
    }
}