move graph creations to assets menu

Author: mbrea-c

crates/bevy_animation_graph_editor/src/ui/actions/graph.rs

@@ -18,11 +18,8 @@ use bevy_animation_graph::core::{
     state_machine::high_level::StateMachine,
 };
 
-use super::{DynamicAction, run_handler, saving::DirtyAssets};
-use crate::{
-    graph_show::{GraphIndicesMap, make_graph_indices},
-    ui::actions::ActionContext,
-};
+use super::saving::DirtyAssets;
+use crate::graph_show::{GraphIndicesMap, make_graph_indices};
 
 pub enum GraphAction {
     CreateLink(CreateLink),
@@ -358,22 +355,3 @@ impl GraphAndContext<'_> {
         }
     }
 }
-
-pub struct CreateGraphAction;
-
-impl DynamicAction for CreateGraphAction {
-    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
-        run_handler(world, "Could not create clip preview")(
-            |In(_),
-             mut graph_assets: ResMut<Assets<AnimationGraph>>,
-             mut dirty_assets: ResMut<DirtyAssets>| {
-                let new_handle = graph_assets.add(AnimationGraph::default());
-                info!("Creating graph with id: {:?}", new_handle.id());
-                dirty_assets
-                    .assets
-                    .insert(new_handle.id().untyped(), new_handle.untyped());
-            },
-            *self,
-        )
-    }
-}

crates/bevy_animation_graph_editor/src/ui/core.rs

@@ -21,7 +21,8 @@ use crate::ui::{
     native_views::{EditorView, EditorViewContext, EditorViewUiState},
     native_windows::{NativeEditorWindow, NativeEditorWindowExtension},
     state_management::global::{
-        GlobalState, clip::RequestCreateClip, fsm::RequestCreateFsm, ragdoll::RequestCreateRagdoll,
+        GlobalState, animation_graph::RequestCreateAnimationGraph, clip::RequestCreateClip,
+        fsm::RequestCreateFsm, ragdoll::RequestCreateRagdoll,
         ragdoll_bone_map::RequestCreateRagdollBoneMap, skeleton::RequestCreateSkeleton,
     },
 };
