progress with editor

Author: mbrea-c

crates/bevy_animation_graph/src/core/animation_graph_player.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use super::{
     animation_graph::{AnimationGraph, DEFAULT_OUTPUT_POSE, InputOverlay, PinId, TimeUpdate},
     context::{DeferredGizmos, PassContext},
@@ -9,14 +11,16 @@ use super::{
 };
 use crate::{
     core::ragdoll::{bone_mapping::RagdollBoneMap, definition::Ragdoll, spawning::SpawnedRagdoll},
-    prelude::{CustomRelativeDrawCommand, SystemResources},
+    prelude::{CustomRelativeDrawCommand, CustomRelativeDrawCommandReference, SystemResources},
 };
 use bevy::{
     asset::prelude::*,
     color::{Color, palettes::css::WHITE},
     ecs::prelude::*,
+    gizmos::gizmos::Gizmos,
     platform::collections::HashMap,
     reflect::prelude::*,
+    transform::components::Transform,
 };
 
 #[derive(Default, Reflect, Clone, Copy)]
@@ -227,6 +231,16 @@ impl AnimationGraphPlayer {
         self.debug_draw_custom.push(gizmo);
     }
 
+    pub fn gizmo_relative_to_root(
+        &mut self,
+        f: impl Fn(Transform, &mut Gizmos) + Send + Sync + 'static,
+    ) {
+        self.debug_draw_custom.push(CustomRelativeDrawCommand {
+            reference: CustomRelativeDrawCommandReference::Root,
+            f: Arc::new(f),
+        });
+    }
+
     pub(crate) fn debug_draw_bones(
         &mut self,
         system_resources: &SystemResources,

crates/bevy_animation_graph/src/core/context/deferred_gizmos.rs

@@ -74,8 +74,13 @@ impl DeferredGizmos {
     }
 }
 
+pub enum CustomRelativeDrawCommandReference {
+    Root,
+    Bone(BoneId),
+}
+
 pub struct CustomRelativeDrawCommand {
-    pub bone_id: BoneId,
+    pub reference: CustomRelativeDrawCommandReference,
     #[allow(clippy::type_complexity)]
     pub f: Arc<dyn Fn(Transform, &mut Gizmos) + Send + Sync + 'static>,
 }
@@ -203,9 +208,17 @@ impl DeferredGizmosContext<'_> {
         let default_pose = Pose::default();
         let pose = pose.unwrap_or(&default_pose);
 
-        let global_bone_transform =
-            self.space_conversion
-                .global_transform_of_bone(pose, skeleton, command.bone_id);
+        let global_bone_transform = match command.reference {
+            CustomRelativeDrawCommandReference::Root => self
+                .space_conversion
+                .pose_fallback
+                .root_global_transform(skeleton)
+                .unwrap()
+                .compute_transform(),
+            CustomRelativeDrawCommandReference::Bone(bone_id) => self
+                .space_conversion
+                .global_transform_of_bone(pose, skeleton, bone_id),
+        };
 
         self.gizmos
             .queue(DeferredGizmoCommand::Custom(Arc::new(move |gizmos| {

crates/bevy_animation_graph/src/core/context/mod.rs

@@ -6,7 +6,10 @@ mod pose_fallback;
 mod spec_context;
 mod system_resources;
 
-pub use deferred_gizmos::{CustomRelativeDrawCommand, DeferredGizmos, DeferredGizmosContext};
+pub use deferred_gizmos::{
+    CustomRelativeDrawCommand, CustomRelativeDrawCommandReference, DeferredGizmos,
+    DeferredGizmosContext,
+};
 pub use graph_context::{CacheReadFilter, CacheWriteFilter, GraphContext};
 pub use graph_context_arena::{GraphContextArena, GraphContextId};
 pub use pass_context::{FsmContext, PassContext, StateRole, StateStack};

crates/bevy_animation_graph/src/core/ragdoll/definition.rs

@@ -20,6 +20,10 @@ impl Ragdoll {
         self.bodies.iter().find(|b| b.id == id)
     }
 
+    pub fn get_body_mut(&mut self, id: BodyId) -> Option<&mut Body> {
+        self.bodies.iter_mut().find(|b| b.id == id)
+    }
+
     pub fn get_collider(&self, id: ColliderId) -> Option<&Collider> {
         self.bodies
             .iter()

crates/bevy_animation_graph_editor/src/tree.rs

@@ -6,8 +6,6 @@ use bevy_animation_graph::core::{
 };
 use egui::Sense;
 
-use crate::{icons, ui::utils::collapsing::Collapser};
-
 pub struct Tree<I, L>(pub Vec<TreeInternal<I, L>>);
 impl<I, T> Default for Tree<I, T> {
     fn default() -> Self {
@@ -355,83 +353,3 @@ impl Tree<RagdollNode, RagdollNode> {
         TreeInternal::Leaf(format!("{:?}", joint.id), RagdollNode::Joint(joint_id))
     }
 }
-
-#[derive(Clone, Copy)]
-pub struct RagdollTreeRenderer {}
-
-impl RagdollTreeRenderer {}
-
-pub struct RagdollResponse {
-    pub hovered: Option<RagdollNode>,
-    pub clicked: Option<RagdollNode>,
-}
-
-impl TreeResponse for RagdollResponse {
-    fn combine(&self, other: &Self) -> Self {
-        RagdollResponse {
-            hovered: self.hovered.or(other.hovered),
-            clicked: self.clicked.or(other.clicked),
-        }
-    }
-}
-
-impl TreeRenderer<RagdollNode, RagdollNode, RagdollResponse> for RagdollTreeRenderer {
-    fn render_inner(
-        &self,
-        label: &str,
-        data: &RagdollNode,
-        children: &[TreeInternal<RagdollNode, RagdollNode>],
-        ui: &mut egui::Ui,
-        render_child: impl Fn(
-            &TreeInternal<RagdollNode, RagdollNode>,
-            &mut egui::Ui,
-        ) -> TreeResult<RagdollNode, RagdollNode, RagdollResponse>,
-    ) -> TreeResult<RagdollNode, RagdollNode, RagdollResponse> {
-        let collapsing_response = Collapser::new()
-            .with_default_open(true)
-            .with_id_salt(data)
-            .show(
-                ui,
-                |ui| self.render_leaf(label, data, ui),
-                |ui| {
-                    children
-                        .iter()
-                        .map(|c| render_child(c, ui))
-                        .reduce(|l, r| l.or(r))
-                        .unwrap_or_default()
-                },
-            );
-
-        collapsing_response
-            .head
-            .or(collapsing_response.body.unwrap_or_default())
-    }
-
-    fn render_leaf(
-        &self,
-        label: &str,
-        data: &RagdollNode,
-        ui: &mut egui::Ui,
-    ) -> TreeResult<RagdollNode, RagdollNode, RagdollResponse> {
-        let response = ui
-            .horizontal(|ui| {
-                let image = match data {
-                    RagdollNode::Body(_) => icons::BONE,
-                    RagdollNode::Collider(_) => icons::BOX,
-                    RagdollNode::Joint(_) => icons::JOINT,
-                };
-                let color = ui.visuals().text_color();
-                ui.add(egui::Image::new(image).tint(color).sense(Sense::click()))
-                    | ui.add(egui::Label::new(label).sense(Sense::click()))
-            })
-            .inner;
-
-        TreeResult::Leaf(
-            data.clone(),
-            RagdollResponse {
-                hovered: response.hovered().then_some(*data),
-                clicked: response.clicked().then_some(*data),
-            },
-        )
-    }
-}

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

@@ -8,6 +8,7 @@ pub mod colliders;
 pub mod event_tracks;
 pub mod fsm;
 pub mod graph;
+pub mod ragdoll;
 pub mod saving;
 pub mod window;
 

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

@@ -0,0 +1,39 @@
+use bevy::{
+    asset::{Assets, Handle},
+    ecs::{
+        system::{In, ResMut},
+        world::World,
+    },
+};
+use bevy_animation_graph::core::ragdoll::definition::{Body, Ragdoll};
+
+use crate::ui::actions::{DynamicAction, run_handler, saving::DirtyAssets};
+
+pub struct EditRagdollBody {
+    pub ragdoll: Handle<Ragdoll>,
+    pub body: Body,
+}
+
+impl DynamicAction for EditRagdollBody {
+    fn handle(self: Box<Self>, world: &mut World) {
+        run_handler(world, "Could not edit body")(Self::system, *self)
+    }
+}
+
+impl EditRagdollBody {
+    pub fn system(
+        In(input): In<Self>,
+        mut ragdoll_assets: ResMut<Assets<Ragdoll>>,
+        mut dirty_assets: ResMut<DirtyAssets>,
+    ) {
+        let Some(ragdoll) = ragdoll_assets.get_mut(&input.ragdoll) else {
+            return;
+        };
+
+        dirty_assets.add(input.ragdoll);
+
+        if let Some(body) = ragdoll.get_body_mut(input.body.id) {
+            *body = input.body.clone()
+        }
+    }
+}