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

package/src/engine/engine_physics.ts

@@ -1,27 +1,26 @@
-import * as CANNON from 'cannon-es'
-import * as THREE from 'three'
+import { Body, Box, Constraint, Vec3, World, Sphere as PhysicsSphere, Quaternion as PhysicsQuaternion } from 'cannon-es'
+import { Box3, Camera, Intersection, Layers, Matrix4, Mesh, Object3D, Quaternion, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
 import { Context } from './engine_setup';
 import cannonDebugger from 'cannon-es-debugger'
-import * as utils from "./engine_utils"
-import * as threeutils from "./engine_three_utils"
+import { getParam } from "./engine_utils"
+import { getWorldPosition, getWorldQuaternion, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
 import {
     IComponent as Component,
     IGameObject as GameObject,
     ICollider,
-    IRigidbody as Rigidbody, $physicsKey,
-    Collision, CannonCollision,
-    ICollisionContext,
-    IComponent
-}
-    from './engine_types';
+    IRigidbody as Rigidbody,
+    $physicsKey,
+    Collision, 
+    CannonCollision,
+    ICollisionContext
+} from './engine_types';
 import { Shape } from 'cannon-es';
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
-import { getComponentInChildren } from './engine_components';
 
 
-const debugPhysics = utils.getParam("debugphysics");
-const debugCollisions = utils.getParam("debugcollisions");
+const debugPhysics = getParam("debugphysics");
+const debugCollisions = getParam("debugcollisions");
 
 export class BodyOptions {
     mass: number = 1;
@@ -35,16 +34,16 @@ export class BodyOptions {
 
 // TODO: refactor to return some kind of handle for adding/removing
 class PhysicsObject {
-    obj: THREE.Object3D;
-    parent: THREE.Object3D | null;
-    body: CANNON.Body | null;
+    obj: Object3D;
+    parent: Object3D | null;
+    body: Body | null;
     shapes: Array<Shape> = [];
     collisonCallback: Function | null = null;
 
     _hasRigidbody: boolean = false;
     _didSleepLastStep: boolean = false;
 
-    constructor(obj: THREE.Object3D, body: CANNON.Body | null) {
+    constructor(obj: Object3D, body: Body | null) {
         this.obj = obj;
         this.parent = obj.parent;
         this.body = body;
@@ -54,28 +53,28 @@ class PhysicsObject {
 }
 
 export class RaycastOptions {
-    ray: THREE.Ray | undefined = undefined;
-    cam: THREE.Camera | undefined | null = undefined;
-    screenPoint: THREE.Vector2 | undefined = undefined;
-    raycaster: THREE.Raycaster | undefined = undefined;
-    results: Array<THREE.Intersection> | undefined = undefined;
-    targets: Array<THREE.Object3D> | undefined = undefined;
+    ray: Ray | undefined = undefined;
+    cam: Camera | undefined | null = undefined;
+    screenPoint: Vector2 | undefined = undefined;
+    raycaster: Raycaster | undefined = undefined;
+    results: Array<Intersection> | undefined = undefined;
+    targets: Array<Object3D> | undefined = undefined;
     recursive: boolean | undefined = true;
     minDistance: number | undefined = undefined;
     maxDistance: number | undefined = undefined;
     lineThreshold: number | undefined = undefined;
-    layerMask: THREE.Layers | number | undefined = undefined;
-    ignore: THREE.Object3D[] | undefined = undefined;
+    layerMask: Layers | number | undefined = undefined;
+    ignore: Object3D[] | undefined = undefined;
 
     screenPointFromOffset(ox: number, oy: number) {
-        if (this.screenPoint === undefined) this.screenPoint = new THREE.Vector2();
+        if (this.screenPoint === undefined) this.screenPoint = new Vector2();
         this.screenPoint.x = ox / window.innerWidth * 2 - 1;
         this.screenPoint.y = -(oy / window.innerHeight) * 2 + 1;
     }
 
     setMask(mask: number) {
-        if (!this.layerMask) this.layerMask = new THREE.Layers();
-        const lm = this.layerMask as THREE.Layers;
+        if (!this.layerMask) this.layerMask = new Layers();
+        const lm = this.layerMask as Layers;
         if (lm)
             lm.mask = mask;
         else this.layerMask = mask;
@@ -84,11 +83,11 @@ export class RaycastOptions {
     public static AllLayers = 0xFFFFFFFF;
 }
 
-export class SphereIntersection implements THREE.Intersection {
+export class SphereIntersection implements Intersection {
     distance: number;
-    point: THREE.Vector3;
-    object: THREE.Object3D;
-    constructor(object: THREE.Object3D, distance: number, point: THREE.Vector3) {
+    point: Vector3;
+    object: Object3D;
+    constructor(object: Object3D, distance: number, point: Vector3) {
         this.object = object;
         this.distance = distance;
         this.point = point;
@@ -99,9 +98,9 @@ export class Physics {
 
     // raycasting
 
-    private readonly raycaster: THREE.Raycaster = new THREE.Raycaster();
+    private readonly raycaster: Raycaster = new Raycaster();
     private readonly defaultRaycastOptions: RaycastOptions = new RaycastOptions();
-    private readonly targetBuffer: Array<THREE.Object3D> = new Array<THREE.Object3D>(1);
+    private readonly targetBuffer: Array<Object3D> = new Array<Object3D>(1);
     private readonly defaultThresholds = {
         Mesh: {},
         Line: { threshold: 0 },
@@ -111,60 +110,56 @@ export class Physics {
     }
 
 
-    private sphereResults: Array<THREE.Intersection> = new Array<THREE.Intersection>();
-    private sphereMask: THREE.Layers = new THREE.Layers();
-    public sphereOverlap(spherePos: THREE.Vector3, radius: number): Array<THREE.Intersection> {
+    private sphereResults: Array<Intersection> = new Array<Intersection>();
+    private sphereMask: Layers = new Layers();
+    public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): Array<Intersection> {
         this.sphereResults.length = 0;
         if (!this.context.scene) return this.sphereResults;
-        const sphere = new THREE.Sphere(spherePos, radius);
+        const sphere = new Sphere(spherePos, radius);
         const mask = this.sphereMask;
         mask.enableAll();
         mask.disable(2);
-        // mask testing
-        // const dummy = new THREE.Layers();
-        // dummy.set(2);
-        // console.log(dummy.mask, mask.test(dummy))
         for (const ch of this.context.scene.children) {
-            const i = this.onSphereOverlap(ch, sphere, mask);
-            if (i) this.sphereResults.push(i);
+            this.onSphereOverlap(ch, sphere, mask, this.sphereResults, traverseChildsAfterHit);
         }
         return this.sphereResults.sort((a, b) => a.distance - b.distance);
     }
-    private tempBoundingBox: THREE.Box3 = new THREE.Box3();
-    private onSphereOverlap(obj: THREE.Object3D, sp: THREE.Sphere, mask: THREE.Layers): THREE.Intersection | null {
-        if (obj.type === "Mesh") {
-            if (!obj.layers.test(mask)) return null;
-            const mesh = obj as THREE.Mesh;
+    private tempBoundingBox: Box3 = new Box3();
+    private onSphereOverlap(obj: Object3D, sp: Sphere, mask: Layers, results: Array<Intersection>, traverseChildsAfterHit: boolean): void {
+        if (obj.type === "Mesh" && obj.layers.test(mask)) {
+            const mesh = obj as Mesh;
             const geo = mesh.geometry;
             if (!geo.boundingBox)
                 geo.computeBoundingBox();
-            if (!geo.boundingBox) return null;
-            if (mesh.matrixWorldNeedsUpdate) mesh.updateMatrixWorld();
-            const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
-            if (sp.intersectsBox(test)) {
-                // console.log(obj, obj.layers.test(mask), obj.layers.mask, mask.mask);
-                const wp = threeutils.getWorldPosition(obj);
-                const dist = wp.distanceTo(sp.center);
-                const int = new SphereIntersection(obj, dist, sp.center.clone());
-                return int;
+            if (geo.boundingBox) {
+                if (mesh.matrixWorldNeedsUpdate) mesh.updateMatrixWorld();
+                const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
+                if (sp.intersectsBox(test)) {
+                    // console.log(obj, obj.layers.test(mask), obj.layers.mask, mask.mask);
+                    const wp = getWorldPosition(obj);
+                    const dist = wp.distanceTo(sp.center);
+                    const int = new SphereIntersection(obj, dist, sp.center.clone());
+                    results.push(int);
+                    if (!traverseChildsAfterHit) return;
+                }
             }
         }
-        else if (obj.children) {
+        if (obj.children) {
             for (const ch of obj.children) {
-                const i = this.onSphereOverlap(ch, sp, mask);
-                if (i) return i;
+                const len = results.length;
+                this.onSphereOverlap(ch, sp, mask, results, traverseChildsAfterHit);
+                if (len != results.length && !traverseChildsAfterHit) return;
             }
         }
-        return null;
     }
 
-    public raycastFromRay(ray: THREE.Ray, options: RaycastOptions | null = null): Array<THREE.Intersection> {
+    public raycastFromRay(ray: Ray, options: RaycastOptions | null = null): Array<Intersection> {
         const opts = options ?? this.defaultRaycastOptions;
         opts.ray = ray;
         return this.raycast(opts);
     }
 
-    public raycast(options: RaycastOptions | null = null): Array<THREE.Intersection> {
+    public raycast(options: RaycastOptions | null = null): Array<Intersection> {
         if (!options) options = this.defaultRaycastOptions;
         const mp = options.screenPoint ?? this.context.input.mousePositionRC;
         const rc = options.raycaster ?? this.raycaster;
@@ -194,14 +189,14 @@ export class Physics {
         let results = options.results;
         if (!results) {
             if (!this.defaultRaycastOptions.results)
-                this.defaultRaycastOptions.results = new Array<THREE.Intersection>();
+                this.defaultRaycastOptions.results = new Array<Intersection>();
             results = this.defaultRaycastOptions.results;
         }
 
         // layermask
-        // https://github.com/mrdoob/three.js/blob/master/src/core/Layers.js
+        // https://github.com/mrdoob/js/blob/master/src/core/Layers.js
         if (options.layerMask !== undefined) {
-            if (options.layerMask instanceof THREE.Layers)
+            if (options.layerMask instanceof Layers)
                 rc.layers.mask = options.layerMask.mask;
             else
                 rc.layers.mask = options.layerMask;
@@ -236,11 +231,11 @@ export class Physics {
 
     private context: Context;
 
-    private world: CANNON.World = new CANNON.World();
+    private world: World = new World();
     private objects: Array<PhysicsObject> = [];
 
-    private tempPosition: THREE.Vector3 = new THREE.Vector3();
-    private tempQuaternion: THREE.Quaternion = new THREE.Quaternion();
+    private tempPosition: Vector3 = new Vector3();
+    private tempQuaternion: Quaternion = new Quaternion();
 
     constructor(context: Context) {
         this.context = context;
@@ -248,7 +243,7 @@ export class Physics {
         if (debugPhysics) {
             // https://www.npmjs.com/package/cannon-es-debugger
             const opts = {};
-            opts["onInit"] = (_body: CANNON.Body, mesh: THREE.Mesh, _shape: CANNON.Shape) => {
+            opts["onInit"] = (_body: Body, mesh: Mesh, _shape: Shape) => {
                 // ignore in raycast
                 mesh.layers.set(-1);
             };
@@ -267,21 +262,21 @@ export class Physics {
         this.world.addEventListener("postStep", listener);
     }
 
-    public addConstraint(constraint: CANNON.Constraint) {
+    public addConstraint(constraint: Constraint) {
         this.world.addConstraint(constraint);
     }
 
-    public setGravity(vec: THREE.Vector3) {
+    public setGravity(vec: Vector3) {
         this.world.gravity.set(vec.x, vec.y, vec.z);
     }
 
-    public multiplyGravity(vec: THREE.Vector3) {
+    public multiplyGravity(vec: Vector3) {
         this.world.gravity.x *= vec.x;
         this.world.gravity.y *= vec.y;
         this.world.gravity.z *= vec.z;
     }
 
-    public addBody(go: GameObject, body: CANNON.Body) {
+    public addBody(go: GameObject, body: Body) {
         for (let i = 0; i < this.objects.length; i++) {
             const reg = this.objects[i];
             if (reg.obj === go) {
@@ -295,7 +290,7 @@ export class Physics {
             this.world.addBody(body);
     }
 
-    public removeBody(go: GameObject, body: CANNON.Body, removeCompletely: boolean = true) {
+    public removeBody(go: GameObject, body: Body, removeCompletely: boolean = true) {
         this.world.removeBody(body);
         for (let i = 0; i < this.objects.length; i++) {
             const reg = this.objects[i];
@@ -308,7 +303,7 @@ export class Physics {
         }
     }
 
-    public removeShape(obj: THREE.Object3D, shape: CANNON.Shape) {
+    public removeShape(obj: Object3D, shape: Shape) {
         for (const reg of this.objects) {
             if (reg.obj === obj) {
                 if (reg.body) {
@@ -321,13 +316,13 @@ export class Physics {
     }
 
     // TODO: make it work with rigibody in parent
-    public createBody(obj: THREE.Object3D, settings: BodyOptions): CANNON.Body {
+    public createBody(obj: Object3D, settings: BodyOptions): Body {
         const body = this.internalCreateBody(obj, null);
         if (settings.mass)
             body.mass = settings.mass;
         if (settings.kinematic)
-            body.type = CANNON.Body.KINEMATIC;
-        else body.type = CANNON.Body.DYNAMIC;
+            body.type = Body.KINEMATIC;
+        else body.type = Body.DYNAMIC;
         if (settings.drag)
             body.linearDamping = settings.drag;
         if (settings.angularDrag)
@@ -351,17 +346,17 @@ export class Physics {
         return body;
     }
 
-    public addBoxCollider(obj: THREE.Object3D, trigger: boolean, center: THREE.Vector3, size: THREE.Vector3, rb: Rigidbody | null): CANNON.Shape {
+    public addBoxCollider(obj: Object3D, trigger: boolean, center: Vector3, size: Vector3, rb: Rigidbody | null): Shape {
 
         const scale = this.tempPosition;
         obj.getWorldScale(scale);
 
-        const pos = new CANNON.Vec3(
+        const pos = new Vec3(
             .5 * scale.x * size.x,
             .5 * scale.y * size.y,
             .5 * scale.z * size.z
         );
-        const shape = new CANNON.Box(pos);
+        const shape = new Box(pos);
         shape.collisionResponse = !trigger;
 
         center = center.clone();
@@ -377,12 +372,12 @@ export class Physics {
         return shape;
     }
 
-    public addSphereCollider(obj: THREE.Object3D, center: THREE.Vector3, radius: number, rb: Rigidbody | null): CANNON.Shape {
+    public addSphereCollider(obj: Object3D, center: Vector3, radius: number, rb: Rigidbody | null): Shape {
         const scale = this.tempPosition;
         obj.getWorldScale(scale);
 
         const factor = Math.max(scale.x, scale.y, scale.z);
-        const shape = new CANNON.Sphere(radius * factor);
+        const shape = new PhysicsSphere(radius * factor);
         // shape.collisionResponse = !trigger;
 
         center = center.clone();
@@ -398,11 +393,11 @@ export class Physics {
         return shape;
     }
 
-    public addMeshCollider(_obj: THREE.Object3D) {
-        // see https://github.com/schteppe/cannon.js/blob/master/demos/bunny.html
+    public addMeshCollider(_obj: Object3D) {
+        // see https://github.com/schteppe/js/blob/master/demos/bunny.html
         if (debugPhysics)
             console.warn("TODO mesh collider not yet supported")
-        // const geometry: THREE.BufferGeometry = obj["geometry"];
+        // const geometry: BufferGeometry = obj["geometry"];
         // console.log(geometry);
         // const size = geometry.boundingBox.max.clone();
         // size.sub(geometry.boundingBox.min);
@@ -418,31 +413,31 @@ export class Physics {
         //     const i0 = geometry.index.array[i];
         //     const i1 = geometry.index.array[i + 1];
         //     const i2 = geometry.index.array[i + 2];
-        //     const v0 = new THREE.Vector3(verts[i0 * 3], verts[i0 * 3 + 1], verts[i0 * 3 + 2]);
-        //     const v1 = new THREE.Vector3(verts[i1 * 3], verts[i1 * 3 + 1], verts[i1 * 3 + 2]);
-        //     const v2 = new THREE.Vector3(verts[i2 * 3], verts[i2 * 3 + 1], verts[i2 * 3 + 2]);
+        //     const v0 = new Vector3(verts[i0 * 3], verts[i0 * 3 + 1], verts[i0 * 3 + 2]);
+        //     const v1 = new Vector3(verts[i1 * 3], verts[i1 * 3 + 1], verts[i1 * 3 + 2]);
+        //     const v2 = new Vector3(verts[i2 * 3], verts[i2 * 3 + 1], verts[i2 * 3 + 2]);
         //     const face = [v0, v1, v2];
         //     faces.push(face);
         // }
-        // const convex = new THREE.ConvexBufferGeometry(faces);
+        // const convex = new ConvexBufferGeometry(faces);
 
-        // var shape = new CANNON.ConvexPolyhedron({ verts, faces });
+        // var shape = new ConvexPolyhedron({ verts, faces });
         // this.addShape(obj, shape);
     }
 
-    private isAlreadyRegistered(body: CANNON.Body): boolean {
+    private isAlreadyRegistered(body: Body): boolean {
         for (const obj of this.objects) {
             if (obj.body === body) return true;
         }
         return false;
     }
 
-    private readonly tempMat1: THREE.Matrix4 = new THREE.Matrix4();
-    private readonly tempMat2: THREE.Matrix4 = new THREE.Matrix4();
+    private readonly tempMat1: Matrix4 = new Matrix4();
+    private readonly tempMat2: Matrix4 = new Matrix4();
 
-    private addShape(obj: THREE.Object3D, shape: CANNON.Shape, center: THREE.Vector3, rb: Rigidbody | null): CANNON.Body | null {
+    private addShape(obj: Object3D, shape: Shape, center: Vector3, rb: Rigidbody | null): Body | null {
 
-        let body: CANNON.Body | null = null;
+        let body: Body | null = null;
 
         if (rb) {
             // if (debugPhysics)
@@ -454,7 +449,7 @@ export class Physics {
         else {
             // console.log("has no rb", obj);
             body = this.internalCreateBody(obj, null);
-            body.type = CANNON.Body.KINEMATIC;
+            body.type = Body.KINEMATIC;
         }
 
         if (body) {
@@ -476,14 +471,14 @@ export class Physics {
                 this.tempMat1.decompose(wp, wr, this.tempPosition);
             }
             else {
-                wp = threeutils.getWorldPosition(obj);
+                wp = getWorldPosition(obj);
                 const bp = body.position;
                 wp.x -= bp.x;
                 wp.y -= bp.y;
                 wp.z -= bp.z;
 
-                wr = threeutils.getWorldQuaternion(obj);
-                const r = new THREE.Quaternion(body.quaternion.x, body.quaternion.y, body.quaternion.z, body.quaternion.w);
+                wr = getWorldQuaternion(obj);
+                const r = new Quaternion(body.quaternion.x, body.quaternion.y, body.quaternion.z, body.quaternion.w);
                 wr.multiply(r.invert());
             }
             // get rotation difference
@@ -497,14 +492,14 @@ export class Physics {
             //     this.tempMat.setPosition(wp);
             //     this.tempMat.makeRotationFromQuaternion(wr);
             //     this.tempMat.multiplyMatrices(this.tempMat, rb?.gameObject.matrix);
-            //     this.tempMat.decompose(this.tempPosition, this.tempQuaternion, new THREE.Vector3());
+            //     this.tempMat.decompose(this.tempPosition, this.tempQuaternion, new Vector3());
             //     wp.copy(this.tempPosition);
             // }
 
             // wp.applyQuaternion(wr);
 
-            const pos = new CANNON.Vec3(wp.x, wp.y, wp.z);
-            const rot = new CANNON.Quaternion(wr.x, wr.y, wr.z, wr.w);
+            const pos = new Vec3(wp.x, wp.y, wp.z);
+            const rot = new PhysicsQuaternion(wr.x, wr.y, wr.z, wr.w);
             body.addShape(shape, pos, rot);
             body.updateMassProperties();
             this.world.addBody(body);
@@ -524,8 +519,8 @@ export class Physics {
         }
     }
 
-    private temp: THREE.Vector3 = new THREE.Vector3();
-    private tempQuat: THREE.Quaternion = new THREE.Quaternion();
+    private temp: Vector3 = new Vector3();
+    private tempQuat: Quaternion = new Quaternion();
 
     public postStep() {
         this._isUpdatingPhysicsWorld = true;
@@ -533,43 +528,48 @@ export class Physics {
             const entry = this.objects[i];
             const body = entry.body;
             if (!body || !body.world) continue;
+            const obj = entry.obj;
 
             body.sleepTick(this.context.time.time);
 
             if (debugPhysics) {
-                if (!entry._didSleepLastStep && body.sleepState === CANNON.Body.SLEEPING) {
+                if (!entry._didSleepLastStep && body.sleepState === Body.SLEEPING) {
                     console.log("BODY SLEEPING", body);
                 }
-                else if (entry._didSleepLastStep && body.sleepState !== CANNON.Body.SLEEPING) {
+                else if (entry._didSleepLastStep && body.sleepState !== Body.SLEEPING) {
                     console.log("BODY WOKE UP", body);
                 }
             }
-            entry._didSleepLastStep = body.sleepState === CANNON.Body.SLEEPING;
-            // if(body.sleepState === CANNON.Body.SLEEPING) {
+            entry._didSleepLastStep = body.sleepState === Body.SLEEPING;
+            // if(body.sleepState === Body.SLEEPING) {
             //     console.log("SLEEP", body.name);
             // }
-            // if (body.type == CANNON.Body.KINEMATIC) continue;
-            const obj = entry.obj;
+            // if (body.type == Body.KINEMATIC) continue;
 
-            if (body.type === CANNON.Body.KINEMATIC) {
-                const wp = threeutils.getWorldPosition(obj, this.temp);
+            if (body.type === Body.KINEMATIC) {
+                const wp = getWorldPosition(obj, this.temp);
                 body.position.set(wp.x, wp.y, wp.z);
-                const rot = threeutils.getWorldQuaternion(obj, this.tempQuat);
+                const rot = getWorldQuaternion(obj, this.tempQuat);
                 body.quaternion.set(rot.x, rot.y, rot.z, rot.w);
                 continue;
             }
 
+            if ((isNaN(body.position.x) || isNaN(body.position.y) || isNaN(body.position.z))) {
+                console.error("body position is NaN on", obj.name, "this usually means some colliders are overlapping", body.previousPosition, obj.position);
+                this.world.removeBody(body);
+                continue;
+            }
 
 
             // when reparenting (e.g. attached to controller) I think it doesnt work with previous parent? need to test again, to tired now
             if (entry.parent && obj.parent === entry.parent) {
 
-                threeutils.setWorldQuaternionXYZW(obj,
+                setWorldQuaternionXYZW(obj,
                     body.quaternion.x, body.quaternion.y, body.quaternion.z, body.quaternion.w
                 );
 
                 const p = body.position;
-                threeutils.setWorldPositionXYZ(obj, p.x, p.y, p.z);
+                setWorldPositionXYZ(obj, p.x, p.y, p.z);
 
                 if (body.velocity.length() > body.sleepSpeedLimit) {
                     InstancingUtil.markDirty(obj);
@@ -597,20 +597,20 @@ export class Physics {
         this._isUpdatingPhysicsWorld = false;
     }
 
-    private internalCreateBody(obj: THREE.Object3D, shape: CANNON.Shape | undefined | null): CANNON.Body {
+    private internalCreateBody(obj: Object3D, shape: Shape | undefined | null): Body {
 
-        const body = new CANNON.Body();
+        const body = new Body();
         body["_owner"] = obj;
         body["_name"] = obj.name;
         obj.getWorldPosition(this.tempPosition);
         const pos = this.tempPosition;
-        body.position = new CANNON.Vec3(pos.x, pos.y, pos.z);
+        body.position = new Vec3(pos.x, pos.y, pos.z);
 
         const quat = this.tempQuaternion;
         obj.getWorldQuaternion(quat);
-        body.quaternion = new CANNON.Quaternion(quat.x, quat.y, quat.z, quat.w);
+        body.quaternion = new PhysicsQuaternion(quat.x, quat.y, quat.z, quat.w);
 
-        body.type = CANNON.Body.KINEMATIC;
+        body.type = Body.KINEMATIC;
         if (shape) {
             body.addShape(shape);
             body.updateMassProperties();
@@ -618,7 +618,7 @@ export class Physics {
         return body;
     }
 
-    // private findObject(obj: THREE.Object3D): PhysicsObject | null {
+    // private findObject(obj: Object3D): PhysicsObject | null {
     //     for (let i = 0; i < this.objects.length; i++) {
     //         const entry = this.objects[i];
     //         if (entry.obj == obj)
@@ -648,7 +648,7 @@ export class Physics {
 
     private readonly collisionContext: ICollisionContext = new CollisionContext();
 
-    private raiseCollisionEvents(obj: THREE.Object3D, event: CannonCollision) {
+    private raiseCollisionEvents(obj: Object3D, event: CannonCollision) {
         const collision = new Collision(obj, event, this.collisionContext);
         if (debugCollisions)
             console.log("collision between", event.contact.bi, event.contact.bj, obj, event);
@@ -665,9 +665,9 @@ export class Physics {
         }
     }
 
-    private onEndContact(args: { bodyA: CANNON.Body, bodyB: CANNON.Body }) {
-        // if(args.bodyB.sleepState !== CANNON.Body.AWAKE) return;
-        // console.log("END", CANNON.BODY_SLEEP_STATES, args.bodyB.sleepState);
+    private onEndContact(args: { bodyA: Body, bodyB: Body }) {
+        // if(args.bodyB.sleepState !== Body.AWAKE) return;
+        // console.log("END", BODY_SLEEP_STATES, args.bodyB.sleepState);
         const obj1 = args.bodyA[$physicsKey];
         const obj2 = args.bodyB[$physicsKey];
         // console.log(obj2);
@@ -690,7 +690,7 @@ export class Physics {
 }
 
 export interface IColliderProvider {
-    getCollider(obj: THREE.Object3D): ICollider;
+    getCollider(obj: Object3D): ICollider;
 }
 
 let colliderProvider: IColliderProvider | null = null;
@@ -700,7 +700,7 @@ export function registerColliderProvider(prov: IColliderProvider) {
 
 class CollisionContext implements ICollisionContext {
 
-    getCollider(obj: THREE.Object3D<THREE.Event>): ICollider {
+    getCollider(obj: Object3D<Event>): ICollider {
         return colliderProvider!.getCollider(obj);
     }
 

package/src/engine/engine_serialization_core.ts

@@ -5,6 +5,9 @@ import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
 import { SourceIdentifier } from "./engine_types";
 import { debugExtension } from "../engine/engine_default_parameters";
+import { LogType, showBalloonMessage } from "./debug/debug";
+import { isLocalNetwork } from "./engine_networking_utils";
+import { $BuiltInTypeFlag } from "./engine_typestore";
 
 const debug = getParam("debugserializer");
 
@@ -312,6 +315,8 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
         implictlyAssignPrimitiveTypes(obj, serializedData);
     }
 
+    checkObjectAssignments(obj, serializedData);
+
     if (obj.onAfterDeserialize !== undefined) {
         obj.onAfterDeserialize(serializedData, context);
     }
@@ -320,6 +325,42 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
     return true;
 }
 
+const blockChecks = getParam("noerrors");
+function checkObjectAssignments(obj: any, _serializedData?: any) {
+    if(blockChecks) return;
+    if (isLocalNetwork() === false) return;
+    if (!obj) return;
+
+    // ignore builtin components that we dont want to check
+    if(obj.constructor && obj.constructor[$BuiltInTypeFlag] === true) return;
+
+    const typeName = obj.constructor?.name as string;
+    // test if any object reference is missing serializable
+    const ownKeys = Object.getOwnPropertyNames(obj);
+    for (const key of ownKeys) {
+        if (key === "sourceId") continue;
+        const value = obj[key];
+        if (value === undefined || value === null) continue;
+        if (typeof value === "object") {
+            if (!value.isObject3D) {
+                if (typeof value["node"] === "number" || typeof value["guid"] === "string") {
+                    const hasOtherKeys = Object.keys(value).length > 1;
+                    if (!hasOtherKeys) {
+                        showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(Object3D)\n${key}? : Object3D;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable" target="_blank">documentation</a>`, LogType.Warn);
+                        console.warn(typeName, key, obj[key], obj);
+                    }
+                }
+            }
+        }
+        else if (typeof value === "string") {
+            if (value.endsWith(".gltf") || value.endsWith(".glb")) {
+                showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(AssetReference)\n${key}? : AssetReference;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable" target="_blank">documentation</a>`, LogType.Warn);
+                console.warn(typeName, key, obj[key], obj);
+            }
+        }
+    }
+}
+
 function implictlyAssignPrimitiveTypes(obj: any, serializedData: any) {
     // implictly assign serialized primitive fields
     for (const key of Object.keys(serializedData)) {

package/src/engine/engine_setup.ts

@@ -600,7 +600,7 @@ export class Context {
 		this._isRendering = true;
 		this.renderRequiredTextures();
 		if (!this.isManagedExternally) {
-			if (this.composer) {
+			if (this.composer && !this.isInXR) {
 				this.composer.render();
 			}
 			else if (this.mainCamera) {