symmetry for colliders and bodies

Author: mbrea-c

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

@@ -8,13 +8,16 @@ use bevy::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::core::colliders::core::ColliderShape;
+use crate::{core::colliders::core::ColliderShape, prelude::config::SymmertryMode};
 
 #[derive(Asset, Debug, Clone, Reflect, Serialize, Deserialize)]
 pub struct Ragdoll {
     pub bodies: HashMap<BodyId, Body>,
     pub colliders: HashMap<ColliderId, Collider>,
     pub joints: HashMap<JointId, Joint>,
+
+    #[serde(default)]
+    pub suffixes: SymmetrySuffixes,
 }
 
 impl Ragdoll {
@@ -54,11 +57,39 @@ impl Ragdoll {
         self.bodies.values()
     }
 
+    pub fn iter_bodies_mut(&mut self) -> impl Iterator<Item = &mut Body> {
+        self.bodies.values_mut()
+    }
+
+    pub fn iter_body_ids(&self) -> impl Iterator<Item = BodyId> {
+        self.bodies.keys().copied()
+    }
+
+    pub fn iter_colliders(&self) -> impl Iterator<Item = &Collider> {
+        self.colliders.values()
+    }
+
     pub fn iter_joints(&self) -> impl Iterator<Item = &Joint> {
         self.joints.values()
     }
 }
 
+/// Determines which suffixes to apply to labels of elements that make use of symmetry
+#[derive(Debug, Clone, Reflect, Serialize, Deserialize)]
+pub struct SymmetrySuffixes {
+    pub original: String,
+    pub mirror: String,
+}
+
+impl Default for SymmetrySuffixes {
+    fn default() -> Self {
+        Self {
+            original: ".R".into(),
+            mirror: ".L".into(),
+        }
+    }
+}
+
 #[derive(Reflect, Debug, Clone, Serialize, Deserialize)]
 pub struct Body {
     pub id: BodyId,
@@ -67,6 +98,13 @@ pub struct Body {
     pub isometry: Isometry3d,
     pub colliders: Vec<ColliderId>,
     pub default_mode: BodyMode,
+
+    #[serde(default)]
+    pub use_symmetry: bool,
+    /// If symmetry is enabled and this body was created as the image under the symmetry of another
+    /// body, which body is it?
+    #[serde(default)]
+    pub created_from: Option<BodyId>,
 }
 
 impl Body {
@@ -79,8 +117,39 @@ impl Body {
             isometry: default(),
             colliders: default(),
             default_mode: BodyMode::Kinematic,
+
+            use_symmetry: false,
+            created_from: None,
         }
     }
+
+    pub fn mirror_onto(
+        &self,
+        target: &mut Self,
+        suffixes: &SymmetrySuffixes,
+        mode: &SymmertryMode,
+    ) {
+        let original_label = self
+            .label
+            .strip_suffix(&suffixes.original)
+            .unwrap_or(&self.label)
+            .to_owned();
+
+        let mirrored_label = format!("{}{}", original_label, suffixes.mirror);
+        target.label = mirrored_label;
+
+        let mirrored_isometry = Isometry3d {
+            rotation: mode.apply_quat(self.isometry.rotation),
+            translation: mode.apply_position(self.isometry.translation.into()).into(),
+        };
+        target.isometry = mirrored_isometry;
+
+        todo!("What do we do about colliders?");
+
+        target.default_mode = self.default_mode;
+        target.use_symmetry = false;
+        target.created_from = Some(self.id);
+    }
 }
 
 #[derive(Reflect, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -100,6 +169,10 @@ pub struct Collider {
     pub override_layers: bool,
     /// Label that will be attached to the created collider in a [`ColliderLabel`] component.
     pub label: String,
+    /// If symmetry is enabled and this body was created as the image under the symmetry of another
+    /// body, which body is it?
+    #[serde(default)]
+    pub created_from: Option<ColliderId>,
 }
 
 impl Collider {
@@ -114,6 +187,7 @@ impl Collider {
             layer_filter: 1,
             override_layers: false,
             label: "New collider".into(),
+            created_from: None,
         }
     }
 }

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

@@ -13,6 +13,8 @@ use bevy_animation_graph::{
     prelude::{AnimatedScene, AnimationGraph, AnimationNode, DataSpec, GraphClip},
 };
 
+use crate::ui::actions::ActionContext;
+
 use super::{DynamicAction, run_handler};
 
 #[derive(Resource, Default)]
@@ -42,7 +44,7 @@ pub struct CreateClipPreview {
 }
 
 impl DynamicAction for CreateClipPreview {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not create clip preview")(Self::system, *self)
     }
 }
@@ -97,7 +99,7 @@ pub struct CreateTrackNodePreview {
 }
 
 impl DynamicAction for CreateTrackNodePreview {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not create clip preview")(Self::system, *self)
     }
 }

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

@@ -13,15 +13,15 @@ use bevy_animation_graph::{
     prelude::config::SymmetryConfig,
 };
 
