Transform Gizmo Refactor

fission/src/mirabuf/MirabufSceneObject.ts

@@ -10,7 +10,6 @@ import JOLT from "@/util/loading/JoltSyncLoader"
 import { BodyAssociate, LayerReserve } from "@/systems/physics/PhysicsSystem"
 import Mechanism from "@/systems/physics/Mechanism"
 import InputSystem from "@/systems/input/InputSystem"
-import TransformGizmos from "@/ui/components/TransformGizmos"
 import { EjectorPreferences, FieldPreferences, IntakePreferences } from "@/systems/preferences/PreferenceTypes"
 import PreferencesSystem from "@/systems/preferences/PreferencesSystem"
 import { MiraType } from "./MirabufLoader"
@@ -21,6 +20,7 @@ import ScoringZoneSceneObject from "./ScoringZoneSceneObject"
 import { SceneOverlayTag } from "@/ui/components/SceneOverlayEvents"
 import { ProgressHandle } from "@/ui/components/ProgressNotificationData"
 import SynthesisBrain from "@/systems/simulation/synthesis_brain/SynthesisBrain"
+import GizmoSceneObject from "@/systems/scene/GizmoSceneObject"
 
 const DEBUG_BODIES = false
 
@@ -38,8 +38,6 @@ class MirabufSceneObject extends SceneObject {
     private _debugBodies: Map<string, RnDebugMeshes> | null
     private _physicsLayerReserve: LayerReserve | undefined
 
-    private _transformGizmos: TransformGizmos | undefined
-
     private _intakePreferences: IntakePreferences | undefined
     private _ejectorPreferences: EjectorPreferences | undefined
 
@@ -106,8 +104,6 @@ class MirabufSceneObject extends SceneObject {
 
         this._debugBodies = null
 
-        this.EnableTransformControls() // adding transform gizmo to mirabuf object on its creation
-
         this.getPreferences()
 
         // creating nametag for robots
@@ -159,6 +155,17 @@ class MirabufSceneObject extends SceneObject {
         this.UpdateIntakeSensor()
 
         this.UpdateScoringZones()
+
+        // Adding a transform gizmo to the assembly when it spawns
+        new GizmoSceneObject(
+            new THREE.Mesh(
+                new THREE.SphereGeometry(3.0),
+                new THREE.MeshBasicMaterial({ transparent: true, opacity: 0 })
+            ),
+            "translate",
+            3,
+            this
+        )
     }
 
     public Update(): void {
@@ -180,29 +187,6 @@ class MirabufSceneObject extends SceneObject {
                 meshes.forEach(([batch, id]) => batch.setMatrixAt(id, partTransform))
             })
 
-            /**
-             * Update the position and rotation of the body to match the position of the transform gizmo.
-             *
-             * This block of code should only be executed if the transform gizmo exists.
-             */
-            if (this._transformGizmos) {
-                if (InputSystem.isKeyPressed("Enter")) {
-                    // confirming placement of the mirabuf object
-                    this.DisableTransformControls()
-                    return
-                } else if (InputSystem.isKeyPressed("Escape")) {
-                    // cancelling the creation of the mirabuf scene object
-                    World.SceneRenderer.RemoveSceneObject(this.id)
-                    return
-                }
-
-                // if the gizmo is being dragged, copy the mesh position and rotation to the Mirabuf body
-                if (this._transformGizmos.isBeingDragged()) {
-                    this._transformGizmos.UpdateMirabufPositioning(this, rn)
-                    World.PhysicsSystem.DisablePhysicsForBody(this._mechanism.GetBodyByNodeId(rn.id)!)
-                }
-            }
-
             if (isNaN(body.GetPosition().GetX())) {
                 const vel = body.GetLinearVelocity()
                 const pos = body.GetPosition()
@@ -261,7 +245,6 @@ class MirabufSceneObject extends SceneObject {
         })
 
         this._nameTag?.Dispose()
-        this.DisableTransformControls()
         World.SimulationSystem.UnregisterMechanism(this._mechanism)
         World.PhysicsSystem.DestroyMechanism(this._mechanism)
         this._mirabufInstance.Dispose(World.SceneRenderer.scene)
@@ -371,34 +354,6 @@ class MirabufSceneObject extends SceneObject {
         }
     }
 
-    /**
-     * Changes the mode of the mirabuf object from being interacted with to being placed.
-     */
-    public EnableTransformControls(): void {
-        if (this._transformGizmos) return
-
-        this._transformGizmos = new TransformGizmos(
-            new THREE.Mesh(
-                new THREE.SphereGeometry(3.0),
-                new THREE.MeshBasicMaterial({ color: 0x000000, transparent: true, opacity: 0 })
-            )
-        )
-        this._transformGizmos.AddMeshToScene()
-        this._transformGizmos.CreateGizmo("translate", 5.0)
-
-        this.DisablePhysics()
-    }
-
-    /**
-     * Changes the mode of the mirabuf object from being placed to being interacted with.
-     */
-    public DisableTransformControls(): void {
-        if (!this._transformGizmos) return
-        this._transformGizmos?.RemoveGizmos()
-        this._transformGizmos = undefined
-        this.EnablePhysics()
-    }
-
     /**
      *
      * @returns The bounding box of the mirabuf object.
@@ -419,13 +374,13 @@ class MirabufSceneObject extends SceneObject {
         this._fieldPreferences = PreferencesSystem.getFieldPreferences(this.assemblyName)
     }
 
-    private EnablePhysics() {
+    public EnablePhysics() {
         this._mirabufInstance.parser.rigidNodes.forEach(rn => {
             World.PhysicsSystem.EnablePhysicsForBody(this._mechanism.GetBodyByNodeId(rn.id)!)
         })
     }
 
-    private DisablePhysics() {
+    public DisablePhysics() {
         this._mirabufInstance.parser.rigidNodes.forEach(rn => {
             World.PhysicsSystem.DisablePhysicsForBody(this._mechanism.GetBodyByNodeId(rn.id)!)
         })

fission/src/systems/scene/GizmoSceneObject.ts

@@ -0,0 +1,162 @@
+import SceneObject from "./SceneObject"
+import { TransformControls } from "three/examples/jsm/controls/TransformControls.js"
+import InputSystem from "../input/InputSystem"
+import World from "../World"
+import MirabufSceneObject from "@/mirabuf/MirabufSceneObject"
+import { PerspectiveCamera } from "three"
+import { ThreeMatrix4_JoltMat44, ThreeQuaternion_JoltQuat } from "@/util/TypeConversions"
+
+export type GizmoMode = "translate" | "rotate" | "scale"
+
+class GizmoSceneObject extends SceneObject {
+    private _gizmo: TransformControls
+    private _mesh: THREE.Mesh
+    private _parentObject: MirabufSceneObject | undefined
+
+    private _mainCamera: PerspectiveCamera
+
+    private _size: number
+
+    public get gizmo() {
+        return this._gizmo
+    }
+
+    public get mesh() {
+        return this._mesh
+    }
+
+    public constructor(mesh: THREE.Mesh, mode: GizmoMode, size: number, parentObject?: MirabufSceneObject) {
+        super()
+
+        this._mesh = mesh
+        this._parentObject = parentObject
+        this._mainCamera = World.SceneRenderer.mainCamera
+
+        this._size = size
+
+        this._gizmo = new TransformControls(World.SceneRenderer.mainCamera, World.SceneRenderer.renderer.domElement)
+        this._gizmo.setMode(mode)
+
+        World.SceneRenderer.RegisterSceneObject(this)
+    }
+
+    public Setup(): void {
+        // adding the mesh and gizmo to the scene
+        World.SceneRenderer.AddObject(this._mesh)
+        World.SceneRenderer.AddObject(this._gizmo)
+
+        // forcing the gizmo to rotate and transform with the object
+        this._gizmo.setSpace("local")
+        this._gizmo.attach(this._mesh)
+
+        this._gizmo.addEventListener("dragging-changed", (event: { target: TransformControls; value: unknown }) => {
+            // disable orbit controls when dragging the transform gizmo
+            const gizmoDragging = World.SceneRenderer.IsAnyGizmoDragging()
+            if (!event.value && !gizmoDragging) {
+                World.SceneRenderer.orbitControls.enabled = true // enable orbit controls when not dragging another transform gizmo
+            } else if (!event.value && gizmoDragging) {
+                World.SceneRenderer.orbitControls.enabled = false // disable orbit controls when dragging another transform gizmo
+            } else {
+                World.SceneRenderer.orbitControls.enabled = !event.value // disable orbit controls when dragging transform gizmo
+            }
+
+            if (event.target.mode === "translate") {
+                // disable other gizmos when translating
+                Array.from(World.SceneRenderer.sceneObjects.values())
+                    .filter(obj => obj instanceof GizmoSceneObject)
+                    .forEach(obj => {
+                        if (obj.gizmo.object === event.target.object && obj.gizmo.mode !== "translate") {
+                            obj.gizmo.dragging = false
+                            obj.gizmo.enabled = !event.value
+                            return
+                        }
+                    })
+            } else if (
+                event.target.mode === "scale" &&
+                (InputSystem.isKeyPressed("ShiftRight") || InputSystem.isKeyPressed("ShiftLeft"))
+            ) {
+                // scale uniformly if shift is pressed
+                event.target.axis = "XYZE"
+            } else if (event.target.mode === "rotate") {
+                // scale on all axes
+                Array.from(World.SceneRenderer.sceneObjects.values())
+                    .filter(obj => obj instanceof GizmoSceneObject)
+                    .forEach(obj => {
+                        if (
+                            obj.gizmo.mode === "scale" &&
+                            event.target !== obj.gizmo &&
+                            obj.gizmo.object === event.target.object
+                        ) {
+                            obj.gizmo.dragging = false
+                            obj.gizmo.enabled = !event.value
+                            return
+                        }
+                    })
+            }
+        })
+
+        if (this._parentObject !== undefined) this._parentObject.DisablePhysics()
+    }
+    public Update(): void {
+        // updating the size of the gizmo based on the distance from the camera
+        const mainCameraFovRadians = (Math.PI * (this._mainCamera.fov * 0.5)) / 180
+        this._gizmo.setSize(
+            (this._size / this._mainCamera.position.distanceTo(this.gizmo.object!.position)) *
+                Math.tan(mainCameraFovRadians) *
+                1.9
+        )
+
+        // mapping the mesh transformations to the mirabuf object
+        if (this._parentObject !== undefined) {
+            this._parentObject.DisablePhysics()
+
+            if (this._gizmo.dragging) {
+                this._parentObject.mirabufInstance.parser.rigidNodes.forEach(rn => {
+                    World.PhysicsSystem.SetBodyPosition(
+                        this._parentObject!.mechanism.GetBodyByNodeId(rn.id)!,
+                        ThreeMatrix4_JoltMat44(this._mesh.matrix).GetTranslation()
+                    )
+                    World.PhysicsSystem.SetBodyRotation(
+                        this._parentObject!.mechanism.GetBodyByNodeId(rn.id)!,
+                        ThreeQuaternion_JoltQuat(this._mesh.quaternion)
+                    )
+
+                    rn.parts.forEach(part => {
+                        const partTransform = this._parentObject!.mirabufInstance.parser.globalTransforms.get(part)!
+                            .clone()
+                            .premultiply(this._mesh.matrix)
+
+                        const meshes = this._parentObject!.mirabufInstance.meshes.get(part) ?? []
+                        meshes.forEach(([batch, id]) => batch.setMatrixAt(id, partTransform))
+                    })
+                })
+            }
+        }
+
+        // creating enter key and escape key event listeners
+        if (InputSystem.isKeyPressed("Enter")) {
+            // confirming placement of object
+            if (this._parentObject !== undefined) this._parentObject.EnablePhysics()
+            World.SceneRenderer.RemoveSceneObject(this.id)
+            return
+        } else if (InputSystem.isKeyPressed("Escape") && this._parentObject) {
+            // cancelling the creation of the mirabuf scene object
+            World.SceneRenderer.RemoveSceneObject(this._parentObject.id)
+            World.SceneRenderer.RemoveSceneObject(this.id)
+            return
+        }
+    }
+
+    public Dispose(): void {
+        this._gizmo.detach()
+        World.SceneRenderer.RemoveObject(this._mesh)
+        World.SceneRenderer.RemoveObject(this._gizmo)
+    }
+
+    /** changes the mode of the gizmo */
+    public SetMode(mode: GizmoMode) {
+        this._gizmo.setMode(mode)
+    }
+}
+
+export default GizmoSceneObject