@needle-tools/engine 2.36.0-pre → 2.38.0-pre

package/src/engine-components/RigidBody.ts

@@ -1,234 +1,377 @@
 import { Behaviour } from "./Component";
-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 { serializeable } from "../engine/engine_serialization_decorator";
 import { Watch } from "../engine/engine_utils";
-import { Vector3 } from "three";
+import { Object3D, Vector3 } from "three";
 import { IRigidbody } from "../engine/engine_types";
+import { CollisionDetectionMode, RigidbodyConstraints } from "../engine/engine_physics.types";
+import { validate } from "../engine/engine_util_decorator";
+import { Context, FrameEvent } from "../engine/engine_setup";
+
+class TransformWatch {
+
+    get isDirty(): boolean {
+        return this.positionChanged || this.rotationChanged;
+    }
+    positionChanged: boolean = false;
+    rotationChanged: boolean = false;
+
+    position?: { x?: number, y?: number, z?: number };
+    quaternion?: { _x?: number, _y?: number, _z?: number, _w?: number };
+
+    private _positionKeys: string[] = ["x", "y", "z"];
+    private _quaternionKeys: string[] = ["_x", "_y", "_z", "_w"];
+
+    reset(clearPreviousValues: boolean = false) {
+        this.positionChanged = false;
+        this.rotationChanged = false;
+        this.mute = false;
+
+        if (clearPreviousValues) {
+            if (this.position)
+                for (const key of this._positionKeys)
+                    delete this.position[key];
+            if (this.quaternion)
+                for (const key of this._quaternionKeys)
+                    delete this.quaternion[key];
+        }
+    }
+
+    mute: boolean = false;
+
+    applyValues() {
+        // only apply the values that actually changed
+        // since we want to still control all the other values via physics 
+        if (this.positionChanged && this.position) {
+            for (const key of this._positionKeys) {
+                const val = this.position[key];
+                if (val !== undefined)
+                    this.obj.position[key] = val;
+            }
+        }
+        if (this.rotationChanged) {
+            if (this.quaternion) {
+                for (const key of this._quaternionKeys) {
+                    const val = this.quaternion[key];
+                    if (val !== undefined)
+                        this.obj.quaternion[key] = val;
+                }
+            }
+        }
+    }
+
+    readonly context: Context;
+    readonly obj: Object3D;
+    private _positionWatch?: Watch;
+    private _rotationWatch?: Watch;
+
+    constructor(obj: Object3D, context: Context) {
+        this.context = context;
+        this.obj = obj;
+    }
+
+    start(position: boolean, rotation: boolean) {
+        this.reset();
+        if (position) {
+            if (!this._positionWatch)
+                this._positionWatch = new Watch(this.obj.position, ["x", "y", "z"]);
+            this._positionWatch.apply();
+            this.position = {};
+            // this.position = this.obj.position.clone();
+            this._positionWatch.subscribeWrite((val, prop) => {
+                if (this.context.physics.isUpdating || this.mute) return;
+                const prev = this.position![prop];
+                if (Math.abs(prev - val) < .00001) return;
+                this.position![prop] = val;
+                this.positionChanged = true;
+            })
+        }
+        if (rotation) {
+            if (!this._rotationWatch)
+                this._rotationWatch = new Watch(this.obj.quaternion, ["_x", "_y", "_z", "_w"]);
+            this._rotationWatch.apply();
+            this.quaternion = {};
+            // this.quaternion = this.obj.quaternion.clone();
+            this._rotationWatch.subscribeWrite((val, prop) => {
+                if (this.context.physics.isUpdating || this.mute) return;
+                const prev = this.quaternion![prop];
+                if (Math.abs(prev - val) < .00001) return;
+                this.quaternion![prop] = val;
+                this.rotationChanged = true;
+            })
+        }
+    }
+
+    stop() {
+        this._positionWatch?.revoke();
+        this._rotationWatch?.revoke();
+    }
+}
+
 
 export class Rigidbody extends Behaviour implements IRigidbody {
 
+    @validate()
     @serializeable()
     mass: number = 1;
 
+    @validate()
     @serializeable()
-    public set isKinematic(kinematic: boolean) {
-        this._isKinematic = kinematic;
-        if (this._body) {
-            this._body.type = kinematic ? CANNON.Body.KINEMATIC : CANNON.Body.DYNAMIC;
-        }
-    }
+    useGravity: boolean = true;
 
-    public get isKinematic(): boolean {
-        return this._isKinematic;
-    }
-    private _isKinematic: boolean = false;
+    @validate()
+    @serializeable()
+    constraints: RigidbodyConstraints = RigidbodyConstraints.None;
 
+    @validate()
+    @serializeable()
+    isKinematic: boolean = false;
+
+    @validate()
     @serializeable()
     drag: number = 0;
+
+    @validate()
     @serializeable()
     angularDrag: number = 1;
+
+    @validate()
     @serializeable()
     detectCollisions: boolean = true;
+
+    @validate()
     @serializeable()
     sleepThreshold: number = 0.01;
 
+    @validate()
+    @serializeable()
+    collisionDetectionMode: CollisionDetectionMode = CollisionDetectionMode.Discrete;
 
-    get body(): CANNON.Body | null {
-        if (this._body === null) {
-            this.initialize();
-        }
-        return this._body;
+    get lockPositionX() {
+        return (this.constraints & RigidbodyConstraints.FreezePositionX) !== 0;
+    }
+    get lockPositionY() {
+        return (this.constraints & RigidbodyConstraints.FreezePositionY) !== 0;
+    }
+    get lockPositionZ() {
+        return (this.constraints & RigidbodyConstraints.FreezePositionZ) !== 0;
+    }
+    get lockRotationX() {
+        return (this.constraints & RigidbodyConstraints.FreezeRotationX) !== 0;
+    }
+    get lockRotationY() {
+        return (this.constraints & RigidbodyConstraints.FreezeRotationY) !== 0;
+    }
+    get lockRotationZ() {
+        return (this.constraints & RigidbodyConstraints.FreezeRotationZ) !== 0;
+    }
+
+    set lockPositionX(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezePositionX;
+        else this.constraints &= ~RigidbodyConstraints.FreezePositionX;
+    }
+    set lockPositionY(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezePositionY;
+        else this.constraints &= ~RigidbodyConstraints.FreezePositionY;
+    }
+    set lockPositionZ(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezePositionZ;
+        else this.constraints &= ~RigidbodyConstraints.FreezePositionZ;
+    }
+    set lockRotationX(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezeRotationX;
+        else this.constraints &= ~RigidbodyConstraints.FreezeRotationX;
+    }
+    set lockRotationY(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezeRotationY;
+        else this.constraints &= ~RigidbodyConstraints.FreezeRotationY;
+    }
+    set lockRotationZ(v: boolean) {
+        if (v) this.constraints |= RigidbodyConstraints.FreezeRotationZ;
+        else this.constraints &= ~RigidbodyConstraints.FreezeRotationZ;
     }
 
+    private _propertiesChanged: boolean = false;
     private static tempPosition: THREE.Vector3 = new THREE.Vector3();
-    private _body: CANNON.Body | null = null;
-    private currentVelocity!: THREE.Vector3;
+    private _currentVelocity!: THREE.Vector3;
     private _smoothedVelocity!: THREE.Vector3;
-    private lastWorldPosition!: THREE.Vector3;
+    private _smoothedVelocityGetter!: THREE.Vector3;
+    private _lastPosition!: THREE.Vector3;
 
-    private _ignoreChange: boolean = false;
-    private _dirty: boolean = false;
+    private _watch?: TransformWatch;
 
-    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._watch = undefined;
+        this._currentVelocity = new THREE.Vector3();
         this._smoothedVelocity = new THREE.Vector3();
-        this.lastWorldPosition = getWorldPosition(this.gameObject).clone();
-        this._matrixWatch = undefined;
-        this._positionWatch = undefined;
+        this._smoothedVelocityGetter = new THREE.Vector3();
+        this._lastPosition = new THREE.Vector3();
     }
 
-    // start() {
-    //     this.setBodyFromGameObject();
-    // }
-
     onEnable() {
-        if (this._body) {
-            this.context.physics.addBody(this.gameObject, this._body);
-        }
-        else
-            this.initialize();
-
-        if (this.body) {
-            this.body.wakeUp();
-            this.gameObject.updateWorldMatrix(true, false);
-            this.setBodyFromGameObject();
+        if (!this._watch) {
+            this._watch = new TransformWatch(this.gameObject, this.context);
         }
-
-        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);
-            }
-        })
+        this._watch.start(true, true);
+        this.startCoroutine(this.beforePhysics(), FrameEvent.LateUpdate);
     }
 