-use crate::ui::actions::{DynamicAction, run_handler, saving::DirtyAssets};
+use crate::ui::actions::{ActionContext, DynamicAction, run_handler, saving::DirtyAssets};
 
 pub struct CreateOrEditCollider {
     pub colliders: Handle<SkeletonColliders>,
     pub config: ColliderConfig,
 }
 
 impl DynamicAction for CreateOrEditCollider {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not create collider")(Self::system, *self)
     }
 }
@@ -56,7 +56,7 @@ pub struct DeleteCollider {
 }
 
 impl DynamicAction for DeleteCollider {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not create collider")(Self::system, *self)
     }
 }
@@ -83,7 +83,7 @@ pub struct UpdateSymmetryConfig {
 }
 
 impl DynamicAction for UpdateSymmetryConfig {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not update symmetry config")(Self::system, *self)
     }
 }
@@ -109,7 +109,7 @@ pub struct UpdateSymmetryEnabled {
 }
 
 impl DynamicAction for UpdateSymmetryEnabled {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not update symmetry config")(Self::system, *self)
     }
 }
@@ -136,7 +136,7 @@ pub struct UpdateDefaultLayers {
 }
 
 impl DynamicAction for UpdateDefaultLayers {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not update default physics layers config")(Self::system, *self)
     }
 }
@@ -164,7 +164,7 @@ pub struct UpdateSuffixes {
 }
 
 impl DynamicAction for UpdateSuffixes {
-    fn handle(self: Box<Self>, world: &mut World) {
+    fn handle(self: Box<Self>, world: &mut World, _: &mut ActionContext) {
         run_handler(world, "Could not update suffixes config")(Self::system, *self)
     }
 }

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

@@ -19,7 +19,7 @@ use bevy_animation_graph::{
 
 use crate::{
     graph_show::{GraphIndicesMap, make_graph_indices},
-    ui::egui_inspector_impls::OrderedMap,
+    ui::{actions::ActionContext, egui_inspector_impls::OrderedMap},
 };
 
 use super::{DynamicAction, run_handler, saving::DirtyAssets};
@@ -398,7 +398,7 @@ impl GraphAndContext<'_> {
 pub struct CreateGraphAction;
 
 impl DynamicAction for CreateGraphAction {
-    fn handle(self: Box<Self>, world: &mut World) {
+    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>>,

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

@@ -12,7 +12,7 @@ pub mod ragdoll;
 pub mod saving;
 pub mod window;
 
-use std::{any::Any, cmp::Ordering, fmt::Display};
+use std::{any::Any, cmp::Ordering, collections::VecDeque, fmt::Display};
 
 use bevy::{
     ecs::{
@@ -40,18 +40,26 @@ pub struct PendingActions {
     pub actions: PushQueue<EditorAction>,
 }
 
+#[derive(Default)]
+pub struct ActionContext {
+    /// Queue further actions.
+    ///
+    /// Be careful not to create an inifinite loop
+    actions: PushQueue<EditorAction>,
+}
+
 /// A "push-only" queue
-pub struct PushQueue<T>(Vec<T>);
+pub struct PushQueue<T>(VecDeque<T>);
 
 impl<T> Default for PushQueue<T> {
     fn default() -> Self {
-        Self(Vec::new())
+        Self(VecDeque::new())
     }
 }
 
 impl<T> PushQueue<T> {
     pub fn push(&mut self, item: T) {
-        self.0.push(item);
+        self.0.push_back(item);
     }
 }
 
@@ -65,12 +73,17 @@ pub enum EditorAction {
 }
 
 pub fn handle_editor_action_queue(world: &mut World, actions: impl Iterator<Item = EditorAction>) {
+    let mut ctx = ActionContext::default();
     for action in actions {
-        handle_editor_action(world, action);
+        handle_editor_action(world, action, &mut ctx);
+    }
+
+    while let Some(action) = ctx.actions.0.pop_front() {
+        handle_editor_action(world, action, &mut ctx);
     }
 }
 
-pub fn handle_editor_action(world: &mut World, action: EditorAction) {
+pub fn handle_editor_action(world: &mut World, action: EditorAction, ctx: &mut ActionContext) {
     match action {
         EditorAction::View(action) => {
             if let Err(err) = world.run_system_cached_with(handle_view_action, action) {
@@ -81,7 +94,7 @@ pub fn handle_editor_action(world: &mut World, action: EditorAction) {
         EditorAction::EventTrack(action) => handle_event_track_action(world, action),
         EditorAction::Graph(action) => handle_graph_action(world, action),
         EditorAction::Fsm(action) => handle_fsm_action(world, action),
-        EditorAction::Dynamic(action) => action.handle(world),
+        EditorAction::Dynamic(action) => action.handle(world, ctx),
     }
 }
 
@@ -147,5 +160,5 @@ where
 }
 
 pub trait DynamicAction: Send + Sync + 'static {
-    fn handle(self: Box<Self>, world: &mut World);
+    fn handle(self: Box<Self>, world: &mut World, ctx: &mut ActionContext);
 }