@fps-games/editor 0.1.1-beta.0 → 0.1.1-beta.2

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

@@ -1,3 +1,22 @@
+import { DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, normalizeEditorTransformConstraint, snapEditorTransformSnapshot, } from '@fps-games/editor-core';
+export function resolveBabylonTransformHandleConstraint(tool, handleKey) {
+    if (tool === 'move') {
+        if (handleKey === 'xPlaneGizmo' || handleKey === 'yPlaneGizmo' || handleKey === 'zPlaneGizmo')
+            return 'plane';
+        if (handleKey === 'xGizmo' || handleKey === 'yGizmo' || handleKey === 'zGizmo')
+            return 'axis';
+        return null;
+    }
+    if (tool === 'rotate') {
+        return handleKey === 'xGizmo' || handleKey === 'yGizmo' || handleKey === 'zGizmo' ? 'axis' : null;
+    }
+    if (tool === 'scale') {
+        if (handleKey === 'uniformScaleGizmo')
+            return 'uniform';
+        return handleKey === 'xGizmo' || handleKey === 'yGizmo' || handleKey === 'zGizmo' ? 'axis' : null;
+    }
+    return null;
+}
 export function createBabylonTransformGizmoController(options) {
     const GizmoManager = options.babylon.GizmoManager;
     if (!GizmoManager)
@@ -8,13 +27,19 @@ export function createBabylonTransformGizmoController(options) {
     manager.boundingBoxGizmoEnabled = false;
     let tool = options.initialTool ?? 'select';
     let space = options.initialSpace ?? 'world';
-    let constraint = 'axis';
+    let constraint = normalizeConstraintForTool(tool, 'axis') ?? 'axis';
     let selectedNodeId = null;
     let selectedNodeIds = [];
     let activeDrag = null;
     let disposed = false;
+    let operationSettings = cloneOperationSettings(DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS);
+    let pendingDuplicateDrag = false;
     let observerDisposers = [];
     let pivotProxy = null;
+    let freeMoveHandle = null;
+    let freeMoveHandleMaterial = null;
+    let placementMarker = null;
+    let placementMarkerMaterial = null;
     const canvas = options.scene.getEngine?.().getRenderingCanvas?.();
     function activeTransformTool() {
         return tool === 'select' ? null : tool;
@@ -29,6 +54,14 @@ export function createBabylonTransformGizmoController(options) {
             return [];
         return selectedNodeIds.filter(nodeId => !!options.projection.getAttachableRoot(nodeId));
     }
+    function getCurrentTransformTargetIds() {
+        return selectedNodeIds.length > 1
+            ? getBatchTransformTargetIds()
+            : [getActiveTargetId()].filter((nodeId) => !!nodeId);
+    }
+    function normalizeConstraintForTool(nextTool, nextConstraint) {
+        return normalizeEditorTransformConstraint(nextTool, nextConstraint);
+    }
     function ensurePivotProxy() {
         if (pivotProxy)
             return pivotProxy;
@@ -42,13 +75,13 @@ export function createBabylonTransformGizmoController(options) {
         };
         return pivotProxy;
     }
-    function setPivotProxyTransform(pivot) {
+    function setPivotProxyTransform(pivot, rotation = { x: 0, y: 0, z: 0 }) {
         const proxy = ensurePivotProxy();
         const Vector3 = options.babylon.Vector3;
         if (!proxy || !Vector3)
             return null;
         proxy.position = new Vector3(pivot.position.x, pivot.position.y, pivot.position.z);
-        proxy.rotation = new Vector3(0, 0, 0);
+        proxy.rotation = new Vector3(rotation.x, rotation.y, rotation.z);
         proxy.scaling = new Vector3(1, 1, 1);
         return proxy;
     }
@@ -68,28 +101,31 @@ export function createBabylonTransformGizmoController(options) {
             catch { }
         });
     }
-    function registerDragObserversFor(gizmo) {
-        const axisGizmos = [
-            gizmo?.xGizmo,
-            gizmo?.yGizmo,
-            gizmo?.zGizmo,
-            gizmo?.uniformScaleGizmo,
-            gizmo?.xPlaneGizmo,
-            gizmo?.yPlaneGizmo,
-            gizmo?.zPlaneGizmo,
+    function registerDragObserversFor(activeTool, gizmo) {
+        const handleKeys = [
+            'xGizmo',
+            'yGizmo',
+            'zGizmo',
+            'uniformScaleGizmo',
+            'xPlaneGizmo',
+            'yPlaneGizmo',
+            'zPlaneGizmo',
         ];
-        for (const axis of axisGizmos) {
-            const behavior = axis?.dragBehavior;
-            addObserver(behavior?.onDragStartObservable, beginDrag);
+        for (const handleKey of handleKeys) {
+            const activeConstraint = resolveBabylonTransformHandleConstraint(activeTool, handleKey);
+            if (!activeConstraint)
+                continue;
+            const behavior = gizmo?.[handleKey]?.dragBehavior;
+            addObserver(behavior?.onDragStartObservable, () => beginDrag(activeConstraint));
             addObserver(behavior?.onDragObservable, updateDrag);
             addObserver(behavior?.onDragEndObservable, endDrag);
         }
     }
     function registerDragObservers() {
         clearDragObservers();
-        registerDragObserversFor(manager.gizmos?.positionGizmo);
-        registerDragObserversFor(manager.gizmos?.rotationGizmo);
-        registerDragObserversFor(manager.gizmos?.scaleGizmo);
+        registerDragObserversFor('move', manager.gizmos?.positionGizmo);
+        registerDragObserversFor('rotate', manager.gizmos?.rotationGizmo);
+        registerDragObserversFor('scale', manager.gizmos?.scaleGizmo);
     }
     function applySpacePreference() {
         const matchAttachedMesh = space === 'local';
@@ -105,7 +141,15 @@ export function createBabylonTransformGizmoController(options) {
                 }
             }
             catch { }
-            for (const axis of [gizmo?.xGizmo, gizmo?.yGizmo, gizmo?.zGizmo]) {
+            for (const axis of [
+                gizmo?.xGizmo,
+                gizmo?.yGizmo,
+                gizmo?.zGizmo,
+                gizmo?.xPlaneGizmo,
+                gizmo?.yPlaneGizmo,
+                gizmo?.zPlaneGizmo,
+                gizmo?.uniformScaleGizmo,
+            ]) {
                 try {
                     if ('updateGizmoRotationToMatchAttachedMesh' in (axis ?? {})) {
                         axis.updateGizmoRotationToMatchAttachedMesh = matchAttachedMesh;
@@ -115,25 +159,26 @@ export function createBabylonTransformGizmoController(options) {
             }
         }
     }
+    function applyHandlePreference() {
+        const positionGizmo = manager.gizmos?.positionGizmo;
+        if (positionGizmo) {
+            try {
+                positionGizmo.planarGizmoEnabled = tool === 'move';
+            }
+            catch { }
+        }
+    }
     function attachCurrentSelection() {
         const activeTool = activeTransformTool();
-        const viewPlaneMove = activeTool === 'move' && constraint === 'view-plane';
-        manager.positionGizmoEnabled = activeTool === 'move' && !viewPlaneMove;
+        manager.positionGizmoEnabled = activeTool === 'move';
         manager.rotationGizmoEnabled = activeTool === 'rotate';
         manager.scaleGizmoEnabled = activeTool === 'scale';
+        applyHandlePreference();
         applySpacePreference();
         registerDragObservers();
         let target = null;
-        if (activeTool && !viewPlaneMove) {
-            const batchTransformTargetIds = getBatchTransformTargetIds();
-            if (batchTransformTargetIds.length > 1) {
-                const pivot = options.projection.getSelectionPivot(batchTransformTargetIds);
-                target = pivot ? setPivotProxyTransform(pivot) : null;
-            }
-            else {
-                const activeTargetId = getActiveTargetId();
-                target = activeTargetId ? options.projection.getAttachableRoot(activeTargetId) : null;
-            }
+        if (activeTool) {
+            target = attachNativeTransformProxy(getCurrentTransformTargetIds());
         }
         try {
             manager.attachToNode?.(target ?? null);
@@ -141,23 +186,86 @@ export function createBabylonTransformGizmoController(options) {
         catch (error) {
             options.logger?.warn?.('[BabylonTransformGizmoController] failed to attach gizmo', error);
         }
+        updateFreeMoveHandle();
     }
-    function beginDrag() {
+    function beginDrag(activeConstraint = constraint) {
         if (activeDrag)
             return;
         const activeTool = activeTransformTool();
         if (!activeTool)
             return;
-        const targetIds = selectedNodeIds.length > 1
-            ? getBatchTransformTargetIds()
-            : [getActiveTargetId()].filter((nodeId) => !!nodeId);
-        const drag = createActiveDrag(activeTool, targetIds, activeTool === 'move' ? constraint : 'axis');
+        const duplicate = pendingDuplicateDrag;
+        pendingDuplicateDrag = false;
+        const targetIds = resolveDragTargetIds(activeTool, getCurrentTransformTargetIds(), activeConstraint, duplicate);
+        const drag = createActiveDrag(activeTool, targetIds, activeConstraint, duplicate);
         if (!drag)
             return;
         activeDrag = drag;
         options.onDragStart?.(activeDrag);
     }
-    function createActiveDrag(activeTool, targetIds, activeConstraint) {
+    function resolveDragTargetIds(activeTool, targetIds, activeConstraint, duplicate) {
+        if (!duplicate || targetIds.length === 0)
+            return targetIds;
+        const beforeTransforms = options.projection.readNodeTransforms(targetIds);
+        const validTargetIds = targetIds.filter(nodeId => !!beforeTransforms[nodeId]);
+        if (validTargetIds.length === 0)
+            return [];
+        const duplicateResult = options.onDuplicateDragStart?.({
+            targetIds: validTargetIds,
+            activeId: selectedNodeId && validTargetIds.includes(selectedNodeId) ? selectedNodeId : validTargetIds[validTargetIds.length - 1] ?? null,
+            tool: activeTool,
+            space,
+            constraint: activeConstraint,
+            beforeTransforms,
+        });
+        if (!duplicateResult?.targetIds.length)
+            return [];
+        selectedNodeIds = [...duplicateResult.targetIds];
+        selectedNodeId = duplicateResult.activeId && selectedNodeIds.includes(duplicateResult.activeId)
+            ? duplicateResult.activeId
+            : selectedNodeIds[selectedNodeIds.length - 1] ?? null;
+        if (!attachDragTargetIds(selectedNodeIds))
+            return [];
+        return selectedNodeIds;
+    }
+    function attachDragTargetIds(targetIds) {
+        const target = attachNativeTransformProxy(targetIds);
+        if (!target)
+            return false;
+        try {
+            manager.attachToNode?.(target);
+            updateFreeMoveHandle();
+            return true;
+        }
+        catch (error) {
+            options.logger?.warn?.('[BabylonTransformGizmoController] failed to attach duplicate drag target', error);
+            return false;
+        }
+    }
+    function attachNativeTransformProxy(targetIds) {
+        const validTargetIds = targetIds.filter(nodeId => !!options.projection.getAttachableRoot(nodeId));
+        if (validTargetIds.length === 0)
+            return null;
+        const pivot = validTargetIds.length > 1
+            ? options.projection.getSelectionPivot(validTargetIds)
+            : createSingleTargetPivot(validTargetIds[0]);
+        if (!pivot)
+            return null;
+        const rotation = validTargetIds.length === 1 && space === 'local'
+            ? options.projection.readNodeTransform(validTargetIds[0])?.rotation ?? { x: 0, y: 0, z: 0 }
+            : { x: 0, y: 0, z: 0 };
+        return setPivotProxyTransform(pivot, rotation);
+    }
+    function createSingleTargetPivot(nodeId) {
+        const transform = options.projection.readNodeTransform(nodeId);
+        return transform
+            ? {
+                mode: 'selection-center',
+                position: transform.position,
+            }
+            : null;
+    }
+    function createActiveDrag(activeTool, targetIds, activeConstraint, duplicate = false) {
         if (targetIds.length === 0)
             return null;
         const beforeTransforms = options.projection.readNodeTransforms(targetIds);
@@ -183,55 +291,34 @@ export function createBabylonTransformGizmoController(options) {
             pivot,
             before,
             beforeTransforms,
+            duplicate,
+            proxyStart: readNativeProxyTransform(pivot),
         };
     }
     function updateDrag() {
         if (!activeDrag)
             return;
-        if (activeDrag.targetIds.length > 1) {
-            const currentTransforms = previewBatchTransform(activeDrag);
-            const current = activeDrag.activeId
-                ? currentTransforms[activeDrag.activeId] ?? Object.values(currentTransforms)[0] ?? null
-                : Object.values(currentTransforms)[0] ?? null;
-            if (!current)
-                return;
-            options.onDragUpdate?.({ ...activeDrag, current });
-            return;
-        }
-        if (!activeDrag.nodeId)
-            return;
-        const current = options.projection.readNodeTransform(activeDrag.nodeId);
+        const currentTransforms = previewBatchTransform(activeDrag);
+        const current = activeDrag.activeId
+            ? currentTransforms[activeDrag.activeId] ?? Object.values(currentTransforms)[0] ?? null
+            : Object.values(currentTransforms)[0] ?? null;
         if (!current)
             return;
+        if (activeDrag.tool === 'move') {
+            const pivotPosition = resolvePreviewPivotPosition(activeDrag, currentTransforms);
+            if (pivotPosition)
+                setFreeMoveHandlePosition(pivotPosition);
+        }
         options.onDragUpdate?.({ ...activeDrag, current });
     }
     function endDrag() {
         const drag = activeDrag;
         if (!drag)
             return;
+        const afterTransforms = previewBatchTransform(drag);
         activeDrag = null;
-        if (drag.targetIds.length > 1) {
-            const afterTransforms = previewBatchTransform(drag);
-            emitTransformCommit(drag, afterTransforms);
-            attachCurrentSelection();
-            return;
-        }
-        if (!drag.nodeId || !drag.before) {
-            options.onDragCancel?.(drag);
-            return;
-        }
-        const after = options.projection.readNodeTransform(drag.nodeId);
-        if (!after) {
-            options.onDragCancel?.(drag);
-            return;
-        }
-        options.onDragEnd?.({
-            nodeId: drag.nodeId,
-            tool: drag.tool,
-            space: drag.space,
-            before: drag.before,
-            after,
-        });
+        emitTransformCommit(drag, afterTransforms);
+        attachCurrentSelection();
     }
     function emitTransformCommit(drag, afterTransforms) {
         if (drag.targetIds.length === 1) {
@@ -246,6 +333,7 @@ export function createBabylonTransformGizmoController(options) {
                 nodeId,
                 tool: drag.tool,
                 space: drag.space,
+                constraint: drag.constraint,
                 before,
                 after,
             });
@@ -273,14 +361,19 @@ export function createBabylonTransformGizmoController(options) {
             rotation: { x: 0, y: 0, z: 0 },
             scale: { x: 1, y: 1, z: 1 },
         });
+        const proxyStart = drag.proxyStart ?? {
+            position: drag.pivot.position,
+            rotation: { x: 0, y: 0, z: 0 },
+            scale: { x: 1, y: 1, z: 1 },
+        };
         if (drag.tool === 'move') {
-            return previewMoveWithDelta(drag, subtractVec3(pivotTransform.position, drag.pivot.position));
+            return previewMoveWithDelta(drag, subtractVec3(pivotTransform.position, proxyStart.position));
         }
         if (drag.tool === 'rotate') {
-            return previewRotateWithDelta(drag, pivotTransform.rotation);
+            return previewRotateWithDelta(drag, subtractVec3(pivotTransform.rotation, proxyStart.rotation));
         }
         if (drag.tool === 'scale') {
-            return previewScaleWithDelta(drag, pivotTransform.scale);
+            return previewScaleWithDelta(drag, divideVec3(pivotTransform.scale, proxyStart.scale));
         }
         return {};
     }
@@ -290,7 +383,7 @@ export function createBabylonTransformGizmoController(options) {
             const before = drag.beforeTransforms[nodeId];
             if (!before)
                 continue;
-            transforms[nodeId] = translateTransform(before, delta);
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, translateTransform(before, delta));
         }
         options.projection.setNodeTransformsPreview(transforms);
         return transforms;
@@ -314,6 +407,7 @@ export function createBabylonTransformGizmoController(options) {
                 rotation: addVec3(before.rotation, rotationDelta),
                 scale: before.scale,
             };
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, transforms[nodeId]);
         }
         options.projection.setNodeTransformsPreview(transforms);
         return transforms;
@@ -335,10 +429,26 @@ export function createBabylonTransformGizmoController(options) {
                 rotation: before.rotation,
                 scale: multiplyVec3(before.scale, safeScale),
             };
+            transforms[nodeId] = applySnapToTransform(drag, nodeId, transforms[nodeId]);
         }
         options.projection.setNodeTransformsPreview(transforms);
         return transforms;
     }
+    function applySnapToTransform(drag, nodeId, after) {
+        if (!operationSettings.snap.enabled)
+            return after;
+        const before = drag.beforeTransforms[nodeId];
+        if (!before)
+            return after;
+        return snapEditorTransformSnapshot(before, after, drag.tool, operationSettings.snap);
+    }
+    function readNativeProxyTransform(pivot) {
+        return readProjectionLikeTransform(pivotProxy, {
+            position: pivot.position,
+            rotation: { x: 0, y: 0, z: 0 },
+            scale: { x: 1, y: 1, z: 1 },
+        });
+    }
     function readProjectionLikeTransform(node, fallback) {
         const rotation = node?.rotationQuaternion?.toEulerAngles?.() ?? node?.rotation;
         return {
@@ -387,6 +497,13 @@ export function createBabylonTransformGizmoController(options) {
             z: left.z * right.z,
         };
     }
+    function divideVec3(left, right) {
+        return {
+            x: Math.abs(right.x) > 0.000001 ? left.x / right.x : 1,
+            y: Math.abs(right.y) > 0.000001 ? left.y / right.y : 1,
+            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);
     }
@@ -418,13 +535,15 @@ export function createBabylonTransformGizmoController(options) {
         };
     }
     function isViewPlaneMoveCandidate(event) {
-        if (disposed || activeDrag || tool !== 'move' || constraint !== 'view-plane' || event.button !== 0)
+        if (disposed || activeDrag || tool !== 'move' || event.button !== 0)
             return false;
-        const targetIds = selectedNodeIds.length > 1
-            ? getBatchTransformTargetIds()
-            : [getActiveTargetId()].filter((nodeId) => !!nodeId);
+        const targetIds = getCurrentTransformTargetIds();
         if (targetIds.length === 0)
             return false;
+        if (pickFreeMoveHandleAt(event.clientX, event.clientY))
+            return true;
+        if (constraint !== 'free')
+            return false;
         const pickedId = options.projection.pickNodeIdAt(event.clientX, event.clientY);
         return !!pickedId && targetIds.includes(pickedId);
     }
@@ -432,18 +551,22 @@ export function createBabylonTransformGizmoController(options) {
         if (disposed || activeDrag || event.button !== 0)
             return false;
         const activeTool = activeTransformTool();
-        if (!activeTool || (activeTool === 'move' && constraint === 'view-plane'))
+        if (!activeTool)
             return false;
         const picked = pickGizmoMeshAt(event.clientX, event.clientY);
-        return !!picked && isGizmoNode(picked);
+        if (isFreeMoveHandleNode(picked))
+            return false;
+        const candidate = !!picked && isGizmoNode(picked);
+        if (candidate)
+            pendingDuplicateDrag = isDuplicateDragModifier(event);
+        return candidate;
     }
     function beginViewPlaneMove(event) {
         if (!isViewPlaneMoveCandidate(event))
             return false;
-        const targetIds = selectedNodeIds.length > 1
-            ? getBatchTransformTargetIds()
-            : [getActiveTargetId()].filter((nodeId) => !!nodeId);
-        const drag = createActiveDrag('move', targetIds, 'view-plane');
+        const duplicate = isDuplicateDragModifier(event);
+        const targetIds = resolveDragTargetIds('move', getCurrentTransformTargetIds(), 'free', duplicate);
+        const drag = createActiveDrag('move', targetIds, 'free', duplicate);
         if (!drag)
             return false;
         const startPoint = projectPointerToViewPlane(event.clientX, event.clientY, drag.pivot.position);
@@ -457,6 +580,9 @@ export function createBabylonTransformGizmoController(options) {
         options.onDragStart?.(drag);
         return true;
     }
+    function isDuplicateDragModifier(event) {
+        return event.altKey === true;
+    }
     function updateViewPlaneMove(event) {
         const drag = activeDrag;
         if (!drag?.viewPlane || drag.viewPlane.pointerId !== event.pointerId || disposed)
@@ -464,7 +590,9 @@ export function createBabylonTransformGizmoController(options) {
         const currentPoint = projectPointerToViewPlane(event.clientX, event.clientY, drag.pivot.position);
         if (!currentPoint)
             return false;
-        const transforms = previewMoveWithDelta(drag, subtractVec3(currentPoint, drag.viewPlane.startPoint));
+        const delta = subtractVec3(currentPoint, drag.viewPlane.startPoint);
+        const transforms = previewMoveWithDelta(drag, delta);
+        setFreeMoveHandlePosition(resolvePreviewPivotPosition(drag, transforms) ?? addVec3(drag.pivot.position, delta));
         const current = drag.activeId
             ? transforms[drag.activeId] ?? Object.values(transforms)[0] ?? null
             : Object.values(transforms)[0] ?? null;
@@ -485,6 +613,16 @@ export function createBabylonTransformGizmoController(options) {
         attachCurrentSelection();
         return true;
     }
+    function resolvePreviewPivotPosition(drag, transforms) {
+        for (const nodeId of drag.targetIds) {
+            const before = drag.beforeTransforms[nodeId];
+            const after = transforms[nodeId];
+            if (!before || !after)
+                continue;
+            return addVec3(drag.pivot.position, subtractVec3(after.position, before.position));
+        }
+        return null;
+    }
     function projectPointerToViewPlane(clientX, clientY, planePoint) {
         const camera = options.scene.activeCamera ?? options.scene.cameraToUseForPointers ?? null;
         const Vector3 = options.babylon.Vector3;
@@ -516,6 +654,113 @@ export function createBabylonTransformGizmoController(options) {
         const forwardZ = options.scene.useRightHandedSystem ? -1 : 1;
         return readVec3Like(camera.getDirection(new Vector3(0, 0, forwardZ)));
     }
+    function pickPlacementHit(clientX, clientY, mode) {
+        if (mode === 'off')
+            return null;
+        if (mode === 'ground')
+            return pickGroundPlacementHit(clientX, clientY);
+        return pickSurfacePlacementHit(clientX, clientY);
+    }
+    function pickGroundPlacementHit(clientX, clientY) {
+        const ray = createScenePointerRay(clientX, clientY);
+        const origin = readVec3Like(ray?.origin);
+        const direction = readVec3Like(ray?.direction);
+        if (!origin || !direction || Math.abs(direction.y) < 0.000001)
+            return null;
+        const t = -origin.y / direction.y;
+        if (!Number.isFinite(t) || t < 0)
+            return null;
+        return {
+            mode: 'ground',
+            position: addVec3(origin, scaleVec3(direction, t)),
+            normal: { x: 0, y: 1, z: 0 },
+            nodeId: null,
+        };
+    }
+    function pickSurfacePlacementHit(clientX, clientY) {
+        if (!canvas || typeof options.scene.pick !== 'function')
+            return null;
+        const rect = canvas.getBoundingClientRect();
+        const pick = options.scene.pick(clientX - rect.left, clientY - rect.top, (mesh) => !isPlacementPickIgnored(mesh));
+        const point = readVec3Like(pick?.pickedPoint);
+        if (!pick?.hit || !point)
+            return null;
+        const normal = readVec3Like(pick?.getNormal?.(true)) ?? readVec3Like(pick?.normal);
+        return {
+            mode: 'surface',
+            position: point,
+            normal: normal ?? undefined,
+            nodeId: options.projection.resolveProjectionNodeId(pick.pickedMesh ?? null),
+        };
+    }
+    function isPlacementPickIgnored(node) {
+        let current = node;
+        while (current) {
+            if (current.metadata?.editorProjectionHelper)
+                return true;
+            if (current.metadata?.editorTransformFreeMoveHandle)
+                return true;
+            if (current.metadata?.editorPlacementMarker)
+                return true;
+            current = current.parent ?? null;
+        }
+        return false;
+    }
+    function createScenePointerRay(clientX, clientY) {
+        const camera = options.scene.activeCamera ?? options.scene.cameraToUseForPointers ?? null;
+        const Matrix = options.babylon.Matrix;
+        if (!canvas || !camera || !Matrix?.Identity || !options.scene.createPickingRay)
+            return null;
+        const rect = canvas.getBoundingClientRect();
+        return options.scene.createPickingRay(clientX - rect.left, clientY - rect.top, Matrix.Identity(), camera);
+    }
+    function ensurePlacementMarker() {
+        if (placementMarker)
+            return placementMarker;
+        const MeshBuilder = options.babylon.MeshBuilder;
+        const StandardMaterial = options.babylon.StandardMaterial;
+        const Color3 = options.babylon.Color3;
+        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        if (!MeshBuilder?.CreateSphere || !utilityScene)
+            return null;
+        placementMarker = MeshBuilder.CreateSphere('editor.placement.marker', { diameter: 0.32, segments: 16 }, utilityScene);
+        placementMarker.metadata = {
+            ...(placementMarker.metadata ?? {}),
+            editorProjectionHelper: true,
+            editorPlacementMarker: true,
+        };
+        placementMarker.isPickable = false;
+        if (StandardMaterial && Color3) {
+            placementMarkerMaterial = new StandardMaterial('editor.placement.marker.material', utilityScene);
+            placementMarkerMaterial.diffuseColor = new Color3(0.18, 0.86, 0.78);
+            placementMarkerMaterial.emissiveColor = new Color3(0.1, 0.62, 0.56);
+            placementMarkerMaterial.specularColor = new Color3(0.04, 0.18, 0.16);
+            placementMarker.material = placementMarkerMaterial;
+        }
+        setPlacementMarkerVisible(false);
+        return placementMarker;
+    }
+    function setPlacementMarkerVisible(visible) {
+        if (!placementMarker)
+            return;
+        placementMarker.isVisible = visible;
+        try {
+            placementMarker.setEnabled?.(visible);
+        }
+        catch { }
+    }
+    function setPlacementMarker(hit) {
+        if (!hit) {
+            setPlacementMarkerVisible(false);
+            return;
+        }
+        const marker = ensurePlacementMarker();
+        const Vector3 = options.babylon.Vector3;
+        if (!marker || !Vector3)
+            return;
+        marker.position = new Vector3(hit.position.x, hit.position.y, hit.position.z);
+        setPlacementMarkerVisible(true);
+    }
     function pickGizmoMeshAt(clientX, clientY) {
         if (!canvas)
             return null;
@@ -529,10 +774,88 @@ export function createBabylonTransformGizmoController(options) {
         const scenePick = typeof options.scene.pick === 'function' ? options.scene.pick(x, y) : null;
         return scenePick?.hit ? scenePick.pickedMesh ?? null : null;
     }
+    function pickFreeMoveHandleAt(clientX, clientY) {
+        if (!canvas || !freeMoveHandle)
+            return null;
+        const rect = canvas.getBoundingClientRect();
+        const x = clientX - rect.left;
+        const y = clientY - rect.top;
+        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        const pick = typeof utilityScene?.pick === 'function'
+            ? utilityScene.pick(x, y, (mesh) => isFreeMoveHandleNode(mesh))
+            : null;
+        return pick?.hit && isFreeMoveHandleNode(pick.pickedMesh) ? pick.pickedMesh : null;
+    }
+    function ensureFreeMoveHandle() {
+        if (freeMoveHandle)
+            return freeMoveHandle;
+        const MeshBuilder = options.babylon.MeshBuilder;
+        const StandardMaterial = options.babylon.StandardMaterial;
+        const Color3 = options.babylon.Color3;
+        const utilityScene = manager.utilityLayer?.utilityLayerScene;
+        if (!MeshBuilder?.CreateSphere || !utilityScene)
+            return null;
+        freeMoveHandle = MeshBuilder.CreateSphere('editor.transform.freeMoveHandle', { diameter: 0.22, segments: 12 }, utilityScene);
+        freeMoveHandle.metadata = {
+            ...(freeMoveHandle.metadata ?? {}),
+            editorProjectionHelper: true,
+            editorTransformFreeMoveHandle: true,
+        };
+        freeMoveHandle.isPickable = true;
+        if (StandardMaterial && Color3) {
+            freeMoveHandleMaterial = new StandardMaterial('editor.transform.freeMoveHandle.material', utilityScene);
+            freeMoveHandleMaterial.diffuseColor = new Color3(1, 0.82, 0.28);
+            freeMoveHandleMaterial.emissiveColor = new Color3(1, 0.68, 0.18);
+            freeMoveHandleMaterial.specularColor = new Color3(0.2, 0.18, 0.08);
+            freeMoveHandle.material = freeMoveHandleMaterial;
+        }
+        setFreeMoveHandleVisible(false);
+        return freeMoveHandle;
+    }
+    function setFreeMoveHandleVisible(visible) {
+        if (!freeMoveHandle)
+            return;
+        freeMoveHandle.isVisible = visible;
+        try {
+            freeMoveHandle.setEnabled?.(visible);
+        }
+        catch { }
+    }
+    function setFreeMoveHandlePosition(position) {
+        const handle = ensureFreeMoveHandle();
+        const Vector3 = options.babylon.Vector3;
+        if (!handle || !Vector3)
+            return;
+        handle.position = new Vector3(position.x, position.y, position.z);
+        setFreeMoveHandleVisible(true);
+    }
+    function updateFreeMoveHandle() {
+        if (tool !== 'move' || activeDrag) {
+            setFreeMoveHandleVisible(false);
+            return;
+        }
+        const targetIds = getCurrentTransformTargetIds();
+        if (targetIds.length === 0) {
+            setFreeMoveHandleVisible(false);
+            return;
+        }
+        const pivot = targetIds.length > 1
+            ? options.projection.getSelectionPivot(targetIds)
+            : null;
+        const position = pivot?.position
+            ?? (targetIds[0] ? options.projection.readNodeTransform(targetIds[0])?.position : null);
+        if (!position) {
+            setFreeMoveHandleVisible(false);
+            return;
+        }
+        setFreeMoveHandlePosition(position);
+    }
     function isGizmoNode(node) {
         let current = node;
         const roots = collectCurrentGizmoRoots();
         while (current) {
+            if (isFreeMoveHandleNode(current))
+                return false;
             if (roots.has(current))
                 return true;
             if (current.metadata?.editorProjection?.nodeId)
@@ -546,6 +869,15 @@ export function createBabylonTransformGizmoController(options) {
         }
         return false;
     }
+    function isFreeMoveHandleNode(node) {
+        let current = node;
+        while (current) {
+            if (current.metadata?.editorTransformFreeMoveHandle)
+                return true;
+            current = current.parent ?? null;
+        }
+        return false;
+    }
     function collectCurrentGizmoRoots() {
         const roots = new Set();
         const activeTool = activeTransformTool();
@@ -591,6 +923,7 @@ export function createBabylonTransformGizmoController(options) {
                 return;
             controller.cancelDrag();
             tool = nextTool;
+            constraint = normalizeConstraintForTool(tool, constraint) ?? 'axis';
             attachCurrentSelection();
         },
         setSpace(nextSpace) {
@@ -605,12 +938,25 @@ export function createBabylonTransformGizmoController(options) {
         setConstraint(nextConstraint) {
             if (disposed)
                 return;
-            if (constraint === nextConstraint)
+            const normalized = normalizeConstraintForTool(tool, nextConstraint) ?? 'axis';
+            if (constraint === normalized)
                 return;
             controller.cancelDrag();
-            constraint = nextConstraint;
+            constraint = normalized;
             attachCurrentSelection();
         },
+        setOperationSettings(settings) {
+            if (disposed)
+                return;
+            operationSettings = cloneOperationSettings(settings);
+            if (activeDrag)
+                updateDrag();
+        },
+        preparePointerDrag(event) {
+            if (disposed || event.button !== 0)
+                return;
+            pendingDuplicateDrag = isDuplicateDragModifier(event);
+        },
         setSelectedNode(nextNodeId) {
             if (disposed)
                 return;
@@ -648,6 +994,8 @@ export function createBabylonTransformGizmoController(options) {
         beginViewPlaneMove,
         updateViewPlaneMove,
         endViewPlaneMove,
+        pickPlacementHit,
+        setPlacementMarker,
         cancelDrag() {
             const drag = activeDrag;
             if (!drag)
@@ -655,11 +1003,11 @@ export function createBabylonTransformGizmoController(options) {
             activeDrag = null;
             if (drag.targetIds.length > 1) {
                 options.projection.setNodeTransformsPreview(drag.beforeTransforms);
-                attachCurrentSelection();
             }
             else if (drag.nodeId && drag.before) {
                 options.projection.setNodeTransformPreview(drag.nodeId, drag.before);
             }
+            attachCurrentSelection();
             options.onDragCancel?.(drag);
         },
         dispose() {
@@ -679,11 +1027,42 @@ export function createBabylonTransformGizmoController(options) {
                 pivotProxy?.dispose?.();
             }
             catch { }
+            try {
+                freeMoveHandle?.dispose?.();
+            }
+            catch { }
+            try {
+                freeMoveHandleMaterial?.dispose?.();
+            }
+            catch { }
+            try {
+                placementMarker?.dispose?.();
+            }
+            catch { }
+            try {
+                placementMarkerMaterial?.dispose?.();
+            }
+            catch { }
             pivotProxy = null;
+            freeMoveHandle = null;
+            freeMoveHandleMaterial = null;
+            placementMarker = null;
+            placementMarkerMaterial = null;
             disposed = true;
         },
     };
     attachCurrentSelection();
     return controller;
 }
+function cloneOperationSettings(settings) {
+    return {
+        snap: {
+            enabled: settings.snap.enabled,
+            moveStep: settings.snap.moveStep,
+            rotateStepDegrees: settings.snap.rotateStepDegrees,
+            scaleStep: settings.snap.scaleStep,
+        },
+        placementMode: settings.placementMode,
+    };
+}
 //# sourceMappingURL=transform-gizmo-controller.js.map