@needle-tools/engine 2.31.0-pre → 2.32.0-pre

package/src/engine-components/Component.ts

@@ -79,9 +79,12 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
 
     guid: string | undefined;
 
-    public static setActive(go: THREE.Object3D, active: boolean) {
+    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
         if (!go) return;
         go.visible = active;
+        main.updateActiveInHierarchyWithoutEventCall(go);
+        if (active && processStart)
+            main.processStart(Context.Current, go);
     }
 
     public static isActiveSelf(go: THREE.Object3D): boolean {
@@ -838,8 +841,13 @@ class Component implements EventTarget {
 
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
+    onCollisionExitRaw?(col: Collision);
     onCollisionStay?(col: Collision);
 
+    onTriggerEnter?(col: Collision);
+    onTriggerStay?(col: Collision);
+    onTriggerExit?(col: Collision);
+
     startCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): Generator {
         return this.context.registerCoroutineUpdate(this, routine, evt);
     }
@@ -900,6 +908,7 @@ class Component implements EventTarget {
         this.__didEnable = false;
         this._collisionExitRoutine = undefined;
         this.onDisable();
+        this._collisions?.clear();
     }
 
     constructor() {
@@ -907,55 +916,115 @@ class Component implements EventTarget {
     }
 
     private _collisionExitRoutine: any;
-    private _collisions: Map<Object3D, { col: Collision, frame: number }> | null = null;
+    private _collisions: Map<Object3D, { col: Collision, frame: number, exitFrame?: number }> | null = null;
+
+    private _triggerExitRoutine: any;
+    private _triggerCollisions: Map<Object3D, { col: Collision, frame: number, exitFrame?: number }> | null = null;
+
+    get collisionsCount() { return this._collisions?.size ?? 0; }
 
     private __internalResetsCachedPhysicsData() {
         this._collisionExitRoutine = null;
         this._collisions = null;
+        this._triggerExitRoutine = null;
+        this._triggerCollisions = null;
     }
 
-    __internalHandleCollision(col: Collision) {
-        if (this.onCollisionEnter || this.onCollisionExit || this.onCollisionStay) {
-            const otherObject = col.gameObject;
-            if (!this._collisions) this._collisions = new Map();
-            if (this._collisions.has(otherObject)) {
-                const cur = this._collisions.get(otherObject)!;
-                cur.frame = this.context.time.frameCount;
-                cur.col = col;
+    __internalHandleCollision(col: Collision, isTriggerCollision: boolean) {
+        if (isTriggerCollision) {
+            if (!this.onTriggerEnter && !this.onTriggerStay && !this.onTriggerExit) return;
+        }
+        else {
+            if (!this.onCollisionEnter && !this.onCollisionStay && !this.onCollisionExit) return;
+        }
+
+        const otherObject = col.gameObject;
+
+        // lazily create the maps
+        if (isTriggerCollision && !this._triggerCollisions) this._triggerCollisions = new Map();
+        else if (!this._collisions) this._collisions = new Map();
+
+        // select the correct map
+        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
+
+        if (collection.has(otherObject)) {
+            const cur = collection.get(otherObject)!;
+            // console.log("STAY", this.name, this.context.time.frameCount)
+            // cur.exitFrame = undefined;
+            cur.frame = this.context.time.frameCount;
+            cur.col = col;
+            if (isTriggerCollision)
+                this.onTriggerStay?.(col);
+            else
                 this.onCollisionStay?.call(this, col);
-            }
-            else {
-                const entry = { col, frame: this.context.time.frameCount };
-                this._collisions.set(otherObject, entry);
+        }
+        else {
+            // console.log("START", this.name);
+            const entry = { col, frame: this.context.time.frameCount };
+            collection.set(otherObject, entry);
+            if (isTriggerCollision)
+                this.onTriggerEnter?.(col);
+            else
                 this.onCollisionEnter?.call(this, col);
-            }
         }
     }
 
-    sendExitCollisionEvent(obj : Object3D) {
-        if(!this._collisions) return;
-        const col = this._collisions.get(obj);
-        if(!col) return;
-        this.onCollisionExit?.call(this, col.col);
-        this._collisions.delete(obj);
-    }
-
-    private __waitForCollisionExit() {
-        if (this._collisionExitRoutine) return;
-        // const self = this;
-        // function* routine() {
-        //     while (self._collisions && self._collisions.size > 0) {
-        //         for (let ob of self._collisions.keys()) {
-        //             const entry = self._collisions!.get(ob)!;
-        //             if (self.context.time.frameCount - entry.frame > 1) {
-        //                 self._collisions!.delete(ob);
-        //                 self.onCollisionExit?.call(self, entry.col);
-        //             }
-        //         }
-        //         yield;
-        //     }
-        // }
-        // this._collisionExitRoutine = this.startCoroutine(routine(), FrameEvent.EarlyUpdate);
+    __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean) {
+        if (isTriggerCollision) {
+            if (!this._triggerCollisions) return;
+        }
+        else {
+            if (!this._collisions) return;
+        }
+
+        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
+
+        const collision = collection.get(obj);
+        if (!collision) return;
+        collision.exitFrame = this.context.time.frameCount;
+        // console.log("EXIT col", this.name, this.context.time.frameCount);
+        // if (this.onCollisionExit !== undefined)
+        this.__waitForCollisionExit(isTriggerCollision);
+        if (!isTriggerCollision)
+            this.onCollisionExitRaw?.call(this, collision.col);
+        // this._collisions.delete(obj);
+    }
+
+    private __waitForCollisionExit(isTriggerCollision: boolean) {
+        const routine = isTriggerCollision ? this._triggerExitRoutine : this._collisionExitRoutine;
+        if (routine) return;
+
+        const collection = isTriggerCollision ? this._triggerCollisions! : this._collisions!;
+        const self = this;
+        const frames = 10;
+        function* delayedExitRoutine() {
+            while (collection && collection.size > 0) {
+                for (let other of collection.keys()) {
+                    const entry = collection!.get(other)!;
+                    if (entry.frame !== undefined && self.context.time.frameCount - entry.frame >= frames) {
+                        // console.log("EXIT real", self.name, entry.col.gameObject.name, collection);
+                        collection!.delete(other);
+                        if (isTriggerCollision)
+                            self.onTriggerExit?.(entry.col);
+                        else
+                            self.onCollisionExit?.call(self, entry.col);
+                    }
+                }
+                for (let i = 0; i < frames; i++)
+                    yield;
+            }
+            if (isTriggerCollision)
+                self._triggerExitRoutine = undefined;
+            else
+                self._collisionExitRoutine = null;
+            // console.log("DONE", self.name);
+        }
+
+        const newRoutine = this.startCoroutine(delayedExitRoutine(), FrameEvent.OnAfterRender);
+        if (isTriggerCollision)
+            this._triggerExitRoutine = newRoutine;
+        else
+            this._collisionExitRoutine = newRoutine
     }
 
 
@@ -1046,7 +1115,7 @@ class Component implements EventTarget {
     private static _forward: THREE.Vector3 = new THREE.Vector3(0, 0, 1);
     public get forward(): THREE.Vector3 {
 
-        return Component._forward.set(0, 0, 1).applyQuaternion(this.worldQuaternion);
+        return Component._forward.set(0, 0, -1).applyQuaternion(this.worldQuaternion);
     }
 
 

package/src/engine-components/OrbitControls.ts

@@ -53,9 +53,11 @@ export class OrbitControls extends Behaviour {
 
     private _inputs: number = 0;
     private _enableTime: number = 0; // use to disable double click when double clicking on UI
+    private _startedListeningToKeyEvents: boolean = false;
 
     awake(): void {
         this._lookTargetPosition = new THREE.Vector3();
+        this._startedListeningToKeyEvents = false;
     }
 
     onEnable() {
@@ -86,6 +88,10 @@ export class OrbitControls extends Behaviour {
             }
             this._controls.dampingFactor = this.dampingFactor;
             this._controls.enablePan = this.enablePan;
+            if (!this._startedListeningToKeyEvents) {
+                this._startedListeningToKeyEvents = true;
+                this._controls.listenToKeyEvents(window.document.body);
+            }
         }
     }
 
@@ -97,12 +103,16 @@ export class OrbitControls extends Behaviour {
             // this._controls.reset();
         }
     }
+    
+    onDestroy(){
+        this._controls?.dispose();
+    }
 
     start() {
         if (this._controls) {
             const camGo = GameObject.getComponent(this.gameObject, Camera);
             if (camGo && !this.setFromTargetPosition()) {
-                if(this.debugLog)
+                if (this.debugLog)
                     console.log("NO TARGET");
                 const forward = new THREE.Vector3(0, 0, -1).applyMatrix4(camGo.cam.matrixWorld);
                 this.setTarget(forward, true);

package/src/engine-components/RigidBody.ts

@@ -3,14 +3,15 @@ import { BodyOptions } from '../engine/engine_physics'
 import * as CANNON from 'cannon-es'
 import * as THREE from 'three'
 import { getWorldPosition } from "../engine/engine_three_utils";
-import { onChange, RevocableProxy } from "./ui/Utils";
 import { serializeable } from "../engine/engine_serialization_decorator";
+import { Watch } from "../engine/engine_utils";
+import { Vector3 } from "three";
 
 export class Rigidbody extends Behaviour {
 
     @serializeable()
     mass: number = 1;
-    
+
     @serializeable()
     public set isKinematic(kinematic: boolean) {
         this._isKinematic = kinematic;
@@ -47,19 +48,30 @@ export class Rigidbody extends Behaviour {
     private _smoothedVelocity!: THREE.Vector3;
     private lastWorldPosition!: THREE.Vector3;
 
-    private dirty: boolean = true;
-    private transformProxy? : RevocableProxy;
+    private _ignoreChange: boolean = false;
+    private _dirty: boolean = false;
+
+    private _positionWatch?: Watch;
+    private _matrixWatch?: Watch;
+    private _setMatrix: THREE.Matrix4;
+
+    constructor() {
+        super();
+        this._setMatrix = new THREE.Matrix4();
+    }
 
     awake() {
         this._body = null;
         this.currentVelocity = new THREE.Vector3();
         this._smoothedVelocity = new THREE.Vector3();
         this.lastWorldPosition = getWorldPosition(this.gameObject).clone();
+        this._matrixWatch = undefined;
+        this._positionWatch = undefined;
     }
 
-    start(){
-        this.setBodyFromGameObject();
-    }
+    // start() {
+    //     this.setBodyFromGameObject();
+    // }
 
     onEnable() {
         if (this._body) {
@@ -74,15 +86,18 @@ export class Rigidbody extends Behaviour {
             this.setBodyFromGameObject();
         }
 
-        this.transformProxy = onChange(this.gameObject.matrix, "elements", () => {
-            if (!this.context.physics.isUpdating) {
-                this.dirty = true;
+        if (!this._positionWatch)
+            this._positionWatch = new Watch(this.gameObject.position, ["x", "y", "z"]);
+        this._positionWatch.subscribeWrite(_ => {
+            if (!this.context.physics.isUpdating && !this._ignoreChange) {
+                this._dirty = true;
+                this._setMatrix.copy(this.gameObject.matrix);
+                this._setMatrix.setPosition(this.gameObject.position);
             }
-        });
+        })
     }
 
     onDisable(): void {
-        this.transformProxy?.revoke();
         if (this._body)
             this.context.physics.removeBody(this.gameObject, this._body, false);
     }
@@ -92,15 +107,23 @@ export class Rigidbody extends Behaviour {
             this.context.physics.removeBody(this.gameObject, this._body);
     }
 
-    earlyUpdate(){
-        if(this.dirty) this.setBodyFromGameObject();
-    }
     onBeforeRender() {
+        this._ignoreChange = true;
         this.updateVelocity();
+
+        if (this._dirty) {
+            this._dirty = false;
+            this._setMatrix.decompose(this.gameObject.position, this.gameObject.quaternion, this.gameObject.scale);
+            this.setBodyFromGameObject();
+        }
+
+        this._ignoreChange = false;
     }
 
     initialize() {
-        if (this._body) return;
+        if (this._body) {
+            return;
+        }
         const options = new BodyOptions();
         options.drag = this.drag;
         options.angularDrag = this.angularDrag;
@@ -116,8 +139,14 @@ export class Rigidbody extends Behaviour {
         this.body?.wakeUp();
     }
 
-    public applyForce(vec: THREE.Vector3, rel: THREE.Vector3 | undefined) {
-        this.body?.applyForce(new CANNON.Vec3(vec.x, vec.y, vec.z), rel ? new CANNON.Vec3(rel.x, rel.y, rel.z) : undefined);
+    public applyForce(vec: THREE.Vector3, rel?: THREE.Vector3) {
+        const force = new CANNON.Vec3(vec.x, vec.y, vec.z);
+        force.scale(1 / this.context.time.deltaTime, force);
+        this.body?.applyForce(force, rel ? new CANNON.Vec3(rel.x, rel.y, rel.z) : undefined);
+    }
+
+    public setForce(x: number, y: number, z: number) {
+        this.body?.force.set(x, y, z);
     }
 
     public getVelocity(): THREE.Vector3 {
@@ -126,13 +155,39 @@ export class Rigidbody extends Behaviour {
         return Rigidbody.tempPosition.set(0, 0, 0);
     }
 
-    public setVelocity(x: number, y: number, z: number) {
+    public setVelocity(x: number | Vector3, y: number, z: number) {
         if (!this.body) return;
+        if (x instanceof Vector3) {
+            const vec = x;
+            x = vec.x;
+            y = vec.y;
+            z = vec.z;
+        }
         this.body.velocity.x = x / this.context.time.deltaTime;
         this.body.velocity.y = y / this.context.time.deltaTime;
         this.body.velocity.z = z / this.context.time.deltaTime;
     }
 
+    public getTorque(): THREE.Vector3 {
+        if (this.body)
+            return Rigidbody.tempPosition.set(this.body?.torque.x, this.body?.torque.y, this.body?.torque.z);
+        return Rigidbody.tempPosition.set(0, 0, 0);
+    }
+
+    public setTorque(x: number | Vector3, y: number, z: number) {
+        if (!this.body) return;
+        if (x instanceof Vector3) {
+            const vec = x;
+            x = vec.x;
+            y = vec.y;
+            z = vec.z;
+        }
+        this.body.torque.x = x / this.context.time.deltaTime;
+        this.body.torque.y = y / this.context.time.deltaTime;
+        this.body.torque.z = z / this.context.time.deltaTime;
+
+    }
+
     public get smoothedVelocity() { return this._smoothedVelocity; }
 
     public setAngularVelocity(x: number, y: number, z: number) {
@@ -146,8 +201,8 @@ export class Rigidbody extends Behaviour {
 
 
     public setBodyFromGameObject(velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) {
-        this.dirty = false;
         if (this.body && this.gameObject && !this.destroyed) {
+            this._ignoreChange = true;
             const wp = this.worldPosition;
             this.body.position.set(wp.x, wp.y, wp.z);
             const wr = this.worldQuaternion;
@@ -161,6 +216,7 @@ export class Rigidbody extends Behaviour {
                 this.body.velocity.y = sm.y;
                 this.body.velocity.z = sm.z;
             }
+            this._ignoreChange = false;
         }
     }
 

package/src/engine-components/XRFlag.ts

@@ -1,5 +1,3 @@
-import { BufferAttribute } from "three";
-import { registerComponent } from "../engine/engine_components";
 import { Behaviour, GameObject } from "./Component";
 import * as utils from "../engine/engine_utils";
 const debug = utils.getParam("debugflags");

package/src/engine-components/ui/Text.ts

@@ -7,7 +7,7 @@ import { FrameEvent } from '../../engine/engine_setup';
 import { updateRenderSettings } from './Utils';
 import { Canvas } from './Canvas';
 import { serializeable } from '../../engine/engine_serialization_decorator';
-import { getParam } from '../../engine/engine_utils';
+import { getParam, getPath } from '../../engine/engine_utils';
 
 const debug = getParam("debugtext");
 
@@ -441,6 +441,7 @@ export class Text extends Graphic {
         //         if (!this.font.includes("-bold-italic"))
         //             return this.font + "-bold-italic";
         // }
+        this.font = getPath(this.sourceId, this.font);
         return this.font;
     }
 }