@needle-tools/engine 4.8.6-next.f3ce848 → 4.8.7-next.3c34e8b

package/src/engine-components/OrbitControls.ts

@@ -649,12 +649,12 @@ export class OrbitControls extends Behaviour implements ICameraController {
             if (this._lookTargetLerpActive) {
                 this._lookTargetLerp01 += this.context.time.deltaTime / this._lookTargetLerpDuration;
                 if (this._lookTargetLerp01 >= 1) {
-                    this._controls.target.copy(this._lookTargetEndPosition);
+                    this.lerpLookTarget(this._lookTargetEndPosition, this._lookTargetEndPosition, 1);
                     this._lookTargetLerpActive = false;
                     this.dispatchEvent(new CameraTargetReachedEvent(this, "lookat"));
                 } else {
                     const t = Mathf.easeInOutCubic(this._lookTargetLerp01);
-                    this._controls.target.lerpVectors(this._lookTargetStartPosition, this._lookTargetEndPosition, t);
+                    this.lerpLookTarget(this._lookTargetStartPosition, this._lookTargetEndPosition, t);
                 }
             }
 
@@ -729,7 +729,9 @@ export class OrbitControls extends Behaviour implements ICameraController {
 
             // this._controls.zoomToCursor = this.zoomToCursor;
             if (!this.context.isInXR) {
-                if (!freeCam && this.lookAtConstraint?.locked) this.setLookTargetFromConstraint(0, this.lookAtConstraint01);
+                if (!freeCam && this.lookAtConstraint?.locked && !this._lookTargetLerpActive) {
+                    this.setLookTargetFromConstraint(0, this.lookAtConstraint01);
+                }
                 this._controls.update(this.context.time.deltaTime);
 
                 if (debug) {
@@ -910,7 +912,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
         }
 
         if (immediateOrDuration === true) {
-            this._controls.target.copy(this._lookTargetEndPosition);
+            this.lerpLookTarget(this._lookTargetEndPosition, this._lookTargetEndPosition, 1);
         }
         else {
             this._lookTargetLerpActive = true;
@@ -941,20 +943,18 @@ export class OrbitControls extends Behaviour implements ICameraController {
             const target = sources[index];
             if (target) {
                 target.getWorldPosition(this._lookTargetEndPosition);
-                this.lerpLookTarget(this._lookTargetEndPosition, t);
+                this.lerpLookTarget(this._controls.target, this._lookTargetEndPosition, t);
                 return true;
             }
         }
         return false;
     }
 
-    /** @deprecated use `controls.target.lerp(position, delta)` */
-    public lerpTarget(position: Vector3, delta: number) { return this.lerpLookTarget(position, delta); }
-
-    private lerpLookTarget(position: Vector3, delta: number) {
+    private lerpLookTarget(start: Vector3, position: Vector3, t: number) {
         if (!this._controls) return;
-        if (delta >= 1) this._controls.target.copy(position);
-        else this._controls.target.lerp(position, delta);
+        if (t >= 1) this._controls.target.copy(position);
+        else this._controls.target.lerpVectors(start, position, t);
+        if (this.lookAtConstraint) this.lookAtConstraint.setConstraintPosition(this._controls.target);
     }
 
     private setTargetFromRaycast(ray?: Ray, immediateOrDuration: number | boolean = false): boolean {
@@ -1063,7 +1063,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             return;
         }
 
-        const verticalFov = options.fov || camera.fov;
+        const verticalFov = fov;
         const horizontalFov = 2 * Math.atan(Math.tan(verticalFov * Math.PI / 360 / 2) * camera.aspect) / Math.PI * 360;
         const fitHeightDistance = size.y / (2 * Math.atan(Math.PI * verticalFov / 360));
         const fitWidthDistance = size.x / (2 * Math.atan(Math.PI * horizontalFov / 360));
@@ -1161,16 +1161,19 @@ declare type FitCameraOptions = {
      * The objects to fit the camera to. If not provided the scene children will be used
      */
     objects?: Object3D[] | Object3D;
-    /** Fit offset: A factor to multiply the distance to the objects by
-     * @default 1.1
-     */
-    fitOffset?: number,
     /** If true the camera will move immediately to the new position, otherwise it will lerp 
      * @default false
      */
     immediate?: boolean,
+
     /** If set to "y" the camera will be centered in the y axis */
     centerCamera?: "none" | "y",
     cameraNearFar?: "keep" | "auto",
+
     fov?: number,
+
+    /** Fit offset: A factor to multiply the distance to the objects by
+     * @default 1.1
+     */
+    fitOffset?: number,
 }

package/src/engine-components/webxr/WebXRImageTracking.ts

@@ -12,6 +12,7 @@ import { imageToCanvas, USDObject, USDWriter, USDZExporterContext } from "../../
 import { USDZExporter } from "../../engine-components/export/usdz/USDZExporter.js";
 import { Behaviour, GameObject } from "../Component.js";
 import { Renderer } from "../Renderer.js";
+import { Context } from "../../engine/engine_context.js";
 
 // https://github.com/immersive-web/marker-tracking/blob/main/explainer.md
 
@@ -159,6 +160,10 @@ class ImageTrackingExtension implements IUSDExporterExtension {
         this.widthInMeters = widthInMeters;
     }
 
+    private getImageTrackingComponents() {
+        return GameObject.findObjectsOfType(WebXRImageTracking, Context.Current).filter(c => c.trackedImages && c.trackedImages.length > 0 && c.activeAndEnabled);
+    }
+
     onAfterHierarchy(_context: USDZExporterContext, writer: USDWriter) {
         const iOSVersion = DeviceUtilities.getiOSVersion();
         const majorVersion = iOSVersion ? parseInt(iOSVersion.split(".")[0]) : 18;
@@ -171,12 +176,10 @@ class ImageTrackingExtension implements IUSDExporterExtension {
     }
 
     onBeforeBuildDocument(_context: USDZExporterContext) {
-        const imageTracking = GameObject.findObjectOfType(WebXRImageTracking);
-        if (!imageTracking || !imageTracking.trackedImages) return;
+        const imageTracking = this.getImageTrackingComponents()[0];
 
         // Warn if more than one tracked image is used for USDZ; that's not supported at the moment.
-        if (imageTracking.trackedImages.length > 1) 
-        {
+        if (imageTracking && imageTracking.trackedImages?.length > 1) {
             if (isDevEnvironment()) showBalloonWarning("USDZ: Only one tracked image is supported.");
             console.warn("USDZ: Only one tracked image is supported.");
         }
@@ -187,15 +190,14 @@ class ImageTrackingExtension implements IUSDExporterExtension {
     }
 
     onExportObject(object: Object3D<Object3DEventMap>, model: USDObject, _context: USDZExporterContext) {
-        const imageTracking = GameObject.findObjectOfType(WebXRImageTracking);
-        if (!imageTracking || !imageTracking.trackedImages) return;
+        const imageTracking = this.getImageTrackingComponents()[0];
+        if (!imageTracking || !imageTracking.trackedImages?.length) return;
 
+        const exporter = GameObject.findObjectOfType(USDZExporter);
+        if (!exporter) return;
 
         for (const trackedImage of imageTracking.trackedImages) {
             if (trackedImage.object?.asset === object) {
-                const exporter = GameObject.findObjectOfType(USDZExporter);
-                if (!exporter) continue;
-
                 const { scale, target } = exporter.getARScaleAndTarget();
 
                 // We have to reset the image tracking object's position and rotation, because QuickLook applies them.
@@ -220,8 +222,8 @@ class ImageTrackingExtension implements IUSDExporterExtension {
                 // Thus, we can't have separate transforms for "regularly placing content" and "placing content with an image marker".
                 // model.extraSchemas.push("Preliminary_AnchoringAPI");
                 // model.addEventListener("serialize", (_writer: USDWriter, _context: USDZExporterContext) => {
-                    // writer.appendLine( `token preliminary:anchoring:type = "image"` );
-                    // writer.appendLine( `rel preliminary:imageAnchoring:referenceImage = </${context.document.name}/Scenes/Scene/AnchoringReferenceImage>` );
+                // writer.appendLine( `token preliminary:anchoring:type = "image"` );
+                // writer.appendLine( `rel preliminary:imageAnchoring:referenceImage = </${context.document.name}/Scenes/Scene/AnchoringReferenceImage>` );
                 // });
 
                 // We can only apply this to the first tracked image, more are not supported by QuickLook.
@@ -238,7 +240,7 @@ class ImageTrackingExtension implements IUSDExporterExtension {
 export class WebXRImageTracking extends Behaviour {
 
     @serializable(WebXRImageTrackingModel)
-    trackedImages?: WebXRImageTrackingModel[];
+    trackedImages: WebXRImageTrackingModel[] = [];
 
     /** Applies smoothing based on detected jitter to the tracked image. */
     @serializable()
@@ -337,7 +339,7 @@ export class WebXRImageTracking extends Behaviour {
 
     onLeaveXR(_args: NeedleXREventArgs): void {
 
-        if(!this.supported && DeviceUtilities.isAndroidDevice()) {
+        if (!this.supported && DeviceUtilities.isAndroidDevice()) {
             showBalloonWarning(this.webXRIncubationsWarning);
         }
 
@@ -364,7 +366,7 @@ export class WebXRImageTracking extends Behaviour {
     private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: Object3D | null, frames: number, lastTrackingTime: number }>();
     private readonly currentImages: WebXRTrackedImage[] = [];
 
-    
+
     private readonly webXRIncubationsWarning = "Image tracking is currently not supported on this device. On Chrome for Android, you can enable the <a target=\"_blank\" href=\"#\" onclick=\"() => console.log('I')\">chrome://flags/#webxr-incubations</a> flag.";
 
     onUpdateXR(args: NeedleXREventArgs): void {