@needle-tools/engine 2.35.5-pre → 2.37.0-pre

package/src/engine-components/BoxHelperComponent.ts

@@ -9,12 +9,12 @@ const gizmos = getParam("gizmos");
 export class BoxHelperComponent extends Behaviour {
 
     private box: THREE.Box3 | null = null;
-    private testBox: THREE.Box3 = new THREE.Box3();
+    private static testBox: THREE.Box3 = new THREE.Box3();
     private _lastMatrixUpdateFrame: number = -1;
     private static _position: THREE.Vector3 = new THREE.Vector3();
     private static _size: THREE.Vector3 = new THREE.Vector3(.01, .01, .01);
 
-    public isInBox(obj: THREE.Object3D): boolean | undefined {
+    public isInBox(obj: THREE.Object3D, scaleFactor? : number): boolean | undefined {
         if (!obj) return undefined;
 
         // if (!obj.geometry.boundingBox) obj.geometry.computeBoundingBox();
@@ -23,22 +23,40 @@ export class BoxHelperComponent extends Behaviour {
         if (!this.box) {
             this.box = new THREE.Box3();
         }
-        this.updateBox(false);
 
-        if (obj.type === "Mesh")
-            this.testBox.setFromObject(obj);
+        if (obj.type === "Mesh") {
+            BoxHelperComponent.testBox.setFromObject(obj);
+        }
+        else if (obj.type === "Group") {
+            if (obj.children.length > 0) {
+                BoxHelperComponent.testBox.setFromCenterAndSize(
+                    BoxHelperComponent._position.set(0, 0, 0),
+                    BoxHelperComponent._size.set(0, 0, 0)
+                );
+                for (let i = 0; i < obj.children.length; i++) {
+                    const ch = obj.children[i];
+                    if (ch.type === "Mesh") {
+                        BoxHelperComponent.testBox.expandByObject(obj);
+                    }
+                }
+            }
+        }
         else {
             const wp = getWorldPosition(obj, BoxHelperComponent._position);
             const size = getWorldScale(obj, BoxHelperComponent._size);
-            this.testBox.setFromCenterAndSize(wp, size);
+            if(scaleFactor !== undefined) size.multiplyScalar(scaleFactor);
+            BoxHelperComponent.testBox.setFromCenterAndSize(wp, size);
         }
 
+        // console.log("Obj box:", obj.name, obj.uuid, BoxHelperComponent.testBox.getCenter(new THREE.Vector3()), BoxHelperComponent.testBox.getSize(new THREE.Vector3()),
+        // "\nTest box:", this.box.getCenter(new THREE.Vector3()), this.box.getSize(new THREE.Vector3()), this.context.time.frameCount);
         // this.tp.copy(obj.geometry.boundingBox);
         // // this.tp.setFromCenterAndSize(obj.position, obj.scale);
         // this.tp.applyMatrix4(obj.matrixWorld);
         // console.log(this.tp);
         // console.log(this.box?.min, this.box?.max, this.tp.min, this.tp.max);
-        return this.box?.intersectsBox(this.testBox);
+        this.updateBox();
+        return this.box?.intersectsBox(BoxHelperComponent.testBox);
     }
 
     public intersects(box: THREE.Box3): boolean {
@@ -51,9 +69,12 @@ export class BoxHelperComponent extends Behaviour {
             this.box = new THREE.Box3();
         }
         if (force || this.context.time.frameCount != this._lastMatrixUpdateFrame) {
+            const firstUpdate = this._lastMatrixUpdateFrame < 0;
             this._lastMatrixUpdateFrame = this.context.time.frameCount;
-            this.box.setFromCenterAndSize(new THREE.Vector3(0, 0, 0), new THREE.Vector3(1, 1, 1));
-            this.box.applyMatrix4(this.gameObject.matrixWorld);
+            const updateParents: boolean = firstUpdate; // updating parents seems to cause falsely calculated positions sometimes?
+            const wp = getWorldPosition(this.gameObject, BoxHelperComponent._position, updateParents);
+            const size = getWorldScale(this.gameObject, BoxHelperComponent._size);
+            this.box.setFromCenterAndSize(wp, size);
         }
         return this.box;
     }

package/src/engine-components/Collider.ts

@@ -1,8 +1,7 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { Event, Object3D, Vector3 } from "three"
-import { Shape } from "cannon-es";
+import { Event, Mesh, Object3D, Vector3 } from "three"
 import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
 import { getComponentInChildren } from "../engine/engine_components";
@@ -25,14 +24,14 @@ export class Collider extends Behaviour implements ICollider {
     @serializeable()
     isTrigger: boolean = false;
 
-    protected _shape: Shape | null = null;
 
     awake() {
         super.awake();
-        this._shape = null;
+        if (!this.attachedRigidbody)
+            this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
 
-    start(){
+    start() {
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
@@ -44,9 +43,7 @@ export class Collider extends Behaviour implements ICollider {
     }
 
     onDisable() {
-        if (this._shape) {
-
-        }
+        this.context.physics.removeBody(this);
     }
 
 }
@@ -61,14 +58,8 @@ export class SphereCollider extends Collider {
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addSphereCollider(this.gameObject, this.center, this.radius, this.attachedRigidbody);
+        this.context.physics.addSphereCollider(this, this.center, this.radius);
     }
-
-    // onDisable() {
-    //     // if (this._shape)
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    // }
 }
 
 export class BoxCollider extends Collider {
@@ -80,22 +71,31 @@ export class BoxCollider extends Collider {
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addBoxCollider(this.gameObject, this.isTrigger, this.center, this.size, this.attachedRigidbody);
+        this.context.physics.addBoxCollider(this, this.center, this.size);
     }
-
-    // onDisable() {
-    //     // if (this._shape) {
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    //     // }
-    // }
 }
 
 
-// export class MeshCollider extends Collider {
+export class MeshCollider extends Collider {
 
-//     onEnable() {
-//         if (this.enabled)
-//             this.context.physics.addMeshCollider(this.gameObject);
-//     }
-// }
+
+    sharedMesh?: Mesh;
+    @serializeable()
+    convex: boolean = false;
+
+    awake(){
+        console.log(this);
+    }
+
+    onEnable() {
+        super.onEnable();
+        if (!this.sharedMesh?.isMesh) {
+            // HACK using the renderer mesh
+            if (this.gameObject instanceof Mesh) {
+                this.sharedMesh = this.gameObject;
+            }
+        }
+        if (this.sharedMesh?.isMesh)
+            this.context.physics.addMeshCollider(this, this.sharedMesh, this.convex);
+    }
+}

package/src/engine-components/Component.ts

@@ -6,9 +6,9 @@ import { Context, FrameEvent } from "../engine/engine_setup";
 import * as main from "../engine/engine_mainloop_utils";
 import { Object3D } from "three";
 import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
-import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision } from "../engine/engine_types";
+import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision, ICollider } from "../engine/engine_types";
 import { addNewComponentInstance, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
-import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing } from "../engine/engine_gameobject";
+import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive } from "../engine/engine_gameobject";
 
 
 // export interface ISerializationCallbackReceiver {
@@ -23,10 +23,10 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     guid: string | undefined;
 
-    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
+    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true, setVisible: boolean = true) {
         if (!go) return;
-        go.visible = active;
-        main.updateActiveInHierarchyWithoutEventCall(go);
+        setActive(go, active, setVisible);
+        main.updateIsActive(go);
         if (active && processStart)
             main.processStart(Context.Current, go);
     }
@@ -82,10 +82,12 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
             context = Context.Current;
         }
         parent.add(instance);