-    onDisable(): void {
-        if (this._body)
-            this.context.physics.removeBody(this.gameObject, this._body, false);
+    onDisable() {
+        this._watch?.stop();
+        this.context.physics.removeBody(this);
     }
 
     onDestroy(): void {
-        if (this._body)
-            this.context.physics.removeBody(this.gameObject, this._body);
+        this.context.physics.removeBody(this);
     }
 
-    onBeforeRender() {
-        this._ignoreChange = true;
-        this.updateVelocity();
+    onValidate() {
+        this._propertiesChanged = true;
+    }
 
-        if (this._dirty) {
-            this._dirty = false;
-            this._setMatrix.decompose(this.gameObject.position, this.gameObject.quaternion, this.gameObject.scale);
-            this.setBodyFromGameObject();
+    // need to do this right before updating physics to prevent rendered object glitching through physical bodies
+    *beforePhysics() {
+        while (true) {
+            if (this._propertiesChanged) {
+                this._propertiesChanged = false;
+                this.context.physics.updateProperties(this);
+            }
+            if (this._watch?.isDirty) {
+                this._watch.mute = true;
+                this._watch.applyValues();
+                this.context.physics.updateBody(this, this._watch.positionChanged, this._watch.rotationChanged);
+                this._watch.reset();
+            }
+            this.captureVelocity();
+            yield;
         }
+    }
 
-        this._ignoreChange = false;
+    private get body() {
+        return this.context.physics.internal_getRigidbody(this);
     }
 
-    initialize() {
-        if (this._body) {
-            return;
-        }
-        const options = new BodyOptions();
-        options.drag = this.drag;
-        options.angularDrag = this.angularDrag;
-        options.mass = this.mass;
-        options.kinematic = this.isKinematic;
-        options.physicsEvents = this.detectCollisions;
-        options.sleepThreshold = this.sleepThreshold;
-        this._body = this.context.physics.createBody(this.gameObject, options);
+    public teleport(pt: { x: number, y: number, z: number }, localspace:boolean = true) {
+        this._watch?.reset(true);
+        if(localspace) this.gameObject.position.set(pt.x, pt.y, pt.z);
+        else this.setWorldPosition(pt.x, pt.y, pt.z);
+        this.resetForcesAndTorques();
+        this.resetVelocities();
+    }
+
+    public resetForces() {
+        this.body?.resetForces(true);
     }
 
+    public resetTorques() {
+        this.body?.resetTorques(true);
+    }
+
+    public resetVelocities() {
+        this.setVelocity(0, 0, 0);
+        this.setAngularVelocity(0, 0, 0);
+    }
+
+    public resetForcesAndTorques() {
+        this.resetForces();
+        this.resetTorques();
+    }
 
     public wakeUp() {
         this.body?.wakeUp();
     }
 
-    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 applyForce(vec: Vector3, _rel?: THREE.Vector3) {
+        this.body?.addForce(vec, true);
+    }
+
+    public applyImpulse(vec: Vector3) {
+        this.body?.applyImpulse(vec, true);
     }
 
     public setForce(x: number, y: number, z: number) {
-        this.body?.force.set(x, y, z);
+        this.body?.resetForces(true);
+        this.body?.addForce({ x, y, z }, true);
     }
 
-    public getVelocity(): THREE.Vector3 {
-        if (this.body)
-            return Rigidbody.tempPosition.set(this.body?.velocity.x, this.body?.velocity.y, this.body?.velocity.z);
-        return Rigidbody.tempPosition.set(0, 0, 0);
+    public getVelocity(): Vector3 {
+        const vel = this.body?.linvel();
+        if (!vel) return this._currentVelocity.set(0, 0, 0);
+        this._currentVelocity.x = vel.x;
+        this._currentVelocity.y = vel.y;
+        this._currentVelocity.z = vel.z;
+        return this._currentVelocity;
     }
 
-    public setVelocity(x: number | Vector3, y: number, z: number) {
-        if (!this.body) return;
+    public setVelocity(x: number | Vector3, y?: number, z?: number) {
         if (x instanceof Vector3) {
             const vec = x;
-            x = vec.x;
-            y = vec.y;
-            z = vec.z;
+            this.body?.setLinvel(vec, true);
+            return;
         }
-        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;
+        if (y === undefined || z === undefined) return;
+        this.body?.setLinvel({ x: x, y: y, z: z }, true);
     }
 
-    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;
+    public setAngularVelocity(x: number | Vector3, y?: number, z?: number) {
         if (x instanceof Vector3) {
             const vec = x;
-            x = vec.x;
-            y = vec.y;
-            z = vec.z;
+            this.body?.setAngvel(vec, true);
+            return;
         }
-        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;
-
+        if (y === undefined || z === undefined) return;
+        this.body?.setAngvel({ x: x, y: y, z: z }, true);
     }
 
-    public get smoothedVelocity() { return this._smoothedVelocity; }
-
-    public setAngularVelocity(x: number, y: number, z: number) {
-        if (!this.body) return;
-        this.body.angularVelocity.x = x / this.context.time.deltaTime;
-        this.body.angularVelocity.y = y / this.context.time.deltaTime;
-        this.body.angularVelocity.z = z / this.context.time.deltaTime;
+    public setTorque(x: number | Vector3, y: number, z: number) {
+        this.setAngularVelocity(x, y, z);
     }
 
-    private static copyVector3: THREE.Vector3 = new THREE.Vector3();
-
-
-    public setBodyFromGameObject(velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) {
-        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;
-            this.body.quaternion.set(wr.x, wr.y, wr.z, wr.w);
+    public get smoothedVelocity(): Vector3 {
+        this._smoothedVelocityGetter.copy(this._smoothedVelocity);
+        return this._smoothedVelocityGetter.multiplyScalar(1 / this.context.time.deltaTime);
+    }
 
-            if (velocity) {
-                Rigidbody.copyVector3.set(velocity.x, velocity.y, velocity.z);
-                this._smoothedVelocity.lerp(Rigidbody.copyVector3, this.context.time.deltaTime / .1);
-                const sm = this._smoothedVelocity;
-                this.body.velocity.x = sm.x;
-                this.body.velocity.y = sm.y;
-                this.body.velocity.z = sm.z;
-            }
-            this._ignoreChange = false;
+    // public get smoothedVelocity() { return this._smoothedVelocity; }
+
+
+
+    /**d
+     * @deprecated not used anymore
+     */
+    public setBodyFromGameObject(_velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) {
+        if (this.gameObject && !this.destroyed) {
+            // this.context.physics.updateBody(this);
+            // this._ignoreChange = true;
+            // const wp = this.worldPosition;
+            // this.body.position.set(wp.x, wp.y, wp.z);
+            // const wr = this.worldQuaternion;
+            // this.body.quaternion.set(wr.x, wr.y, wr.z, wr.w);
+
+            // if (velocity) {
+            //     Rigidbody.copyVector3.set(velocity.x, velocity.y, velocity.z);
+            //     this._smoothedVelocity.lerp(Rigidbody.copyVector3, this.context.time.deltaTime / .1);
+            //     const sm = this._smoothedVelocity;
+            //     this.body.velocity.x = sm.x;
+            //     this.body.velocity.y = sm.y;
+            //     this.body.velocity.z = sm.z;
+            // }
+            // this._ignoreChange = false;
         }
     }
 
 
-    private updateVelocity() {
-        if (!this.currentVelocity) return;
-        if (this.body && this.gameObject) {
+
+    private captureVelocity() {
+        if (this.body) {
             const wp = getWorldPosition(this.gameObject);
-            this.currentVelocity.subVectors(wp, this.lastWorldPosition);
-            this.lastWorldPosition.copy(wp);
-            this._smoothedVelocity.lerp(this.currentVelocity, this.context.time.deltaTime / .1);
+            Rigidbody.tempPosition.copy(wp);
+            const vel = wp.sub(this._lastPosition);
+            this._lastPosition.copy(Rigidbody.tempPosition);
+            this._smoothedVelocity.lerp(vel, this.context.time.deltaTime / .1);
+            // this._smoothedVelocity.set(0, 1 / this.context.time.deltaTime, 0);
         }
     }
 }

package/src/engine-components/SmoothFollow.ts

@@ -1,53 +1,56 @@
 import { Camera } from "./Camera";
 import { Behaviour, GameObject } from "./Component";
-import * as utils from "../engine/engine_three_utils";
 import * as THREE from "three";
 import { Mathf } from "../engine/engine_math";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { Object3D } from "three";
+import { getWorldPosition, getWorldQuaternion } from "../engine/engine_three_utils";
+import { Axes } from "../engine/engine_physics.types";
 
 export class SmoothFollow extends Behaviour {
 
     @serializeable(Object3D)
     target: THREE.Object3D | null = null;
 
+    @serializeable()
     followFactor = .1;
+    @serializeable()
     rotateFactor = .1;
 
-    flipForward:boolean = false;
+    @serializeable()
+    positionAxes : Axes = Axes.All;
 
-    private static _invertForward : THREE.Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
-    private _firstUpdate = true;
+    // @serializeable()
+    // rotationAxes : Axes = Axes.All;
 
+    flipForward: boolean = false;
+
+    private static _invertForward: THREE.Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+    private _firstUpdate = true;
 
-    onEnable(): void {
-        const cam = GameObject.getComponentInChildren(this.gameObject, Camera) as Camera;
-        if (cam && cam.cam) {
-            cam.gameObject.position.set(0, 0, 0);
-            cam.cam.position.set(0, 0, 0);
-            cam.gameObject.quaternion.identity();
-            cam.cam.quaternion.setFromEuler(new THREE.Euler(0, Math.PI, 0));
-        }
-    }
 
     onBeforeRender(): void {
-        if (this.followFactor <= 0) return;
         this.updateNow(false);
     }
 
     updateNow(hard: boolean) {
         if (!this.target || this.target === this.gameObject) return;
         if (this.followFactor > 0) {
-            const wp = utils.getWorldPosition(this.target);
+            const wp = getWorldPosition(this.target);
             const fpos = this._firstUpdate || hard ? 1 : Mathf.clamp01(this.context.time.deltaTime * this.followFactor);
-            this.worldPosition = this.worldPosition.lerp(wp, fpos);
+            const currentPosition = this.worldPosition;
+            if(this.positionAxes & Axes.X) currentPosition.x = Mathf.lerp(currentPosition.x, wp.x, fpos);
+            if(this.positionAxes & Axes.Y) currentPosition.y = Mathf.lerp(currentPosition.y, wp.y, fpos);
+            if(this.positionAxes & Axes.Z) currentPosition.z = Mathf.lerp(currentPosition.z, wp.z, fpos);
+            this.worldPosition = currentPosition;
         }
         if (this.rotateFactor > 0) {
-            const wr = utils.getWorldQuaternion(this.target);
-            if(this.flipForward){
+            const wr = getWorldQuaternion(this.target);
+            if (this.flipForward) {
                 wr.premultiply(SmoothFollow._invertForward);
             }
             const frot = this._firstUpdate || hard ? 1 : Mathf.clamp01(this.context.time.deltaTime * this.rotateFactor);
+
             this.worldQuaternion = this.worldQuaternion.slerp(wr, frot);
         }
         this._firstUpdate = false;

package/src/engine-components/SpatialTrigger.ts

@@ -95,7 +95,7 @@ export class SpatialTrigger extends Behaviour {
         SpatialTrigger.triggers.push(this);
         if (!this.boxHelper) {
             this.boxHelper = GameObject.addNewComponent(this.gameObject, BoxHelperComponent);
-            this.boxHelper?.showHelper();
+            this.boxHelper?.showHelper(null, debug as boolean);
         }
     }
     onDisable(): void {

package/src/engine-components/SpectatorCamera.ts

@@ -61,6 +61,10 @@ export class SpectatorCamera extends Behaviour {
         this.target = undefined;
     }
 
+    private get localId() : string {
+        return this.context.connection.connectionId ?? "local";
+    }
+
     /** player view to follow */
     set target(target: PlayerView | undefined) {
         if (this._handler) {
@@ -74,7 +78,7 @@ export class SpectatorCamera extends Behaviour {
             // }
 
             const prev = this._handler.currentTarget?.userId;
-            const self = this.context.players.getPlayerView(this.context.connection.connectionId);
+            const self = this.context.players.getPlayerView(this.localId);
 
             // if user is in XR and sets target to self disable it
             if (target === undefined || (this.context.isInXR === false && self?.currentObject === target.currentObject)) {
@@ -103,7 +107,7 @@ export class SpectatorCamera extends Behaviour {
     }
 
     private get isSpectatingSelf() {
-        return this.isSpectating && this.target?.currentObject === this.context.players.getPlayerView(this.context.connection.connectionId)?.currentObject;
+        return this.isSpectating && this.target?.currentObject === this.context.players.getPlayerView(this.localId)?.currentObject;
     }
 
     // private currentViewport : THREE.Vector4 = new THREE.Vector4();
@@ -191,6 +195,10 @@ export class SpectatorCamera extends Behaviour {
 
     private followSelf() {
         this.target = this.context.players.getPlayerView(this.context.connection.connectionId);
+        if (!this.target) {
+            this.context.players.setPlayerView(this.localId, this.context.mainCamera, ViewDevice.Headset);
+            this.target = this.context.players.getPlayerView(this.localId);
+        }
         if (debug) console.log("Follow self", this.target);
     }