@fps-games/editor 0.1.1-beta.9 → 0.1.2-beta.2

package/node_modules/@fps-games/editor-babylon/dist/transform-gizmo-controller.js

@@ -1,4 +1,5 @@
 import { DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, normalizeEditorTransformConstraint, snapEditorTransformSnapshot, } from '@fps-games/editor-core';
+import { createBabylonTransformSolver } from './transform-solver';
 export function resolveBabylonTransformHandleConstraint(tool, handleKey) {
     if (tool === 'move') {
         if (handleKey === 'xPlaneGizmo' || handleKey === 'yPlaneGizmo' || handleKey === 'zPlaneGizmo')
@@ -18,13 +19,10 @@ export function resolveBabylonTransformHandleConstraint(tool, handleKey) {
     return null;
 }
 export function createBabylonTransformGizmoController(options) {
-    const GizmoManager = options.babylon.GizmoManager;
-    if (!GizmoManager)
+    const GizmoManagerCtor = options.babylon.GizmoManager;
+    if (!GizmoManagerCtor)
         throw new Error('Babylon runtime missing GizmoManager');
-    const manager = new GizmoManager(options.scene);
-    manager.usePointerToAttachGizmos = false;
-    manager.clearGizmoOnEmptyPointerEvent = false;
-    manager.boundingBoxGizmoEnabled = false;
+    const transformSolver = createBabylonTransformSolver({ babylon: options.babylon });
     let tool = options.initialTool ?? 'select';
     let space = options.initialSpace ?? 'world';
     let constraint = normalizeConstraintForTool(tool, 'axis') ?? 'axis';
@@ -40,7 +38,17 @@ export function createBabylonTransformGizmoController(options) {
     let freeMoveHandleMaterial = null;
     let placementMarker = null;
     let placementMarkerMaterial = null;
+    let manager = null;
     const canvas = options.scene.getEngine?.().getRenderingCanvas?.();
+    function ensureGizmoManager() {
+        if (manager)
+            return manager;
+        manager = new GizmoManagerCtor(options.scene);
+        manager.usePointerToAttachGizmos = false;
+        manager.clearGizmoOnEmptyPointerEvent = false;
+        manager.boundingBoxGizmoEnabled = false;
+        return manager;
+    }
     function activeTransformTool() {
         return tool === 'select' ? null : tool;
     }
@@ -116,25 +124,31 @@ export function createBabylonTransformGizmoController(options) {
             if (!activeConstraint)
                 continue;
             const behavior = gizmo?.[handleKey]?.dragBehavior;
-            addObserver(behavior?.onDragStartObservable, () => beginDrag(activeConstraint));
+            addObserver(behavior?.onDragStartObservable, () => beginDrag(activeConstraint, handleKey));
             addObserver(behavior?.onDragObservable, updateDrag);
             addObserver(behavior?.onDragEndObservable, endDrag);
         }
     }
     function registerDragObservers() {
         clearDragObservers();
-        registerDragObserversFor('move', manager.gizmos?.positionGizmo);
-        registerDragObserversFor('rotate', manager.gizmos?.rotationGizmo);
-        registerDragObserversFor('scale', manager.gizmos?.scaleGizmo);
+        const activeManager = manager;
+        if (!activeManager)
+            return;
+        registerDragObserversFor('move', activeManager.gizmos?.positionGizmo);
+        registerDragObserversFor('rotate', activeManager.gizmos?.rotationGizmo);
+        registerDragObserversFor('scale', activeManager.gizmos?.scaleGizmo);
     }
     function applySpacePreference() {
-        const matchAttachedMesh = space === 'local';
+        const activeManager = manager;
+        if (!activeManager)
+            return;
         const gizmos = [
-            manager.gizmos?.positionGizmo,
-            manager.gizmos?.rotationGizmo,
-            manager.gizmos?.scaleGizmo,
+            { gizmo: activeManager.gizmos?.positionGizmo },
+            { gizmo: activeManager.gizmos?.rotationGizmo },
+            { gizmo: activeManager.gizmos?.scaleGizmo },
         ];
-        for (const gizmo of gizmos) {
+        for (const { gizmo } of gizmos) {
+            const matchAttachedMesh = shouldMatchAttachedMeshForGizmo();
             try {
                 if ('updateGizmoRotationToMatchAttachedMesh' in (gizmo ?? {})) {
                     gizmo.updateGizmoRotationToMatchAttachedMesh = matchAttachedMesh;
@@ -159,8 +173,11 @@ export function createBabylonTransformGizmoController(options) {
             }
         }
     }
+    function shouldMatchAttachedMeshForGizmo() {
+        return space === 'local';
+    }
     function applyHandlePreference() {
-        const positionGizmo = manager.gizmos?.positionGizmo;
+        const positionGizmo = manager?.gizmos?.positionGizmo;
         if (positionGizmo) {
             try {
                 positionGizmo.planarGizmoEnabled = tool === 'move';
@@ -169,26 +186,43 @@ export function createBabylonTransformGizmoController(options) {
         }
     }
     function attachCurrentSelection() {
+        clearDragObservers();
         const activeTool = activeTransformTool();
-        manager.positionGizmoEnabled = activeTool === 'move';
-        manager.rotationGizmoEnabled = activeTool === 'rotate';
-        manager.scaleGizmoEnabled = activeTool === 'scale';
+        if (!activeTool) {
+            if (manager) {
+                manager.positionGizmoEnabled = false;
+                manager.rotationGizmoEnabled = false;
+                manager.scaleGizmoEnabled = false;
+                try {
+                    manager.attachToNode?.(null);
+                }
+                catch { }
+            }
+            updateFreeMoveHandle();
+            return;
+        }
+        const activeManager = ensureGizmoManager();
+        if (!activeManager) {
+            updateFreeMoveHandle();
+            return;
+        }
+        activeManager.positionGizmoEnabled = activeTool === 'move';
+        activeManager.rotationGizmoEnabled = activeTool === 'rotate';
+        activeManager.scaleGizmoEnabled = activeTool === 'scale';
         applyHandlePreference();
         applySpacePreference();
         registerDragObservers();
         let target = null;
-        if (activeTool) {
-            target = attachNativeTransformProxy(getCurrentTransformTargetIds());
-        }
+        target = attachNativeTransformProxy(getCurrentTransformTargetIds());
         try {
-            manager.attachToNode?.(target ?? null);
+            activeManager.attachToNode?.(target ?? null);
         }
         catch (error) {
             options.logger?.warn?.('[BabylonTransformGizmoController] failed to attach gizmo', error);
         }
         updateFreeMoveHandle();
     }
-    function beginDrag(activeConstraint = constraint) {
+    function beginDrag(activeConstraint = constraint, handleKey) {
         if (activeDrag)
             return;
         const activeTool = activeTransformTool();
@@ -197,7 +231,7 @@ export function createBabylonTransformGizmoController(options) {
         const duplicate = pendingDuplicateDrag;
         pendingDuplicateDrag = false;
         const targetIds = resolveDragTargetIds(activeTool, getCurrentTransformTargetIds(), activeConstraint, duplicate);
-        const drag = createActiveDrag(activeTool, targetIds, activeConstraint, duplicate);
+        const drag = createActiveDrag(activeTool, targetIds, activeConstraint, duplicate, handleKey);
         if (!drag)
             return;
         activeDrag = drag;
@@ -232,8 +266,11 @@ export function createBabylonTransformGizmoController(options) {
         const target = attachNativeTransformProxy(targetIds);
         if (!target)
             return false;
+        const activeManager = ensureGizmoManager();
+        if (!activeManager)
+            return false;
         try {
-            manager.attachToNode?.(target);
+            activeManager.attachToNode?.(target);
             updateFreeMoveHandle();
             return true;
         }
@@ -265,7 +302,7 @@ export function createBabylonTransformGizmoController(options) {
             }
             : null;
     }
-    function createActiveDrag(activeTool, targetIds, activeConstraint, duplicate = false) {
+    function createActiveDrag(activeTool, targetIds, activeConstraint, duplicate = false, handleKey) {
         if (targetIds.length === 0)
             return null;
         const beforeTransforms = options.projection.readNodeTransforms(targetIds);
@@ -292,13 +329,19 @@ export function createBabylonTransformGizmoController(options) {
             before,
             beforeTransforms,
             duplicate,
+            handleKey,
             proxyStart: readNativeProxyTransform(pivot),
         };
     }
     function updateDrag() {
         if (!activeDrag)
             return;
-        const currentTransforms = previewBatchTransform(activeDrag);
+        const preview = previewBatchTransform(activeDrag);
+        if (!preview.ok) {
+            blockDrag(activeDrag, preview.reason, preview.failedTargetId);
+            return;
+        }
+        const currentTransforms = preview.transforms;
         const current = activeDrag.activeId
             ? currentTransforms[activeDrag.activeId] ?? Object.values(currentTransforms)[0] ?? null
             : Object.values(currentTransforms)[0] ?? null;
@@ -315,10 +358,32 @@ export function createBabylonTransformGizmoController(options) {
         const drag = activeDrag;
         if (!drag)
             return;
-        const afterTransforms = previewBatchTransform(drag);
+        const preview = previewBatchTransform(drag);
+        if (!preview.ok) {
+            blockDrag(drag, preview.reason, preview.failedTargetId);
+            return;
+        }
+        activeDrag = null;
+        emitTransformCommit(drag, preview.transforms);
+        attachCurrentSelection();
+    }
+    function blockDrag(drag, reason, failedTargetId) {
         activeDrag = null;
-        emitTransformCommit(drag, afterTransforms);
+        restoreDragPreview(drag);
         attachCurrentSelection();
+        options.onDragBlocked?.({
+            ...drag,
+            reason,
+            failedTargetId,
+        });
+    }
+    function restoreDragPreview(drag) {
+        if (drag.targetIds.length > 1) {
+            options.projection.setNodeTransformsPreview(drag.beforeTransforms);
+        }
+        else if (drag.nodeId && drag.before) {
+            options.projection.setNodeTransformPreview(drag.nodeId, drag.before);
+        }
     }
     function emitTransformCommit(drag, afterTransforms) {
         if (drag.targetIds.length === 1) {
@@ -367,15 +432,15 @@ export function createBabylonTransformGizmoController(options) {
             scale: { x: 1, y: 1, z: 1 },
         };
         if (drag.tool === 'move') {
-            return previewMoveWithDelta(drag, subtractVec3(pivotTransform.position, proxyStart.position));
+            return { ok: true, transforms: previewMoveWithDelta(drag, subtractVec3(pivotTransform.position, proxyStart.position)) };
         }
         if (drag.tool === 'rotate') {
-            return previewRotateWithDelta(drag, subtractVec3(pivotTransform.rotation, proxyStart.rotation));
+            return previewRotateWithDelta(drag, resolveRotationDelta(drag, pivotTransform, proxyStart));
         }
         if (drag.tool === 'scale') {
             return previewScaleWithDelta(drag, divideVec3(pivotTransform.scale, proxyStart.scale));
         }
-        return {};
+        return { ok: true, transforms: {} };
     }
     function previewMoveWithDelta(drag, delta) {
         const transforms = {};
@@ -383,34 +448,54 @@ export function createBabylonTransformGizmoController(options) {
             const before = drag.beforeTransforms[nodeId];
             if (!before)
                 continue;
-            transforms[nodeId] = applySnapToTransform(drag, nodeId, translateTransform(before, delta));
+            const result = transformSolver.solveMove({ before, delta });
+            if (!result.ok)
+                continue;
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, result.transform);
         }
         options.projection.setNodeTransformsPreview(transforms);
         return transforms;
     }
-    function translateTransform(transform, delta) {
-        return {
-            position: addVec3(transform.position, delta),
-            rotation: transform.rotation,
-            scale: transform.scale,
-        };
-    }
     function previewRotateWithDelta(drag, rotationDelta) {
         const transforms = {};
         for (const nodeId of drag.targetIds) {
             const before = drag.beforeTransforms[nodeId];
             if (!before)
                 continue;
-            const offset = subtractVec3(before.position, drag.pivot.position);
-            transforms[nodeId] = {
-                position: addVec3(drag.pivot.position, rotateVec3Euler(offset, rotationDelta)),
-                rotation: addVec3(before.rotation, rotationDelta),
-                scale: before.scale,
-            };
-            transforms[nodeId] = applySnapToTransform(drag, nodeId, transforms[nodeId]);
+            const result = transformSolver.solveRotate({
+                before,
+                pivot: drag.pivot.position,
+                delta: rotationDelta,
+                space: drag.space,
+            });
+            if (!result.ok) {
+                return { ok: false, reason: result.reason, failedTargetId: nodeId };
+            }
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, result.transform);
         }
         options.projection.setNodeTransformsPreview(transforms);
-        return transforms;
+        return { ok: true, transforms };
+    }
+    function resolveRotationDelta(drag, pivotTransform, proxyStart) {
+        const angleDelta = readRotationHandleAngle(drag.handleKey);
+        if (angleDelta != null)
+            return rotationDeltaFromHandleAngle(drag.handleKey, angleDelta);
+        return subtractVec3(pivotTransform.rotation, proxyStart.rotation);
+    }
+    function readRotationHandleAngle(handleKey) {
+        if (handleKey !== 'xGizmo' && handleKey !== 'yGizmo' && handleKey !== 'zGizmo')
+            return null;
+        const angle = manager?.gizmos?.rotationGizmo?.[handleKey]?.angle;
+        return Number.isFinite(angle) ? Number(angle) : null;
+    }
+    function rotationDeltaFromHandleAngle(handleKey, angle) {
+        if (handleKey === 'xGizmo')
+            return { x: angle, y: 0, z: 0 };
+        if (handleKey === 'yGizmo')
+            return { x: 0, y: angle, z: 0 };
+        if (handleKey === 'zGizmo')
+            return { x: 0, y: 0, z: angle };
+        return { x: 0, y: 0, z: 0 };
     }
     function previewScaleWithDelta(drag, scaleDelta) {
         const transforms = {};
@@ -423,16 +508,19 @@ export function createBabylonTransformGizmoController(options) {
             const before = drag.beforeTransforms[nodeId];
             if (!before)
                 continue;
-            const offset = subtractVec3(before.position, drag.pivot.position);
-            transforms[nodeId] = {
-                position: addVec3(drag.pivot.position, multiplyVec3(offset, safeScale)),
-                rotation: before.rotation,
-                scale: multiplyVec3(before.scale, safeScale),
-            };
-            transforms[nodeId] = applySnapToTransform(drag, nodeId, transforms[nodeId]);
+            const result = transformSolver.solveScale({
+                before,
+                pivot: drag.pivot.position,
+                delta: safeScale,
+                space: drag.space,
+            });
+            if (!result.ok) {
+                return { ok: false, reason: result.reason, failedTargetId: nodeId };
+            }
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, result.transform);
         }
         options.projection.setNodeTransformsPreview(transforms);
-        return transforms;
+        return { ok: true, transforms };
     }
     function applySnapToTransform(drag, nodeId, after) {
         if (!operationSettings.snap.enabled)
@@ -490,13 +578,6 @@ export function createBabylonTransformGizmoController(options) {
     function dotVec3(left, right) {
         return left.x * right.x + left.y * right.y + left.z * right.z;
     }
-    function multiplyVec3(left, right) {
-        return {
-            x: left.x * right.x,
-            y: left.y * right.y,
-            z: left.z * right.z,
-        };
-    }
     function divideVec3(left, right) {
         return {
             x: Math.abs(right.x) > 0.000001 ? left.x / right.x : 1,
@@ -504,36 +585,6 @@ export function createBabylonTransformGizmoController(options) {
             z: Math.abs(right.z) > 0.000001 ? left.z / right.z : 1,
         };
     }
-    function rotateVec3Euler(value, rotation) {
-        return rotateZ(rotateY(rotateX(value, rotation.x), rotation.y), rotation.z);
-    }
-    function rotateX(value, angle) {
-        const cos = Math.cos(angle);
-        const sin = Math.sin(angle);
-        return {
-            x: value.x,
-            y: value.y * cos - value.z * sin,
-            z: value.y * sin + value.z * cos,
-        };
-    }
-    function rotateY(value, angle) {
-        const cos = Math.cos(angle);
-        const sin = Math.sin(angle);
-        return {
-            x: value.x * cos + value.z * sin,
-            y: value.y,
-            z: -value.x * sin + value.z * cos,
-        };
-    }
-    function rotateZ(value, angle) {
-        const cos = Math.cos(angle);
-        const sin = Math.sin(angle);
-        return {
-            x: value.x * cos - value.y * sin,
-            y: value.x * sin + value.y * cos,
-            z: value.z,
-        };
-    }
     function isViewPlaneMoveCandidate(event) {
         if (disposed || activeDrag || tool !== 'move' || event.button !== 0)
             return false;
@@ -720,7 +771,8 @@ export function createBabylonTransformGizmoController(options) {
         const MeshBuilder = options.babylon.MeshBuilder;
         const StandardMaterial = options.babylon.StandardMaterial;
         const Color3 = options.babylon.Color3;
-        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        const activeManager = ensureGizmoManager();
+        const utilityScene = activeManager?.utilityLayer?.utilityLayerScene;
         if (!MeshBuilder?.CreateSphere || !utilityScene)
             return null;
         placementMarker = MeshBuilder.CreateSphere('editor.placement.marker', { diameter: 0.32, segments: 16 }, utilityScene);
@@ -767,7 +819,7 @@ export function createBabylonTransformGizmoController(options) {
         const rect = canvas.getBoundingClientRect();
         const x = clientX - rect.left;
         const y = clientY - rect.top;
-        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        const utilityScene = manager?.utilityLayer?.utilityLayerScene;
         const utilityPick = typeof utilityScene?.pick === 'function' ? utilityScene.pick(x, y) : null;
         if (utilityPick?.hit && utilityPick.pickedMesh)
             return utilityPick.pickedMesh;
@@ -780,7 +832,7 @@ export function createBabylonTransformGizmoController(options) {
         const rect = canvas.getBoundingClientRect();
         const x = clientX - rect.left;
         const y = clientY - rect.top;
-        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        const utilityScene = manager?.utilityLayer?.utilityLayerScene;
         const pick = typeof utilityScene?.pick === 'function'
             ? utilityScene.pick(x, y, (mesh) => isFreeMoveHandleNode(mesh))
             : null;
@@ -792,7 +844,8 @@ export function createBabylonTransformGizmoController(options) {
         const MeshBuilder = options.babylon.MeshBuilder;
         const StandardMaterial = options.babylon.StandardMaterial;
         const Color3 = options.babylon.Color3;
-        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        const activeManager = ensureGizmoManager();
+        const utilityScene = activeManager?.utilityLayer?.utilityLayerScene;
         if (!MeshBuilder?.CreateSphere || !utilityScene)
             return null;
         freeMoveHandle = MeshBuilder.CreateSphere('editor.transform.freeMoveHandle', { diameter: 0.22, segments: 12 }, utilityScene);
@@ -880,13 +933,16 @@ export function createBabylonTransformGizmoController(options) {
     }
     function collectCurrentGizmoRoots() {
         const roots = new Set();
+        const activeManager = manager;
+        if (!activeManager)
+            return roots;
         const activeTool = activeTransformTool();
         const gizmo = activeTool === 'move'
-            ? manager.gizmos?.positionGizmo
+            ? activeManager.gizmos?.positionGizmo
             : activeTool === 'rotate'
-                ? manager.gizmos?.rotationGizmo
+                ? activeManager.gizmos?.rotationGizmo
                 : activeTool === 'scale'
-                    ? manager.gizmos?.scaleGizmo
+                    ? activeManager.gizmos?.scaleGizmo
                     : null;
         collectGizmoRoots(gizmo, roots);
         return roots;
@@ -919,8 +975,11 @@ export function createBabylonTransformGizmoController(options) {
         setTool(nextTool) {
             if (disposed)
                 return;
-            if (tool === nextTool)
+            if (tool === nextTool) {
+                if (!activeDrag)
+                    attachCurrentSelection();
                 return;
+            }
             controller.cancelDrag();
             tool = nextTool;
             constraint = normalizeConstraintForTool(tool, constraint) ?? 'axis';
@@ -929,8 +988,11 @@ export function createBabylonTransformGizmoController(options) {
         setSpace(nextSpace) {
             if (disposed)
                 return;
-            if (space === nextSpace)
+            if (space === nextSpace) {
+                if (!activeDrag)
+                    attachCurrentSelection();
                 return;
+            }
             controller.cancelDrag();
             space = nextSpace;
             attachCurrentSelection();
@@ -939,8 +1001,11 @@ export function createBabylonTransformGizmoController(options) {
             if (disposed)
                 return;
             const normalized = normalizeConstraintForTool(tool, nextConstraint) ?? 'axis';
-            if (constraint === normalized)
+            if (constraint === normalized) {
+                if (!activeDrag)
+                    attachCurrentSelection();
                 return;
+            }
             controller.cancelDrag();
             constraint = normalized;
             attachCurrentSelection();
@@ -1016,11 +1081,11 @@ export function createBabylonTransformGizmoController(options) {
             controller.cancelDrag();
             clearDragObservers();
             try {
-                manager.attachToNode?.(null);
+                manager?.attachToNode?.(null);
             }
             catch { }
             try {
-                manager.dispose?.();
+                manager?.dispose?.();
             }
             catch { }
             try {
@@ -1048,6 +1113,7 @@ export function createBabylonTransformGizmoController(options) {
             freeMoveHandleMaterial = null;
             placementMarker = null;
             placementMarkerMaterial = null;
+            manager = null;
             disposed = true;
         },
     };