@needle-tools/engine 5.1.4 → 5.1.5

package/src/engine-components/DragControlsConstraints.ts

@@ -398,8 +398,11 @@ export class PlaneHeightLockConstraint implements IDragConstraint {
 
 /**
  * Used by {@link SnapToSurfacesDragStrategy} for two-pointer (multi-touch) drags.
- * Casts a downward ray each frame from the follow object's world position and adjusts
- * it so the dragged object's bounding-box contact face rests on the detected surface.
+ * Each frame `MultiTouchDragHandler` aims the snap ray from the pointer origin(s) through the
+ * current two-finger grab midpoint (see {@link setRay}); apply() casts that ray into the scene
+ * and places the follow object so its bounding-box contact face rests on the hit surface with
+ * the object origin at the hit point — the same "snap to what the pointer points at" semantics
+ * as the single-pointer surface raycast.
  *
  * Only injected into the constraint pipeline for multi-touch; the single-pointer path
  * continues to use {@link SnapToSurfacesDragStrategy.update} (pointer ray + drag plane
@@ -409,6 +412,10 @@ export class SnapToSurfaceConstraint implements IDragConstraint {
     private _gameObject: Object3D | null = null;
     private _boundsAtScaleOne: Box3 | null = null;
 
+    /** Snap ray for the current frame. Valid only after {@link setRay}; apply() is a no-op until then. */
+    private readonly _ray = new Ray();
+    private _hasRay = false;
+
     // Per-frame scratch vectors — avoids per-frame allocations.
     private readonly _t1 = new Vector3();
     private readonly _t2 = new Vector3();
@@ -420,19 +427,23 @@ export class SnapToSurfaceConstraint implements IDragConstraint {
     init(ctx: IDragConstraintContext): void {
         this._gameObject = ctx.gameObject;
         this._boundsAtScaleOne = ctx.boundsAtScaleOne;
+        this._hasRay = false;
+    }
+
+    /** Sets the world-space snap ray for this frame. Called by `MultiTouchDragHandler` before the
+     *  constraint pipeline runs. `direction` must be normalized. */
+    setRay(origin: Vector3, direction: Vector3): void {
+        this._ray.origin.copy(origin);
+        this._ray.direction.copy(direction);
+        this._hasRay = true;
     }
 
     apply(followObject: GameObject): void {
-        if (!this._gameObject || !this._boundsAtScaleOne) return;
+        if (!this._gameObject || !this._boundsAtScaleOne || !this._hasRay) return;
 
-        // Cast a downward ray from 0.5 units above the follow object's current world position.
-        // The small upward offset avoids self-intersection when the object sits on a surface.
-        // World-Y down is used; it finds the nearest surface below the follow object.
         const currentWP = followObject.worldPosition;
-        this._t1.set(currentWP.x, currentWP.y + 0.5, currentWP.z);
-        const ray = new Ray(this._t1, _snapToSurfaceDown);
 
-        const hits = this._context.physics.raycastFromRay(ray, {
+        const hits = this._context.physics.raycastFromRay(this._ray, {
             testObject: (o: Object3D) => o !== (followObject as unknown as Object3D) && o !== this._gameObject
         });
 
@@ -469,9 +480,6 @@ export class SnapToSurfaceConstraint implements IDragConstraint {
     }
 }
 
-/** Shared downward direction vector for {@link SnapToSurfaceConstraint}. */
-const _snapToSurfaceDown = new Vector3(0, -1, 0);
-
 
 // #region Utilities
 /**

package/src/engine-components/OrbitControls.ts

@@ -778,12 +778,39 @@ export class OrbitControls extends Behaviour implements ICameraController {
                 this._lookTargetEndPosition.clamp(min, max);
             }
             else {
-                // Interactive use (pan/orbit): smoothly push the target back into bounds
+                // Interactive use (pan/orbit/zoom): smoothly push the target back into
+                // bounds as a RIGID shift — camera and target move by the same delta, so
+                // the camera-target offset is preserved (distance and viewing angles are
+                // untouched; the whole view slides back).
+                //
+                // Preserving the offset is load-bearing, not cosmetic: our three fork keeps
+                // a zoom-to-cursor gesture armed across frames until an update() settles
+                // with zero movement (required for damped zoom to converge). While armed,
+                // every update() re-derives `target` from the camera and turns any offset
+                // change into a dolly along the frozen cursor ray. Clamping only the target
+                // therefore changed the offset each frame, which re-derived the target
+                // outside the bounds again, which clamped again — a positive feedback loop
+                // that flung the camera away exponentially (observed 18m → 10^20m within
+                // ~70 frames). With a rigid shift the re-derived target reproduces the
+                // clamped one exactly, the correction decays geometrically and the gesture
+                // settles normally.
                 const targetVector = this._controls.target;
-                const newTarget = getTempVector(targetVector).clamp(min, max);
+                const delta = getTempVector(targetVector).clamp(min, max).sub(targetVector);
                 const duration = .1;
-                if (duration <= 0) targetVector.copy(newTarget);
-                else targetVector.lerp(newTarget, Math.min(1, this.context.time.deltaTime / duration));
+                if (duration > 0) delta.multiplyScalar(Math.min(1, this.context.time.deltaTime / duration));
+                targetVector.add(delta);
+                // Apply the IDENTICAL delta to the camera position, in the controls'
+                // own space: OrbitControls derives its state from
+                // `object.position - target` directly (parent-naive — three's own
+                // contract says the camera must not sit under a transformed parent,
+                // and all of the controls' math treats position and target as the
+                // same space). Converting the delta through the camera's parent
+                // scales it whenever an ancestor is scaled, so camera and target
+                // would move by different amounts — that changes the derived offset
+                // every frame and re-creates the feedback loop (verified: a 0.456×
+                // scaled ancestor turned the clamp into a ×2.19 camera shift and the
+                // runaway persisted).
+                this._cameraObject?.position.add(delta);
             }
 
             if (debug) {

package/src/engine-components/export/usdz/USDZExporter.ts

@@ -3,7 +3,7 @@ import { Euler, Material, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from "t
 
 import { isDevEnvironment, showBalloonMessage, showBalloonWarning } from "../../../engine/debug/index.js";
 import { findObjectOfType } from "../../../engine/engine_components.js";
-import { KLaEb } from "../../../engine/engine_license.js";
+import { otIKt } from "../../../engine/engine_license.js";
 import { serializable } from "../../../engine/engine_serialization.js";
 import { getFormattedDate, Progress } from "../../../engine/engine_time_utils.js";
 import { DeviceUtilities, getParam } from "../../../engine/engine_utils.js";
@@ -277,7 +277,7 @@ export class USDZExporter extends Behaviour {
         let name = this.exportFileName ?? this.objectToExport?.name ?? this.name;
         name += "-" + getFormattedDate(); // seems iOS caches the file in some cases, this ensures we always have a fresh file
 
-        if (!KLaEb()) {
+        if (!otIKt()) {
             if (name !== "") name += "-";
             name += "MadeWithNeedle";
         }
@@ -682,7 +682,7 @@ export class USDZExporter extends Behaviour {
                     if (debug)
                         showBalloonMessage("Quicklook url: " + callToActionURL);
                     if (callToActionURL) {
-                        if (!KLaEb()) {
+                        if (!otIKt()) {
                             console.warn("Quicklook closed: custom redirects require a Needle Engine Pro license: https://needle.tools/pricing", callToActionURL)
                         }
                         else {
@@ -697,7 +697,7 @@ export class USDZExporter extends Behaviour {
     private buildQuicklookOverlay(): CustomBranding {
         const obj: CustomBranding = {};
         if (this.customBranding) Object.assign(obj, this.customBranding);
-        if (!KLaEb()) {
+        if (!otIKt()) {
             console.log("Custom Quicklook banner text requires pro license: https://needle.tools/pricing");
             obj.callToAction = "Close";
             obj.checkoutTitle = "🌵 Made with Needle";