wip: basic example works

ActuallyHappening · jakobhellermann · commit 8409e5cde08d · 2024-08-11T11:42:09.000+02:00
but a bit buggy
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,14 +11,15 @@ description = "In-App editor tools for bevy apps"
 readme = "README.md"
 
 [workspace.dependencies]
-bevy_editor_pls = { version = "0.8.0", path = "crates/bevy_editor_pls" }
-bevy_editor_pls_core = { version = "0.8.0", path = "crates/bevy_editor_pls_core" }
-bevy_editor_pls_default_windows = { version = "0.8.0", path = "crates/bevy_editor_pls_default_windows" }
+bevy_editor_pls = { version = "0.8.1", path = "crates/bevy_editor_pls" }
+bevy_editor_pls_core = { version = "0.8.1", path = "crates/bevy_editor_pls_core" }
+bevy_editor_pls_default_windows = { version = "0.8.1", path = "crates/bevy_editor_pls_default_windows" }
 
-bevy-inspector-egui = "0.23.0"
-egui = "0.26"
-egui_dock = "0.11"
-egui-gizmo = "0.16"
+bevy-inspector-egui = "0.24.0"
+egui = "0.27"
+egui_dock = "0.12"
+# used to be egui-gizmo 0.16
+transform-gizmo-bevy = "0.2"
 
 [profile.dev.package."*"]
 opt-level = 2
diff --git a/crates/bevy_editor_pls/Cargo.toml b/crates/bevy_editor_pls/Cargo.toml
@@ -24,7 +24,7 @@ bevy_editor_pls_core.workspace = true
 bevy_editor_pls_default_windows = { workspace = true, optional = true }
 bevy = { version = "0.13", default-features = false, features = ["x11"] }
 egui.workspace = true
-egui-gizmo.workspace = true
+transform-gizmo-bevy.workspace = true
 # bevy_framepace = { version = "0.12", default-features = false }
 
 [dev-dependencies]
diff --git a/crates/bevy_editor_pls/examples/basic.rs b/crates/bevy_editor_pls/examples/basic.rs
@@ -47,7 +47,7 @@ fn setup(
         material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
         transform: Transform::from_xyz(0.0, 0.5, 0.0),
         ..Default::default()
-    });
+    }).insert(transform_gizmo_bevy::GizmoTarget::default());
     // light
     commands.spawn(PointLightBundle {
         transform: Transform::from_xyz(4.0, 8.0, 4.0),
@@ -61,5 +61,5 @@ fn setup(
     commands.spawn(Camera3dBundle {
         transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
         ..Default::default()
-    });
+    }).insert(transform_gizmo_bevy::GizmoCamera);
 }
diff --git a/crates/bevy_editor_pls/src/controls.rs b/crates/bevy_editor_pls/src/controls.rs
@@ -240,7 +240,7 @@ pub fn editor_controls_system(
             editor
                 .window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()
                 .unwrap()
-                .gizmo_mode = egui_gizmo::GizmoMode::Translate;
+                .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_translate();
         }
         if controls.just_pressed(
             Action::SetGizmoModeRotate,
@@ -251,7 +251,7 @@ pub fn editor_controls_system(
             editor
                 .window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()
                 .unwrap()
-                .gizmo_mode = egui_gizmo::GizmoMode::Rotate;
+                .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_rotate();
         }
         if controls.just_pressed(
             Action::SetGizmoModeScale,
@@ -262,7 +262,7 @@ pub fn editor_controls_system(
             editor
                 .window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()
                 .unwrap()
-                .gizmo_mode = egui_gizmo::GizmoMode::Scale;
+                .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_scale();
         }
     }
 }
