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

use bevy::{
    asset::Handle,
    ecs::hierarchy::ChildSpawnerCommands,
    image::Image,
    light::PointLight,
    math::Vec3,
    prelude::{Transform, World},
};
use bevy_animation_graph::core::{
    animated_scene::{AnimatedScene, AnimatedSceneHandle, AnimatedSceneInstance},
    animation_graph_player::AnimationGraphPlayer,
};
use egui_dock::egui;

use crate::ui::{
    PartOfSubScene, PreviewScene, SubSceneConfig, SubSceneSyncAction,
    native_windows::{EditorWindowContext, NativeEditorWindowExtension},
    state_management::global::{ClearGlobalState, active_scene::ActiveScene, get_global_state},
    utils::orbit_camera_scene_show,
};

#[derive(Debug, Default)]
pub struct ScenePreviewWindow;

impl NativeEditorWindowExtension for ScenePreviewWindow {
    fn ui(&self, ui: &mut egui::Ui, world: &mut World, ctx: &mut EditorWindowContext) {
        let Some(active_scene) = get_global_state::<ActiveScene>(world) else {
            return;
        };

        let config = ScenePreviewConfig {
            animated_scene: active_scene.handle.clone(),
        };

        let ui_texture_id = ui.id().with("Scene preview texture");
        let mut query = world.query::<(&AnimatedSceneInstance, &PreviewScene, &PartOfSubScene)>();
        if let Some((instance, _, _)) = query
            .iter(world)
            .find(|(_, _, PartOfSubScene(uid))| *uid == ui_texture_id)
        {
            // Scene playback control will only be shown once the scene is created
            // (so from the second frame onwards)
            let entity = instance.player_entity();
            let mut query = world.query::<&mut AnimationGraphPlayer>();
            let Ok(mut player) = query.get_mut(world, entity) else {
                return;
            };

            ui.horizontal(|ui| {
                if ui.button("X").on_hover_text("Close preview").clicked() {
                    ctx.trigger(ClearGlobalState::<ActiveScene>::default());
                }

                if ui.button("||").on_hover_text("Pause").clicked() {
                    player.pause()
                }

                if ui.button(">").on_hover_text("Play").clicked() {
                    player.resume()
                }

                if ui.button("||>").on_hover_text("Play one frame").clicked() {
                    player.play_one_frame()
                }
            });
        }

        orbit_camera_scene_show(&config, ui, world, ui_texture_id);
    }

    fn display_name(&self) -> String {
        "Scene Preview".to_string()
    }
}

#[derive(Clone, PartialEq)]
pub struct ScenePreviewConfig {
    pub animated_scene: Handle<AnimatedScene>,
}

impl SubSceneConfig for ScenePreviewConfig {
    fn spawn(&self, builder: &mut ChildSpawnerCommands, _: Handle<Image>) {
        builder.spawn((
            PointLight::default(),
            Transform::from_translation(Vec3::new(0.0, 0.0, 10.0)),
        ));

        builder.spawn((
            AnimatedSceneHandle::new(self.animated_scene.clone()),
            PreviewScene,
        ));
    }

    fn sync_action(&self, new_config: &Self) -> SubSceneSyncAction {
        match self.animated_scene == new_config.animated_scene {
            true => SubSceneSyncAction::Nothing,
            false => SubSceneSyncAction::Respawn,
        }
    }

    fn update(&self, _id: egui::Id, _world: &mut World) {}
}