@viamrobotics/motion-tools 1.32.0 → 1.33.1

package/dist/components/SelectedTransformControls.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { useThrelte } from '@threlte/core'
 	import { TransformControls } from '@threlte/extras'
-	import { Matrix4, Quaternion, Vector3 } from 'three'
+	import { Matrix4 } from 'three'
 
 	import type { FrameEditSession } from '../editing/FrameEditSession'
 
@@ -11,14 +11,7 @@
 	import { useFrameEditSession } from '../hooks/useFrameEditSession.svelte'
 	import { usePartConfig } from '../hooks/usePartConfig.svelte'
 	import { useSettings } from '../hooks/useSettings.svelte'
-	import {
-		createPose,
-		matrixToPose,
-		poseToMatrix,
-		quaternionToPose,
-		solveEditedMatrix,
-		vector3ToPose,
-	} from '../transform'
+	import { createPose, matrixToPose, poseToMatrix, solveEditedMatrix } from '../transform'
 
 	const { scene } = useThrelte()
 	const settings = useSettings()
@@ -64,9 +57,10 @@
 	})
 	const isSphereScale = $derived(activeMode === 'scale' && sphere.current !== undefined)
 	const isCapsuleScale = $derived(activeMode === 'scale' && capsule.current !== undefined)
+	const transforming = $derived(
+		ref && entity && activeMode && !isFragmentComponentWithVariables && !invisible.current
+	)
 
-	const quaternion = new Quaternion()
-	const vector3 = new Vector3()
 	const refPose = createPose()
 	const tempRefMatrix = new Matrix4()
 	const tempEditedMatrix = new Matrix4()
@@ -119,28 +113,14 @@
 	}
 
 	const onChange = () => {
-		if (!ref || !entity || !activeMode) {
-			return
-		}
+		if (!ref || !entity || !activeMode) return
 
 		const isFrameEntity = entity.has(traits.FramesAPI)
-
 		if (activeMode === 'translate' || activeMode === 'rotate') {
 			if (isFrameEntity) {
 				stageFrameTransform()
 			} else {
-				const matrix = entity.get(traits.Matrix)
-				if (matrix) {
-					matrixToPose(matrix, tempPose)
-					if (activeMode === 'translate') {
-						vector3ToPose(ref.getWorldPosition(vector3), tempPose)
-					} else {
-						quaternionToPose(ref.getWorldQuaternion(quaternion), tempPose)
-						ref.quaternion.copy(quaternion)
-					}
-					poseToMatrix(tempPose, matrix)
-					entity.changed(traits.Matrix)
-				}
+				stageLocalTransform()
 			}
 		} else {
 			// scale → bake the gizmo's scale factor into the geometry trait,
@@ -194,40 +174,46 @@
 	}
 
 	/**
-	 * Frame.svelte renders frame entities by writing the entity's WorldMatrix
-	 * into group.matrix and decomposing it into position/quaternion. The gizmo's
-	 * Three.js parent has identity world, so `ref.position` / `ref.quaternion`
-	 * are world-space values. Matrix and EditedMatrix store local-to-parent
-	 * transforms, so we left-multiply by the parent's inverted WorldMatrix
-	 * before staging — otherwise WorldMatrix recomposition (parent × edited)
-	 * re-applies the parent's rotation/translation and the frame ends up at
-	 * parent × where-the-user-pulled-it.
+	 * Build the entity's parent-relative drag target from the gizmo's world-space
+	 * `ref` transform into `out`.
 	 *
-	 * With a kinematic offset (LiveMatrix + Matrix both present), the local
-	 * target M(local) feeds solveEditedMatrix to back out the EditedMatrix
-	 * that satisfies live × baseline⁻¹ × edited = local.
+	 * Entity renderers mount at the scene root with `matrixAutoUpdate = false`
+	 * and recompose `group.matrix` from the `WorldMatrix` trait, so
+	 * `ref.position` / `ref.quaternion` are world-space. Matrix-shaped traits
+	 * store local-to-parent, so we left-multiply by the parent's inverted
+	 * WorldMatrix. Otherwise recomposition (parentWorld × local) re-applies the
+	 * parent transform and the entity lands at parentWorld × where-it-was-dragged.
 	 */
-	const stageFrameTransform = () => {
+	const computeLocalDragTarget = (out: Matrix4) => {
 		if (!ref || !entity) return
 
-		tempRefMatrix.makeRotationFromQuaternion(ref.quaternion)
-		tempRefMatrix.setPosition(ref.position)
+		out.makeRotationFromQuaternion(ref.quaternion)
+		out.setPosition(ref.position)
 
-		const parentEntity = entity.targetFor(relations.ChildOf)
-		const parentWorld = parentEntity?.get(traits.WorldMatrix)
+		const parentWorld = entity.targetFor(relations.ChildOf)?.get(traits.WorldMatrix)
 		if (parentWorld) {
 			tempParentInverse.copy(parentWorld).invert()
-			tempRefMatrix.premultiply(tempParentInverse)
+			out.premultiply(tempParentInverse)
 		}
+	}
+
+	/**
+	 * Stages a translate/rotate drag for a frame system entity into the edit
+	 * session. With a kinematic offset (LiveMatrix + Matrix both present), the
+	 * parent-relative target feeds solveEditedMatrix to back out the EditedMatrix
+	 * satisfying live × baseline⁻¹ × edited = local. Without one, Frame.svelte's
+	 * blend short-circuits to EditedMatrix, so we stage the target pose directly.
+	 */
+	const stageFrameTransform = () => {
+		if (!ref || !entity) return
 
+		computeLocalDragTarget(tempRefMatrix)
 		matrixToPose(tempRefMatrix, refPose)
 
 		const live = liveMatrix.current
 		const config = configMatrix.current
 
 		if (!live || !config) {
-			// No live matrix available — Frame.svelte's blend short-circuits to
-			// editedMatrix, so the parent-relative target is what we stage.
 			if (activeMode === 'translate') {
 				session?.stagePose(entity, {
 					x: refPose.x,
@@ -249,9 +235,41 @@
 		matrixToPose(tempEditedMatrix, tempPose)
 		session?.stagePose(entity, { ...tempPose })
 	}
+
+	/**
+	 * Stages a translate/rotate drag for a non-frame-system entity (e.g. a gizmo)
+	 * by writing the dragged component into the Matrix trait. Gizmos carry no
+	 * LiveMatrix, so there's no live-pose blend to invert — the parent-relative
+	 * target is the new local transform.
+	 */
+	const stageLocalTransform = () => {
+		if (!ref || !entity) return
+
+		const matrix = entity.get(traits.Matrix)
+		if (!matrix) return
+
+		computeLocalDragTarget(tempRefMatrix)
+
+		// update only the dragged component
+		matrixToPose(matrix, tempPose)
+		matrixToPose(tempRefMatrix, refPose)
+		if (activeMode === 'translate') {
+			tempPose.x = refPose.x
+			tempPose.y = refPose.y
+			tempPose.z = refPose.z
+		} else {
+			tempPose.oX = refPose.oX
+			tempPose.oY = refPose.oY
+			tempPose.oZ = refPose.oZ
+			tempPose.theta = refPose.theta
+		}
+
+		poseToMatrix(tempPose, matrix)
+		entity.changed(traits.Matrix)
+	}
 </script>
 
-{#if ref && entity && activeMode && !isFragmentComponentWithVariables && !invisible.current}
+{#if transforming}
 	{#key entity}
 		<TransformControls
 			object={ref}