diff --git a/crates/bevy_editor_pls/src/lib.rs b/crates/bevy_editor_pls/src/lib.rs
@@ -128,6 +128,11 @@ impl Plugin for EditorPlugin {
 
             app.add_plugins(bevy::pbr::wireframe::WireframePlugin);
 
+						// required for the GizmoWindow
+            if !app.is_plugin_added::<transform_gizmo_bevy::TransformGizmoPlugin>() {
+                app.add_plugins(transform_gizmo_bevy::TransformGizmoPlugin);
+            }
+
             app.insert_resource(controls::EditorControls::default_bindings())
                 .add_systems(Update, controls::editor_controls_system);
 
diff --git a/crates/bevy_editor_pls_default_windows/Cargo.toml b/crates/bevy_editor_pls_default_windows/Cargo.toml
@@ -31,4 +31,4 @@ indexmap = "2"
 pretty-type-name = "1.0"
 bevy_mod_debugdump = "0.10"
 opener = "0.6.0"
-egui-gizmo.workspace = true
+transform-gizmo-bevy.workspace = true
diff --git a/crates/bevy_editor_pls_default_windows/src/cameras/mod.rs b/crates/bevy_editor_pls_default_windows/src/cameras/mod.rs
@@ -13,6 +13,7 @@ use bevy_editor_pls_core::{
     Editor, EditorEvent,
 };
 use bevy_inspector_egui::egui;
+use transform_gizmo_bevy::GizmoCamera;
 // use bevy_mod_picking::prelude::PickRaycastSource;
 
 use crate::hierarchy::{HideInEditor, HierarchyWindow};
@@ -28,6 +29,9 @@ pub struct EditorCamera;
 // Present only one the one currently active camera
 #[derive(Component)]
 pub struct ActiveEditorCamera;
+// /// Changed to a type alias to guarentee being in sync with the GizmoCamera component,
+// /// this should be considered a 'hack' that maybe should be fixed down the line
+// pub type ActiveEditorCamera = transform_gizmo_bevy::GizmoCamera;
 
 // Marker component for the 3d free camera
 #[derive(Component)]
@@ -168,7 +172,7 @@ fn set_active_editor_camera_marker(world: &mut World, editor_cam: EditorCamKind)
             state.iter(world).next().unwrap()
         }
     };
-    world.entity_mut(entity).insert(ActiveEditorCamera);
+    world.entity_mut(entity).insert(ActiveEditorCamera {});
 }
 
 fn cameras_ui(ui: &mut egui::Ui, world: &mut World) {
@@ -232,6 +236,7 @@ fn spawn_editor_cameras(mut commands: Commands, editor: Res<Editor>) {
         HideInEditor,
         Name::new("Editor Camera 3D Free"),
         NotInScene,
+        GizmoCamera,
         render_layers,
     ));
 
@@ -254,6 +259,7 @@ fn spawn_editor_cameras(mut commands: Commands, editor: Res<Editor>) {
         HideInEditor,
         Name::new("Editor Camera 3D Pan/Orbit"),
         NotInScene,
+        GizmoCamera,
         render_layers,
     ));
 
@@ -275,6 +281,7 @@ fn spawn_editor_cameras(mut commands: Commands, editor: Res<Editor>) {
         HideInEditor,
         Name::new("Editor Camera 2D Pan/Zoom"),
         NotInScene,
+        GizmoCamera,
         render_layers,
     ));
 }
@@ -496,21 +503,21 @@ fn initial_camera_setup(
                 camera_state.editor_cam = EditorCamKind::D2PanZoom;
                 commands
                     .entity(cameras.p0().single().0)
-                    .insert(ActiveEditorCamera);
+                    .insert(ActiveEditorCamera {});
                 *has_decided_initial_cam = true;
             }
             (false, true) => {
                 camera_state.editor_cam = EditorCamKind::D3PanOrbit;
                 commands
                     .entity(cameras.p2().single().0)
-                    .insert(ActiveEditorCamera);
+                    .insert(ActiveEditorCamera {});
                 *has_decided_initial_cam = true;
             }
             (true, true) => {
                 camera_state.editor_cam = EditorCamKind::D3PanOrbit;
                 commands
                     .entity(cameras.p2().single().0)
-                    .insert(ActiveEditorCamera);
+                    .insert(ActiveEditorCamera {});
                 *has_decided_initial_cam = true;
             }
             (false, false) => return,
diff --git a/crates/bevy_editor_pls_default_windows/src/gizmos.rs b/crates/bevy_editor_pls_default_windows/src/gizmos.rs
@@ -1,12 +1,13 @@
 use bevy::{
-    ecs::query::QueryFilter,
+    ecs::{query::QueryFilter, system::RunSystemOnce},
     prelude::*,
     render::{camera::CameraProjection, view::RenderLayers},
 };
 
 use bevy_editor_pls_core::editor_window::{EditorWindow, EditorWindowContext};
 use bevy_inspector_egui::{bevy_inspector::hierarchy::SelectedEntities, egui};
