Can now create skeletons from the editor

Author: mbrea-c

crates/bevy_animation_graph_core/src/skeleton/serial.rs

@@ -1,4 +1,4 @@
-use bevy::reflect::Reflect;
+use bevy::{asset::AssetPath, reflect::Reflect};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -9,5 +9,8 @@ pub struct SkeletonSerial {
 
 #[derive(Clone, Reflect, Serialize, Deserialize)]
 pub enum SkeletonSource {
-    Gltf { source: String, label: String },
+    Gltf {
+        source: AssetPath<'static>,
+        label: String,
+    },
 }

crates/bevy_animation_graph_editor/src/ui/core.rs

@@ -22,6 +22,7 @@ use crate::ui::{
     native_windows::{NativeEditorWindow, NativeEditorWindowExtension},
     state_management::global::{
         GlobalState, clip::RequestCreateClip, fsm::RequestCreateFsm, ragdoll::RequestCreateRagdoll,
+        ragdoll_bone_map::RequestCreateRagdollBoneMap, skeleton::RequestCreateSkeleton,
     },
 };
 
@@ -145,18 +146,23 @@ fn menu_bar(ctx: &mut egui::Context, command_queue: &mut CommandQueue) {
         egui::MenuBar::new().ui(ui, |ui| {
             ui.menu_button("Assets", |ui| {
                 ui.menu_button("Create", |ui| {
-                    if ui.button("Skeleton").clicked() {}
+                    if ui.button("Skeleton").clicked() {
+                        command_queue.push(trigger(RequestCreateSkeleton));
+                    }
                     if ui.button("Animation").clicked() {
                         command_queue.push(trigger(RequestCreateClip));
                     }
-                    if ui.button("Animated scene").clicked() {}
                     if ui.button("State machine").clicked() {
                         command_queue.push(trigger(RequestCreateFsm));
                     }
                     if ui.button("Ragdoll").clicked() {
                         command_queue.push(trigger(RequestCreateRagdoll));
                     }
-                    if ui.button("Ragdoll bone map").clicked() {}
+                    if ui.button("Ragdoll bone map").clicked() {
+                        command_queue.push(trigger(RequestCreateRagdollBoneMap));
+                    }
+                    ui.disable();
+                    if ui.button("Animated scene").clicked() {}
                 });
             })
         });

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

@@ -3,3 +3,4 @@ pub mod fsm;
 pub mod generic_with_path;
 pub mod ragdoll;
 pub mod ragdoll_bone_map;
+pub mod skeleton;

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

@@ -0,0 +1,92 @@
+use bevy::{
+    asset::{AssetServer, Assets, Handle},
+    gltf::Gltf,
+    prelude::World,
+};
+use bevy_animation_graph::core::skeleton::serial::{SkeletonSerial, SkeletonSource};
+use egui_dock::egui;
+
+use crate::ui::{
+    generic_widgets::{popup_asset_picker::PopupAssetPicker, string_picker::StringPickerWidget},
+    native_windows::{EditorWindowContext, NativeEditorWindowExtension},
+    state_management::global::{CloseWindow, skeleton::CreateSkeleton},
+    utils::asset_path,
+};
+
+#[derive(Debug, Clone, Copy)]
+pub struct CreateSkeletonWindow;
+
+impl NativeEditorWindowExtension for CreateSkeletonWindow {
+    fn ui(&self, ui: &mut egui::Ui, world: &mut World, ctx: &mut EditorWindowContext) {
+        ui.push_id("Skeleton asset creator", |ui| {
+            let mut queue = ctx.make_queue();
+
+            let buffer_id = ui.id().with("buffer");
+            let buffer: &mut SkeletonCreateBuffer = ctx.buffers.get_mut_or_default(buffer_id);
+
+            ui.label("asset path:");
+            ui.text_edit_singleline(&mut buffer.path);
+
+            ui.label("GLTF file:");
+            ui.add(PopupAssetPicker::new_salted(
+                &mut buffer.gltf,
+                world,
+                "gtlf",
+            ));
+
+            // get gltf asset
+            let gltf_assets = world.resource::<Assets<Gltf>>();
+            let labels: Vec<String> = gltf_assets
+                .get(&buffer.gltf)
+                .map(|gltf| {
+                    (0..gltf.scenes.len())
+                        .map(|k| format!("Scene{}", k))
+                        .collect()
+                })
+                .unwrap_or_default();
+
+            ui.label("Scene label:");
+            ui.add(
+                StringPickerWidget::new(&mut buffer.label, &labels).salted("scene label picker"),
+            );
+
+            let asset_server = world.resource::<AssetServer>();
+
+            ui.add_enabled_ui(validate_buffer(buffer), |ui| {
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Max), |ui| {
+                    if ui.button("Create").clicked() {
+                        queue.trigger(CreateSkeleton {
+                            virtual_path: buffer.path.clone(),
+                            skeleton: SkeletonSerial {
+                                source: SkeletonSource::Gltf {
+                                    source: asset_path(buffer.gltf.id().untyped(), asset_server),
+                                    label: buffer.label.clone(),
+                                },
+                            },
+                        });
+                        queue.trigger_window(CloseWindow::default());
+                    }
+                });
+            });
+
+            ctx.consume_queue(queue);
+        });
+    }
+
+    fn display_name(&self) -> String {
+        "Create skeleton".to_string()
+    }
+}
+
+fn validate_buffer(buffer: &SkeletonCreateBuffer) -> bool {
+    buffer.gltf != Handle::default()
+        && !buffer.label.is_empty()
+        && buffer.path.ends_with(".skn.ron")
+}
+
+#[derive(Default)]
+pub struct SkeletonCreateBuffer {
+    path: String,
+    gltf: Handle<Gltf>,
+    label: String,
+}

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