-        main.updateActiveInHierarchyWithoutEventCall(instance);
+        setActive(instance, true);
+        main.updateIsActive(instance);
         if (context) {
             GameObject.foreachComponent(instance, (comp: Component) => {
                 main.addScriptToArrays(comp, context!);
+                if(comp.__internalDidAwakeAndStart) return;
                 if (context!.new_script_start.includes(comp) === false) {
                     context!.new_script_start.push(comp as Behaviour);
                 }
@@ -102,6 +104,8 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     public static remove(instance: THREE.Object3D | null | undefined) {
         if (!instance) return;
         instance.parent?.remove(instance);
+        setActive(instance, false);
+        main.updateIsActive(instance);
         GameObject.foreachComponent(instance, (comp) => {
             main.processRemoveFromScene(comp);
         }, true);
@@ -313,9 +317,8 @@ class Component implements IComponent, EventTarget {
     onDestroy() {
         this.__destroyed = true;
     }
+    onValidate?(prop?: string): void;
     start?(): void;
-    // available update loop events:
-    // earlyUpdate, update, lateUpdate, onBeforeRender, onAfterRender
     earlyUpdate?(): void;
     update?(): void;
     lateUpdate?(): void;
@@ -324,12 +327,11 @@ class Component implements IComponent, EventTarget {
 
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
-    onCollisionExitRaw?(col: Collision);
     onCollisionStay?(col: Collision);
-
-    onTriggerEnter?(col: Collision);
-    onTriggerStay?(col: Collision);
-    onTriggerExit?(col: Collision);
+    
+    onTriggerEnter?(col: ICollider);
+    onTriggerStay?(col: ICollider);
+    onTriggerExit?(col: ICollider);
 
     startCoroutine(routine: Generator, evt: FrameEvent = FrameEvent.Update): Generator {
         return this.context.registerCoroutineUpdate(this, routine, evt);
@@ -354,13 +356,21 @@ class Component implements IComponent, EventTarget {
     protected __isEnabled: boolean | undefined = undefined;
     private __destroyed: boolean = false;
 
+    get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
+
+
+    constructor() {
+        // super();
+        this.__internalNewInstanceCreated();
+    }
+
     __internalNewInstanceCreated() {
         this.__didAwake = false;
         this.__didStart = false;
         this.__didEnable = false;
         this.__isEnabled = undefined;
         this.__destroyed = false;
-        this.__internalResetsCachedPhysicsData();
+        // this.__internalResetsCachedPhysicsData();
     }
 
     __internalAwake() {
@@ -391,9 +401,9 @@ class Component implements IComponent, EventTarget {
     __internalDisable() {
         if (!this.__didEnable) return;
         this.__didEnable = false;
-        this._collisionExitRoutine = undefined;
+        // this._collisionExitRoutine = undefined;
         this.onDisable();
-        this._collisions?.clear();
+        // this._collisions?.clear();
         // if we do this after processing the callback
         this.__isEnabled = false;
     }
@@ -431,126 +441,7 @@ class Component implements IComponent, EventTarget {
         }
     }
 
-    constructor() {
-        // super();
-        this.__internalNewInstanceCreated();
-    }
-
-    private _collisionExitRoutine: any;
-    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, 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 {
-            // 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);
-        }
-    }
-
-    __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
-    }
-
-
     // TODO move this to threeutils
-
     // we need a copy for modifying the values to local space
     private static _worldPositionBuffer: THREE.Vector3 = new THREE.Vector3();
     private static _worldQuaternionBuffer: THREE.Quaternion = new THREE.Quaternion();

package/src/engine-components/DragControls.ts

@@ -230,7 +230,7 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         this._dragHelper.onUpdate(this.context);
         for (const rb of this._draggingRigidbodies) {
             rb.wakeUp();
-            rb.setBodyFromGameObject();
+            rb.resetVelocities();
         }
     }
 
@@ -238,6 +238,9 @@ export class DragControls extends Interactable implements IPointerDownHandler, I
         if (!this || !this._isDragging) return;
         this._isDragging = false;
         if (!this._dragHelper) return;
+        for(const rb of this._draggingRigidbodies){
+            rb.setVelocity(rb.smoothedVelocity);
+        }
         this._draggingRigidbodies.length = 0;
         const selected = this._dragHelper.selected;
         if (debug)
@@ -323,8 +326,8 @@ class DragHelper {
         if (this._selected && context) {
             for (const rb of this._rbs) {
                 rb.wakeUp();
-                if (!rb.smoothedVelocity) continue;
-                rb.setVelocity(rb.smoothedVelocity.x, rb.smoothedVelocity.y, rb.smoothedVelocity.z);
+                // if (!rb.smoothedVelocity) continue;
+                rb.setVelocity(0,0,0);
             }
         }
 
@@ -358,7 +361,7 @@ class DragHelper {
             this._groundOffset.set(0, 0, 0);
             this._requireUpdateGroundPlane = true;
 
-            this._rbs = GameObject.getComponentsInChildren(this._selected, Rigidbody);
+            // this._rbs = GameObject.getComponentsInChildren(this._selected, Rigidbody);
             this.onUpdateScreenSpacePlane();
         }
     }
@@ -518,7 +521,8 @@ class DragHelper {
 
         for (const rb of this._rbs) {
             rb.wakeUp();
-            rb.setBodyFromGameObject({ x: 0, y: 0, z: 0 });
+            rb.resetForcesAndTorques();
+            // rb.setBodyFromGameObject({ x: 0, y: 0, z: 0 });
             rb.setAngularVelocity(0, 0, 0);
         }
     }

package/src/engine-components/GroundProjection.ts

@@ -41,12 +41,13 @@ export class GroundProjectedEnv extends Behaviour {
 
 
     onEnable() {
-        this.updateProjection();
-        if (!this._watcher) {
-            this._watcher = new Watch(this.context.scene, "environment");
-            this._watcher.subscribeWrite(this.updateProjection.bind(this));
-        }
-        this._watcher.apply();
+        // TODO: if we do this in the first frame we can not disable it again. Something buggy with the watch?!
+        if (this.context.time.frameCount > 0)
+            this.updateAndCreate();
+    }
+
+    start() {
+        this.updateAndCreate();
     }
 
     onDisable() {
@@ -54,8 +55,22 @@ export class GroundProjectedEnv extends Behaviour {
         this.env?.removeFromParent();
     }
 
+    private updateAndCreate() {
+        this.updateProjection();
+        if (!this._watcher) {
+            this._watcher = new Watch(this.context.scene, "environment");
+            this._watcher.subscribeWrite(_ => {
+                this.updateProjection();
+            });
+        }
+        this._watcher.apply();
+    }
+
     updateProjection() {
-        if (!this.context.scene.environment) return;
+        if (!this.context.scene.environment) {
+            this.env?.removeFromParent();
+            return;
+        }
         if (!this.env || this.context.scene.environment !== this._lastEnvironment) {
             console.log("Create/Update Ground Projection", this.context.scene.environment.name);
             this.env = new GroundProjection(this.context.scene.environment);