-use egui_gizmo::GizmoMode;
+use transform_gizmo_bevy::{EnumSet, GizmoMode};
+use transform_gizmo_bevy::GizmoTarget;
 
 use crate::{
     cameras::{ActiveEditorCamera, CameraWindow, EditorCamera, EDITOR_RENDER_LAYER},
@@ -15,14 +16,15 @@ use crate::{
 
 pub struct GizmoState {
     pub camera_gizmo_active: bool,
-    pub gizmo_mode: GizmoMode,
+		/// TODO: Take these settings into account
+    pub gizmo_mode: EnumSet<GizmoMode>,
 }
 
 impl Default for GizmoState {
     fn default() -> Self {
         Self {
             camera_gizmo_active: true,
-            gizmo_mode: GizmoMode::Translate,
+            gizmo_mode: GizmoMode::all_translate(),
         }
     }
 }
@@ -42,10 +44,62 @@ impl EditorWindow for GizmoWindow {
         let gizmo_state = cx.state::<GizmoWindow>().unwrap();
 
         if gizmo_state.camera_gizmo_active {
-            if let (Some(hierarchy_state), Some(_camera_state)) =
-                (cx.state::<HierarchyWindow>(), cx.state::<CameraWindow>())
-            {
-                draw_gizmo(ui, world, &hierarchy_state.selected, gizmo_state.gizmo_mode);
+            // if let (Some(hierarchy_state), Some(_camera_state)) =
+            //     (cx.state::<HierarchyWindow>(), cx.state::<CameraWindow>())
+            // {
+            //     draw_gizmo(ui, world, &hierarchy_state.selected, gizmo_state.gizmo_mode);
+            // }
+
+            /// Before [hydrate_gizmos] and [deconstruct_gizmos] are run, this system resets the state of all entities that have a [EntityShouldShowGizmo] component.
+            /// Then, according to selection logic some entities are marked as focussed, and [hydrate_gizmos] and [deconstruct_gizmos] is run to sync the gizmo state with the selection state.
+            fn reset_gizmos_selected_state(
+                mut commands: Commands,
+                entities: Query<Entity, With<EntityShouldShowGizmo>>,
+            ) {
+                for entity in entities.iter() {
+                    commands.entity(entity).remove::<EntityShouldShowGizmo>();
+                }
+            }
+
+            /// Takes all entities marked with [EntityShouldShowGizmo] and adds the [GizmoTarget] component to them.
+            fn hydrate_gizmos(
+                mut commands: Commands,
+                entities: Query<Entity, (With<EntityShouldShowGizmo>, Without<GizmoTarget>)>,
+            ) {
+                for entity in entities.iter() {
+                    trace!("Hydrating a gizmo on entity {:?} because it is selected", entity);
+                    // TODO: Maybe change the exact gizmo target instance instead of using default? should this load from some config?
+                    commands.entity(entity).insert(GizmoTarget::default());
+                }
+            }
+
+            /// Takes all entities that should have their [GizmoTarget] removed because they are no longer selected.
+            fn deconstruct_gizmos(
+                mut commands: Commands,
+                entities: Query<Entity, (With<GizmoTarget>, Without<EntityShouldShowGizmo>)>,
+            ) {
+                for entity in entities.iter() {
+                    commands.entity(entity).remove::<GizmoTarget>();
+                    debug!(
+                        "Removing GizmoTarget from entity {:?} because it has lost focus",
+                        entity
+                    );
+                }
+            }
+
+            if let Some(hierarchy_state) = cx.state::<HierarchyWindow>() {
+                // here should assign the `EntityShouldShowGizmo` component, which is later synced
+                // with the actual gizmo ui system
+
+                world.run_system_once(reset_gizmos_selected_state);
+
+                let selected_entities = hierarchy_state.selected.iter();
+                for entity in selected_entities {
+                    world.entity_mut(entity).insert(EntityShouldShowGizmo);
+                }
+
+                world.run_system_once(hydrate_gizmos);
+                world.run_system_once(deconstruct_gizmos);
             }
         }
     }
@@ -93,9 +147,15 @@ struct GizmoMarkerConfig {
     camera_material: Handle<StandardMaterial>,
 }
 
+/// can somebody document what this does? is it a duplicate of [EntityShouldShowGizmo]?
 #[derive(Component)]
 struct HasGizmoMarker;
 
+/// When on an entity, this entity should be controllable using some sort of user gizmo.
+/// Currently uses [transform_gizmo_bevy], and puts the [GizmoTarget] on the entity.
+#[derive(Component)]
+struct EntityShouldShowGizmo;
+
 type GizmoMarkerQuery<'w, 's, T, F = ()> =
     Query<'w, 's, Entity, (With<T>, Without<HasGizmoMarker>, F)>;
 
@@ -166,55 +226,59 @@ fn add_gizmo_markers(
     }
 }
 
-fn draw_gizmo(
-    ui: &mut egui::Ui,
-    world: &mut World,
-    selected_entities: &SelectedEntities,
-    gizmo_mode: GizmoMode,
-) {
-    let Ok((cam_transform, projection)) = world
-        .query_filtered::<(&GlobalTransform, &Projection), With<ActiveEditorCamera>>()
-        .get_single(world)
-    else {
-        return;
-    };
-    let view_matrix = Mat4::from(cam_transform.affine().inverse());
-    let projection_matrix = projection.get_projection_matrix();
-
-    if selected_entities.len() != 1 {
-        return;
-    }
+// fn draw_gizmo(
+//     ui: &mut egui::Ui,
+//     world: &mut World,
+//     selected_entities: &SelectedEntities,
+//     gizmo_mode: GizmoMode,
+// ) {
+// 		for entity in selected_entities.iter() {
+// 			world.entity_mut(entity).insert(transform_gizmo_bevy::GizmoTarget::default());
+// 			info!("Inserted GizmoTarget to entity: {:?}", entity);
+// 		}
+//     // let Ok((cam_transform, projection)) = world
+//     //     .query_filtered::<(&GlobalTransform, &Projection), With<ActiveEditorCamera>>()
+//     //     .get_single(world)
+//     // else {
+//     //     return;
+//     // };
+//     // let view_matrix = Mat4::from(cam_transform.affine().inverse());
+//     // let projection_matrix = projection.get_projection_matrix();
 
-    for selected in selected_entities.iter() {
-        let Some(global_transform) = world.get::<GlobalTransform>(selected) else {
-            continue;
-        };
-        let model_matrix = global_transform.compute_matrix();
-
-        let Some(result) = egui_gizmo::Gizmo::new(selected)
-            .model_matrix(model_matrix.into())
-            .view_matrix(view_matrix.into())
-            .projection_matrix(projection_matrix.into())
-            .orientation(egui_gizmo::GizmoOrientation::Local)
-            .mode(gizmo_mode)
-            .interact(ui)
-        else {
-            continue;
-        };
-
-        let global_affine = global_transform.affine();
-
-        let mut transform = world.get_mut::<Transform>(selected).unwrap();
-
-        let parent_affine = global_affine * transform.compute_affine().inverse();
-        let inverse_parent_transform = GlobalTransform::from(parent_affine.inverse());
-
-        let global_transform = Transform {
-            translation: result.translation.into(),
-            rotation: result.rotation.into(),
-            scale: result.scale.into(),
-        };
-
-        *transform = (inverse_parent_transform * global_transform).into();
-    }
-}
+//     // if selected_entities.len() != 1 {
+//     //     return;
+//     // }
+
+//     // for selected in selected_entities.iter() {
+//     //     // let Some(global_transform) = world.get::<GlobalTransform>(selected) else {
+//     //     //     continue;
+//     //     // };
+//     //     // let model_matrix = global_transform.compute_matrix();
+
+//     //     // let Some(result) = transform_gizmo_bevy::Gizmo::new(selected)
+//     //     //     .model_matrix(model_matrix.into())
+//     //     //     .view_matrix(view_matrix.into())
+//     //     //     .projection_matrix(projection_matrix.into())
+//     //     //     .orientation(transform_gizmo_bevy::GizmoOrientation::Local)
+//     //     //     .mode(gizmo_mode)
+//     //     //     .interact(ui)
+//     //     // else {
+//     //     //     continue;
+//     //     // };
+
+//     //     // let global_affine = global_transform.affine();
+
+//     //     // let mut transform = world.get_mut::<Transform>(selected).unwrap();
+
+//     //     // let parent_affine = global_affine * transform.compute_affine().inverse();
+//     //     // let inverse_parent_transform = GlobalTransform::from(parent_affine.inverse());
+
+//     //     // let global_transform = Transform {
+//     //     //     translation: result.translation.into(),
+//     //     //     rotation: result.rotation.into(),
+//     //     //     scale: result.scale.into(),
+//     //     // };
+
+//     //     // *transform = (inverse_parent_transform * global_transform).into();
+//     // }
+// }

Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ pub fn editor_controls_system(`
`240`	`240`	`editor`
`241`	`241`	`.window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()`
`242`	`242`	`.unwrap()`
`243`		`- .gizmo_mode = egui_gizmo::GizmoMode::Translate;`
	`243`	`+ .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_translate();`
`244`	`244`	`}`
`245`	`245`	`if controls.just_pressed(`
`246`	`246`	`Action::SetGizmoModeRotate,`
`@@ -251,7 +251,7 @@ pub fn editor_controls_system(`
`251`	`251`	`editor`
`252`	`252`	`.window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()`
`253`	`253`	`.unwrap()`
`254`		`- .gizmo_mode = egui_gizmo::GizmoMode::Rotate;`
	`254`	`+ .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_rotate();`
`255`	`255`	`}`
`256`	`256`	`if controls.just_pressed(`
`257`	`257`	`Action::SetGizmoModeScale,`
`@@ -262,7 +262,7 @@ pub fn editor_controls_system(`
`262`	`262`	`editor`
`263`	`263`	`.window_state_mut::<bevy_editor_pls_default_windows::gizmos::GizmoWindow>()`
`264`	`264`	`.unwrap()`
`265`		`- .gizmo_mode = egui_gizmo::GizmoMode::Scale;`
	`265`	`+ .gizmo_mode = transform_gizmo_bevy::GizmoMode::all_scale();`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`	`}`