@@ -12,6 +12,7 @@ pub mod fsm;
 pub mod inspector_selection;
 pub mod ragdoll;
 pub mod ragdoll_bone_map;
+pub mod skeleton;
 
 use std::marker::PhantomData;
 
@@ -32,7 +33,7 @@ use crate::ui::state_management::global::{
     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,
+    ragdoll::RagdollManager, ragdoll_bone_map::RagdollBoneMapManager, skeleton::SkeletonManager,
 };
 
 #[derive(Component)]
@@ -56,6 +57,7 @@ impl GlobalState {
         ClipManager::register(world, entity);
         RagdollManager::register(world, entity);
         RagdollBoneMapManager::register(world, entity);
+        SkeletonManager::register(world, entity);
 
         world.add_observer(CloseWindow::observe);
     }

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

@@ -0,0 +1,77 @@
+use bevy::ecs::{
+    component::Component,
+    entity::Entity,
+    event::Event,
+    observer::On,
+    system::{Commands, Res, ResMut},
+    world::World,
+};
+use bevy_animation_graph::core::skeleton::serial::SkeletonSerial;
+
+use crate::{
+    Cli,
+    scanner::RescanAssets,
+    ui::{
+        UiState,
+        core::EguiWindow,
+        native_windows::{NativeEditorWindow, asset_creation::skeleton::CreateSkeletonWindow},
+        state_management::global::RegisterStateComponent,
+    },
+};
+
+#[derive(Debug, Component, Default, Clone)]
+pub struct SkeletonManager;
+
+impl RegisterStateComponent for SkeletonManager {
+    fn register(world: &mut World, _global_state_entity: Entity) {
+        world.add_observer(RequestCreateSkeleton::observe);
+        world.add_observer(CreateSkeleton::observe);
+    }
+}
+
+/// Will open a "create FSM" window popup
+#[derive(Event)]
+pub struct RequestCreateSkeleton;
+
+impl RequestCreateSkeleton {
+    pub fn observe(
+        _: On<RequestCreateSkeleton>,
+        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, CreateSkeletonWindow);
+
+            let UiState { views, .. } = ui_state.into_inner();
+
+            views[active_view_idx]
+                .dock_state
+                .add_window(vec![EguiWindow::EntityWindow(win)]);
+        }
+    }
+}
+
+#[derive(Event)]
+pub struct CreateSkeleton {
+    pub virtual_path: String,
+    pub skeleton: SkeletonSerial,
+}
+
+impl CreateSkeleton {
+    pub fn observe(event: On<CreateSkeleton>, cli: Res<Cli>, mut commands: Commands) {
+        let mut final_path = cli.asset_source.clone();
+        final_path.push(&event.virtual_path);
+        bevy::log::info!("Creating skeleton at {:?}", final_path);
+        ron::Options::default()
+            .to_io_writer_pretty(
+                std::fs::File::create(final_path).unwrap(),
+                &event.skeleton,
+                ron::ser::PrettyConfig::default(),
+            )
+            .unwrap();
+
+        commands.trigger(RescanAssets);
+    }
+}