@needle-tools/engine 2.31.1-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/RigidBody.ts

@@ -5,6 +5,7 @@ import * as THREE from 'three'
 import { getWorldPosition } from "../engine/engine_three_utils";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { Watch } from "../engine/engine_utils";
+import { Vector3 } from "three";
 
 export class Rigidbody extends Behaviour {
 
@@ -51,7 +52,7 @@ export class Rigidbody extends Behaviour {
     private _dirty: boolean = false;
 
     private _positionWatch?: Watch;
-    // private _matrixWatch?: Watch;
+    private _matrixWatch?: Watch;
     private _setMatrix: THREE.Matrix4;
 
     constructor() {
@@ -64,11 +65,13 @@ export class Rigidbody extends Behaviour {
         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) {
@@ -88,22 +91,13 @@ export class Rigidbody extends Behaviour {
         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);
             }
         })
-
-        // this._matrixWatch = onChange(this.gameObject.matrix, "elements", (newValue, oldValue) => {
-        //     if (newValue !== oldValue) {
-        //         if (!this.context.physics.isUpdating && !this._ignoreChange) {
-        //             this.dirty = true;
-        //             this._setMatrix.copy(this.gameObject.matrix);
-        //         }
-        //     }
-        // });
     }
 
     onDisable(): void {
-        // this._matrixWatch?.u();
         if (this._body)
             this.context.physics.removeBody(this.gameObject, this._body, false);
     }
@@ -113,27 +107,23 @@ export class Rigidbody extends Behaviour {
             this.context.physics.removeBody(this.gameObject, this._body);
     }
 
-    earlyUpdate() {
+    onBeforeRender() {
+        this._ignoreChange = true;
+        this.updateVelocity();
+
         if (this._dirty) {
-            this._ignoreChange = true;
             this._dirty = false;
-            //     // console.log("RESET");
             this._setMatrix.decompose(this.gameObject.position, this.gameObject.quaternion, this.gameObject.scale);
             this.setBodyFromGameObject();
-            this._ignoreChange = false;
         }
-    }
-    onBeforeRender() {
-        this._ignoreChange = true;
-        this.updateVelocity();
-        // this._ignoreChange = true;
-        // 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;
@@ -149,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 {
@@ -159,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) {