Needle Engine 3.25.2

Files changed (5) hide show

src/engine-components/Component.ts +8 -3
src/engine/engine_three_utils.ts +7 -0
src/engine/engine_types.ts +5 -1
src/engine-components/js-extensions/Object3D.ts +23 -2
src/engine-components/webxr/WebXRImageTracking.ts +15 -14

src/engine-components/Component.ts CHANGED Viewed

@@ -26,9 +26,6 @@
     // Added to the threejs Object3D prototype
     abstract destroy();
-    // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
-    abstract get transform(): Object3D;
     public static isDestroyed(go: Object3D): boolean {
         return isDestroyed(go);
     }
@@ -274,6 +271,10 @@
     // these are implemented via threejs object extensions
     abstract activeSelf: boolean;
+    // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
+    abstract get transform(): GameObject;
     /** creates a new component on this gameObject */
     abstract addNewComponent<T>(type: ConstructorConcrete<T>): T | null;
     /** adds an existing component to this gameObject */
@@ -296,6 +297,10 @@
     abstract get worldRotation(): Vector3;
     abstract set worldScale(val: Vector3);
     abstract get worldScale(): Vector3;
+    abstract get worldForward(): Vector3;
+    abstract get worldRight(): Vector3;
+    abstract get worldUp(): Vector3;
 }

src/engine/engine_three_utils.ts CHANGED Viewed

@@ -45,6 +45,13 @@
     object.lookAt(lookTarget);
 }
+const _tempVecs = new CircularBuffer(() => new Vector3(), 100);
+export function getTempVector() {
+    return _tempVecs.get();
+}
 const _worldPositions = new CircularBuffer(() => new Vector3(), 100);
 const _lastMatrixWorldUpdateKey = Symbol("lastMatrixWorldUpdateKey");

src/engine/engine_types.ts CHANGED Viewed

@@ -111,7 +111,7 @@
      * @augments Object3D
      * @tutorial https://fwd.needle.tools/needle-engine/docs/transform
      * */
-    get transform(): Object3D;
+    get transform(): IGameObject;
     addNewComponent<T>(type: Constructor<T>): T | null;
     removeComponent(comp: IComponent): IComponent;
@@ -131,6 +131,10 @@
     set worldRotation(val: Vector3);
     get worldScale(): Vector3;
     set worldScale(val: Vector3);
+    get worldForward(): Vector3;
+    get worldRight(): Vector3;
+    get worldUp(): Vector3;
 }
 export interface IHasGuid {

src/engine-components/js-extensions/Object3D.ts CHANGED Viewed

@@ -11,7 +11,8 @@
     getWorldScale,
     setWorldScale,
     setWorldRotation,
-    getWorldRotation
+    getWorldRotation,
+    getTempVector
 }
     from "../../engine/engine_three_utils.js";
@@ -142,9 +143,29 @@
     });
 }
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "worldForward")) {
+    Object.defineProperty(Object3D.prototype, "worldForward", {
+        get: function () {
+            return getTempVector().set(0, 0, 1).applyQuaternion(getWorldQuaternion(this));
+        },
+    });
+}
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "worldRight")) {
+    Object.defineProperty(Object3D.prototype, "worldRight", {
+        get: function () {
+            return getTempVector().set(1, 0, 0).applyQuaternion(getWorldQuaternion(this));
+        },
+    });
+}
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "worldUp")) {
+    Object.defineProperty(Object3D.prototype, "worldUp", {
+        get: function () {
+            return getTempVector().set(0, 1, 0).applyQuaternion(getWorldQuaternion(this));
+        },
+    });
+}
 // do this after adding the component extensions
 registerPrototypeExtensions(Object3D);

src/engine-components/webxr/WebXRImageTracking.ts CHANGED Viewed

@@ -21,8 +21,6 @@
     get model(): WebXRImageTrackingModel { return this._trackedImage; }
     readonly measuredSize: number;
     readonly state: "tracked" | "emulated";
-    /** realtime since startup, is used to keep the object visible even if tracking is gone for a few frames */
-    lastTrackingTime: number = 0;
     /** Copy the image position to a vector */
     getPosition(vec: Vector3) {
@@ -238,7 +236,7 @@
         }
     };
-    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: GameObject | null, frames: number }>();
+    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: GameObject | null, frames: number, lastTrackingTime:number }>();
     private readonly currentImages: WebXRTrackedImage[] = [];
@@ -267,8 +265,6 @@
                         if (trackedImage) {
                             const pose = frame.getPose(result.imageSpace, space);
                             const imageData = new WebXRTrackedImage(this, trackedImage, result.image, result.measuredSize, state, pose);
-                            if (imageData.state === "tracked")
-                                imageData.lastTrackingTime = this.context.time.realtimeSinceStartup;
                             this.currentImages.push(imageData);
                         }
                         else {
@@ -293,21 +289,23 @@
         }
         // disable any objects that are no longer tracked
-        const hysteresis = 1;
-        for (const [model, object] of this.imageToObjectMap) {
-            if (!object.object || !model) continue;
+        /** time in millis */
+        const hysteresis = 1000;
+        for (const [key, value] of this.imageToObjectMap) {
+            if (!value.object || !key) continue;
             let found = false;
             for (const trackedImage of this.currentImages) {
-                if (trackedImage.model === model) {
+                if (trackedImage.model === key) {
                     // Make sure to keep the object visible if it's marked as static OR is tracked OR was tracked very recently (e.g. low framerate or bad tracking on device)
-                    const timeSinceLastTracking = this.context.time.realtimeSinceStartup - trackedImage.lastTrackingTime;
-                    if (model.imageDoesNotMove || trackedImage.state === "tracked" || timeSinceLastTracking < hysteresis)
+                    const timeSinceLastTracking = Date.now() - value.lastTrackingTime;
+                    if (key.imageDoesNotMove || trackedImage.state === "tracked" || timeSinceLastTracking <= hysteresis) {
                         found = true;
-                    break;
+                        break;
+                    }
                 }
             }
             if (!found) {
-                GameObject.setActive(object.object, false);
+                GameObject.setActive(value.object, false);
             }
         }
     }
@@ -318,12 +316,13 @@
         for (const image of images) {
             const model = image.model;
+            const isTracked = image.state === "tracked";
             // don't do anything if we don't have an object to track - can be handled externally through events
             if (!model.object) continue;
             let trackedData = this.imageToObjectMap.get(model);
             if (trackedData === undefined) {
-                trackedData = { object: null, frames: 0 };
+                trackedData = { object: null, frames: 0, lastTrackingTime: Date.now() };
                 this.imageToObjectMap.set(model, trackedData);
                 model.object.loadAssetAsync().then((asset: GameObject | null) => {
@@ -347,6 +346,8 @@
             }
             else {
                 trackedData.frames++;
+                if(isTracked)
+                    trackedData.lastTrackingTime = Date.now();
                 // TODO we could do a bit more here: e.g. sample for the first 1s or so of getting pose data
                 // to improve the tracking quality a bit.