@@ -152,6 +153,9 @@ fn menu_bar(ctx: &mut egui::Context, command_queue: &mut CommandQueue) {
                     if ui.button("Animation").clicked() {
                         command_queue.push(trigger(RequestCreateClip));
                     }
+                    if ui.button("Animation graph").clicked() {
+                        command_queue.push(trigger(RequestCreateAnimationGraph));
+                    }
                     if ui.button("State machine").clicked() {
                         command_queue.push(trigger(RequestCreateFsm));
                     }

crates/bevy_animation_graph_editor/src/ui/native_windows/asset_creation/animation_graph.rs

@@ -0,0 +1,21 @@
+use bevy_animation_graph::core::animation_graph::AnimationGraph;
+
+use crate::ui::{
+    native_windows::asset_creation::generic_with_path::CreateAssetFromPath,
+    state_management::global::animation_graph::CreateAnimationGraph,
+};
+
+#[derive(Debug, Clone, Copy)]
+pub struct CreateAnimationGraphWindow;
+
+impl CreateAssetFromPath for CreateAnimationGraphWindow {
+    const NAME: &'static str = "Create animation graph";
+    const EXTENSION: &'static str = ".animgraph.ron";
+
+    fn create(&self, path: String, queue: &mut crate::ui::native_windows::OwnedQueue) {
+        queue.trigger(CreateAnimationGraph {
+            animation_graph: AnimationGraph::default(),
+            virtual_path: path.to_string(),
+        });
+    }
+}

crates/bevy_animation_graph_editor/src/ui/native_windows/asset_creation/mod.rs

@@ -1,4 +1,5 @@
 pub mod anim;
+pub mod animation_graph;
 pub mod fsm;
 pub mod generic_with_path;
 pub mod ragdoll;

crates/bevy_animation_graph_editor/src/ui/native_windows/graph_picker.rs

@@ -2,7 +2,6 @@ use bevy::{asset::Handle, prelude::World};
 use egui_dock::egui;
 
 use crate::ui::{
-    actions::graph::CreateGraphAction,
     generic_widgets::asset_picker::AssetPicker,
     native_windows::{EditorWindowContext, NativeEditorWindowExtension},
     state_management::global::{
@@ -35,10 +34,6 @@ impl NativeEditorWindowExtension for GraphPickerWindow {
                 selection: InspectorSelection::ActiveGraph,
             })
         }
-
-        if ui.button("New Graph").clicked() {
-            ctx.editor_actions.dynamic(CreateGraphAction);
-        }
     }
 
     fn display_name(&self) -> String {

crates/bevy_animation_graph_editor/src/ui/state_management/global/animation_graph.rs

@@ -0,0 +1,93 @@
+use bevy::ecs::{
+    component::Component,
+    entity::Entity,
+    event::Event,
+    observer::On,
+    reflect::AppTypeRegistry,
+    system::{Commands, Res, ResMut},
+    world::World,
+};
+use bevy_animation_graph::core::animation_graph::{
+    AnimationGraph, serial::AnimationGraphSerializer,
+};
+
+use crate::{
+    Cli,
+    scanner::RescanAssets,
+    ui::{
+        UiState,
+        core::EguiWindow,
+        native_windows::{
+            NativeEditorWindow, asset_creation::animation_graph::CreateAnimationGraphWindow,
+        },
+        state_management::global::RegisterStateComponent,
+    },
+};
+
+#[derive(Debug, Component, Default, Clone)]
+pub struct AnimationGraphManager;
+
+impl RegisterStateComponent for AnimationGraphManager {
+    fn register(world: &mut World, _global_state_entity: Entity) {
+        world.add_observer(RequestCreateAnimationGraph::observe);
+        world.add_observer(CreateAnimationGraph::observe);
+    }
+}
+
+/// Will open a "create FSM" window popup
+#[derive(Event)]
+pub struct RequestCreateAnimationGraph;
+
+impl RequestCreateAnimationGraph {
+    pub fn observe(
+        _: On<RequestCreateAnimationGraph>,
+        mut commands: Commands,
+        ui_state: ResMut<UiState>,
+    ) {
+        if let Some(active_view_idx) = ui_state.active_view {
+            let view = &ui_state.views[active_view_idx];
+            let win = NativeEditorWindow::create_cmd(
+                &mut commands,
+                view.entity,
+                CreateAnimationGraphWindow,
+            );
+
+            let UiState { views, .. } = ui_state.into_inner();
+
+            views[active_view_idx]
+                .dock_state
+                .add_window(vec![EguiWindow::EntityWindow(win)]);
+        }
+    }
+}
+
+#[derive(Event)]
+pub struct CreateAnimationGraph {
+    pub virtual_path: String,
+    pub animation_graph: AnimationGraph,
+}
+
+impl CreateAnimationGraph {
+    pub fn observe(
+        event: On<CreateAnimationGraph>,
+        cli: Res<Cli>,
+        registry: Res<AppTypeRegistry>,
+        mut commands: Commands,
+    ) {
+        let type_registry = registry.0.read();
+        let graph_serial = AnimationGraphSerializer::new(&event.animation_graph, &type_registry);
+
+        let mut final_path = cli.asset_source.clone();
+        final_path.push(&event.virtual_path);
+        bevy::log::info!("Creating animation graph metadata at {:?}", final_path);
+        ron::Options::default()
+            .to_io_writer_pretty(
+                std::fs::File::create(final_path).unwrap(),
+                &graph_serial,
+                ron::ser::PrettyConfig::default(),
+            )
+            .unwrap();
+
+        commands.trigger(RescanAssets);
+    }
+}

crates/bevy_animation_graph_editor/src/ui/state_management/global/mod.rs

@@ -7,6 +7,7 @@ pub mod active_graph_node;
 pub mod active_ragdoll;
 pub mod active_scene;
 pub mod active_skeleton;
+pub mod animation_graph;
 pub mod clip;
 pub mod fsm;
 pub mod inspector_selection;
@@ -32,8 +33,9 @@ use crate::ui::state_management::global::{
     active_fsm_transition::ActiveFsmTransition, active_graph::ActiveGraph,
     active_graph_context::ActiveContexts, active_graph_node::ActiveGraphNode,
     active_ragdoll::ActiveRagdoll, active_scene::ActiveScene, active_skeleton::ActiveSkeleton,
-    clip::ClipManager, fsm::FsmManager, inspector_selection::InspectorSelection,
-    ragdoll::RagdollManager, ragdoll_bone_map::RagdollBoneMapManager, skeleton::SkeletonManager,
+    animation_graph::AnimationGraphManager, clip::ClipManager, fsm::FsmManager,
+    inspector_selection::InspectorSelection, ragdoll::RagdollManager,
+    ragdoll_bone_map::RagdollBoneMapManager, skeleton::SkeletonManager,
 };
 
 #[derive(Component)]
@@ -58,6 +60,7 @@ impl GlobalState {
         RagdollManager::register(world, entity);
         RagdollBoneMapManager::register(world, entity);
         SkeletonManager::register(world, entity);
+        AnimationGraphManager::register(world, entity);
 
         world.add_observer(CloseWindow::observe);
     }