Add bidirectional scaling to the Gizmo

Allows scaling a single side at once, as opposed to scaling in both directions.
Implementation is a bit hacky. To avoid making the gizmo sad, we need three of 'em,
'cause of coordinate handedness.

Author: Froggy618157725

crates/alkahest-renderer/src/ecs/transform.rs

@@ -119,6 +119,7 @@ bitflags! {
         const IGNORE_SCALE = 1 << 2;
 
         const SCALE_IS_RADIUS = 1 << 3;
+        const SCALE_IS_BIDIRECTIONAL = 1 << 4;
     }
 }
 

crates/alkahest-renderer/src/ecs/utility.rs

@@ -14,6 +14,7 @@ use super::{
     common::{Icon, Label, Mutable, RenderCommonBundle},
     route::{Route, RouteNode},
     tags::{EntityTag, NodeFilter, Tags},
+    transform::TransformFlags,
     visibility::VisibilityHelper,
     MapInfo,
 };
@@ -152,7 +153,8 @@ pub struct CuboidBundle {
 }
 
 impl CuboidBundle {
-    pub fn new(transform: Transform, cuboid: Cuboid) -> Self {
+    pub fn new(mut transform: Transform, cuboid: Cuboid) -> Self {
+        transform.flags |= TransformFlags::SCALE_IS_BIDIRECTIONAL;
         Self {
             transform,
             cuboid,

crates/alkahest/src/app.rs

@@ -19,9 +19,9 @@ use bevy_ecs::system::RunSystemOnce;
 use bevy_tasks::{ComputeTaskPool, TaskPool};
 use egui::{Key, KeyboardShortcut, Modifiers};
 use gilrs::{EventType, Gilrs};
-use glam::Vec2;
+use glam::{Vec2, Vec3};
 use strum::IntoEnumIterator;
-use transform_gizmo_egui::{EnumSet, Gizmo, GizmoConfig, GizmoOrientation};
+use transform_gizmo_egui::{enum_set, EnumSet, Gizmo, GizmoConfig, GizmoMode, GizmoOrientation};
 use windows::core::HRESULT;
 use winit::{
     dpi::{PhysicalPosition, PhysicalSize},
@@ -36,7 +36,7 @@ use crate::{
         activity_select::{get_map_name, set_activity, ActivityBrowser, CurrentActivity},
         console,
         context::{GuiContext, GuiViewManager, HiddenWindows},
-        gizmo::draw_transform_gizmos,
+        gizmo::{draw_transform_gizmos, GizmoInfo},
         hotkeys,
         updater::{ChannelSelector, UpdateDownload},
         SelectionGizmoMode,
@@ -129,12 +129,35 @@ impl AlkahestApp {
         let stringmap = Arc::new(StringContainer::load_all_global());
         resources.insert(stringmap);
 
-        let gizmo = Gizmo::new(GizmoConfig {
-            modes: EnumSet::all(),
-            orientation: GizmoOrientation::Local,
-            ..Default::default()
-        });
-        resources.insert(gizmo);
+        let gizmos = vec![
+            GizmoInfo {
+                gizmo: Gizmo::new(GizmoConfig {
+                    modes: EnumSet::all(),
+                    orientation: GizmoOrientation::Local,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            GizmoInfo {
+                gizmo: Gizmo::new(GizmoConfig {
+                    modes: EnumSet::all(),
+                    orientation: GizmoOrientation::Local,
+                    ..Default::default()
+                }),
+                mode_filter: Some(GizmoMode::ScaleX | GizmoMode::ScaleY),
+                rotation_axis: Some(Vec3::Z),
+            },
+            GizmoInfo {
+                gizmo: Gizmo::new(GizmoConfig {
+                    modes: EnumSet::all(),
+                    orientation: GizmoOrientation::Local,
+                    ..Default::default()
+                }),
+                mode_filter: Some(enum_set!(GizmoMode::ScaleZ)),
+                rotation_axis: Some(Vec3::X),
+            },
+        ];
+        resources.insert(gizmos);
 
         resources
             .get_mut::<GuiViewManager>()

crates/alkahest/src/gui/gizmo.rs

@@ -1,6 +1,11 @@
+use std::f32::consts::PI;
+
 use alkahest_renderer::{
     camera::Camera,
-    ecs::{resources::SelectedEntity, transform::Transform},
+    ecs::{
+        resources::SelectedEntity,
+        transform::{Transform, TransformFlags},
+    },
     icons::{ICON_AXIS_ARROW, ICON_CURSOR_DEFAULT, ICON_RESIZE, ICON_ROTATE_ORBIT},
     renderer::Renderer,
     resources::AppResources,
@@ -9,9 +14,10 @@ use egui::{
     epaint::Vertex, Context, LayerId, Mesh, PointerButton, Pos2, Rgba, RichText, Rounding, Ui,
     UiStackInfo,
 };
-use glam::{DQuat, DVec3};
+use glam::{DQuat, DVec3, Quat, Vec3};
 use transform_gizmo_egui::{
-    math::Transform as GTransform, Gizmo, GizmoConfig, GizmoInteraction, GizmoResult,
+    math::Transform as GTransform, EnumSet, Gizmo, GizmoConfig, GizmoInteraction, GizmoMode,
+    GizmoResult,
 };
 use winit::window::Window;
 
@@ -111,6 +117,13 @@ impl GuiView for GizmoSelector {
     }
 }
 
+#[derive(Default)]
+pub struct GizmoInfo {
+    pub gizmo: Gizmo,
+    pub mode_filter: Option<EnumSet<GizmoMode>>,
+    pub rotation_axis: Option<Vec3>,
+}
+
 pub fn draw_transform_gizmos(renderer: &Renderer, ctx: &egui::Context, resources: &AppResources) {
     let Some(selected) = resources.get::<SelectedEntity>().selected() else {
         return;
@@ -134,26 +147,69 @@ pub fn draw_transform_gizmos(renderer: &Renderer, ctx: &egui::Context, resources
         };
         let camera = resources.get::<Camera>();
 
-        let mut gizmo = resources.get_mut::<Gizmo>();
-        let old_config = *gizmo.config();
-        gizmo.update_config(GizmoConfig {
-            view_matrix: camera.world_to_camera.as_dmat4().into(),
-            projection_matrix: camera.camera_to_projective.as_dmat4().into(),
-            modes: gizmo_mode.to_enumset(),
-            ..old_config
-        });
+        let mut gizmo_info = resources.get_mut::<Vec<GizmoInfo>>();
 
-        if let Some((_result, new_transform)) = gizmo_interact(
-            &mut gizmo,
+        for (i, info) in gizmo_info.iter_mut().enumerate() {
+            let old_config = *info.gizmo.config();
+
+            if transform
+                .flags
+                .contains(TransformFlags::SCALE_IS_BIDIRECTIONAL)
+                || i == 1
+            {
+                info.gizmo.update_config(GizmoConfig {
+                    view_matrix: camera.world_to_camera.as_dmat4().into(),
+                    projection_matrix: camera.camera_to_projective.as_dmat4().into(),
+                    modes: match info.mode_filter {
+                        Some(filter) => gizmo_mode.to_enumset().intersection(filter),
+                        None => gizmo_mode.to_enumset(),
+                    },
+                    ..old_config
+                });
+            } else {
+                info.gizmo.update_config(GizmoConfig {
+                    view_matrix: camera.world_to_camera.as_dmat4().into(),
+                    projection_matrix: camera.camera_to_projective.as_dmat4().into(),
+                    modes: EnumSet::empty(),
+                    ..old_config
+                });
+            }
+        }
+
+        let end = if transform
+            .flags
+            .contains(TransformFlags::SCALE_IS_BIDIRECTIONAL)
+        {
+            gizmo_info.len()
+        } else {
+            gizmo_info.len().min(1)
+        };
+
+        if let Some((_result, new_transform, i)) = gizmo_interact(
+            &mut gizmo_info[..end],
             ctx,
             &[GTransform {
                 scale: transform.scale.as_dvec3().into(),
                 rotation: transform.rotation.as_dquat().into(),
                 translation: transform.translation.as_dvec3().into(),
             }],
+            &mut [GTransform::default()],
         ) {
             renderer.pickbuffer.cancel_request();
-            transform.translation = DVec3::from(new_transform[0].translation).as_vec3();
+
+            transform.translation = DVec3::from(new_transform[0].translation).as_vec3()
+                + if transform
+                    .flags
+                    .contains(TransformFlags::SCALE_IS_BIDIRECTIONAL)
+                {
+                    if i == 0 {
+                        DVec3::from(new_transform[0].scale).as_vec3() - transform.scale
+                    } else {
+                        transform.scale - DVec3::from(new_transform[0].scale).as_vec3()
+                    }
+                } else {
+                    Vec3::ZERO
+                };
             transform.rotation = DQuat::from(new_transform[0].rotation).as_quat().normalize();
             transform.scale = DVec3::from(new_transform[0].scale).as_vec3();
         }
@@ -162,52 +218,77 @@ pub fn draw_transform_gizmos(renderer: &Renderer, ctx: &egui::Context, resources
 
 #[must_use]
 fn gizmo_interact(
-    gizmo: &mut Gizmo,
+    gizmo_info: &mut [GizmoInfo],
     ctx: &egui::Context,
     targets: &[GTransform],
-) -> Option<(GizmoResult, Vec<GTransform>)> {
+    targets_scratch: &mut [GTransform],
+) -> Option<(GizmoResult, Vec<GTransform>, usize)> {
     let cursor_pos = ctx
         .input(|input| input.pointer.hover_pos())
         .unwrap_or_default();
 
-    let mut viewport = gizmo.config().viewport;
-    if !viewport.is_finite() {
-        viewport = ctx.screen_rect();
+    let mut active_result = None;
+    for (i, info) in gizmo_info.iter_mut().enumerate() {
+        let mut viewport = info.gizmo.config().viewport;
+        if !viewport.is_finite() {
+            viewport = ctx.screen_rect();
+        }
+        info.gizmo.update_config(GizmoConfig {
+            viewport,
+            pixels_per_point: ctx.pixels_per_point(),
+            ..*info.gizmo.config()
+        });
+        if active_result.is_none() {
+            for (target, target_scratch) in targets.iter().zip(targets_scratch.iter_mut()) {
+                target_scratch.rotation = if let Some(axis) = info.rotation_axis {
+                    DQuat::from(target.rotation)
+                        .as_quat()
+                        .mul_quat(Quat::from_axis_angle(axis, PI))
+                        .as_dquat()
+                        .into()
+                } else {
+                    target.rotation
+                };
+                target_scratch.translation = target.translation;
+                target_scratch.scale = target.scale;
+            }
+            let gizmo_result = info.gizmo.update(
+                GizmoInteraction {
+                    cursor_pos: (cursor_pos.x, cursor_pos.y),
+                    drag_started: ctx
+                        .input(|input| input.pointer.button_pressed(PointerButton::Primary)),
+                    dragging: ctx.input(|input| input.pointer.button_down(PointerButton::Primary)),
+                },
+                targets_scratch,
+            );
+            active_result = gizmo_result.map(|(g, v)| (g, v, i));
+        }
     }
 
-    gizmo.update_config(GizmoConfig {
-        viewport,
-        pixels_per_point: ctx.pixels_per_point(),
-        ..*gizmo.config()
-    });
-
-    let gizmo_result = gizmo.update(
-        GizmoInteraction {
-            cursor_pos: (cursor_pos.x, cursor_pos.y),
-            drag_started: ctx.input(|input| input.pointer.button_pressed(PointerButton::Primary)),
-            dragging: ctx.input(|input| input.pointer.button_down(PointerButton::Primary)),
-        },
-        targets,
-    );
-
-    let draw_data = gizmo.draw();
-
-    ctx.layer_painter(egui::LayerId::background())
-        // .with_clip_rect(egui_viewport)
-        .add(Mesh {
-            indices: draw_data.indices,
-            vertices: draw_data
-                .vertices
-                .into_iter()
-                .zip(draw_data.colors)
-                .map(|(pos, [r, g, b, a])| Vertex {
-                    pos: pos.into(),
-                    uv: Pos2::default(),
-                    color: Rgba::from_rgba_premultiplied(r, g, b, a).into(),
-                })
-                .collect(),
-            ..Default::default()
-        });
+    for (i, info) in gizmo_info.iter_mut().enumerate() {
+        if active_result
+            .as_ref()
+            .map_or(true, |(_, _, active)| *active == i)
+        {
+            let draw_data = info.gizmo.draw();
 
-    gizmo_result
+            ctx.layer_painter(egui::LayerId::background())
+                // .with_clip_rect(egui_viewport)
+                .add(Mesh {
+                    indices: draw_data.indices,
+                    vertices: draw_data
+                        .vertices
+                        .into_iter()
+                        .zip(draw_data.colors)
+                        .map(|(pos, [r, g, b, a])| Vertex {
+                            pos: pos.into(),
+                            uv: Pos2::default(),
+                            color: Rgba::from_rgba_premultiplied(r, g, b, a).into(),
+                        })
+                        .collect(),
+                    ..Default::default()
+                });
+        }
+    }
+    active_result
 }

crates/alkahest/src/gui/inspector/mod.rs

@@ -465,6 +465,11 @@ impl ComponentPanel for Transform {
                                 (self.translation - camera.position()).length().max(0.1),
                             );
                         }
+                    } else if self.flags.contains(TransformFlags::SCALE_IS_BIDIRECTIONAL) {
+                        let mut scale = self.scale * 2.0;
+                        if input_float3!(ui, format!("{ICON_RESIZE} Sides"), &mut scale).inner {
+                            self.scale = scale / 2.0;
+                        }
                     } else {
                         input_float3!(ui, format!("{ICON_RESIZE} Scale"), &mut self.scale).inner;
                     }