@needle-tools/engine 2.38.0-pre.2 → 2.40.0-pre

package/src/engine/engine_gizmos.ts

@@ -1,15 +1,127 @@
 import * as THREE from 'three';
+import { BufferAttribute, Line, BoxGeometry, EdgesGeometry, Color, LineSegments, LineBasicMaterial, Object3D, Mesh, SphereGeometry, ColorRepresentation, Vector3 } from 'three';
+import { Context } from './engine_setup';
+import { setWorldPosition, setWorldPositionXYZ } from './engine_three_utils';
+import { Vec3 } from './engine_types';
 
-const box: THREE.BoxGeometry = new THREE.BoxGeometry(1, 1, 1);
+const _tmp = new Vector3();
 
-export function CreateWireCube(col: THREE.ColorRepresentation | null = null) : THREE.LineSegments {
-    const color = new THREE.Color(col ?? 0xdddddd);
+export class Gizmos {
+
+    static DrawRay(origin: Vec3, dir: Vec3, color: ColorRepresentation = 0x888888, duration: number = 0, depthTest: boolean = true) {
+        const obj = Internal.getLine(duration);
+        const positions = obj.geometry.getAttribute("position");
+        positions.setXYZ(0, origin.x, origin.y, origin.z);
+        _tmp.set(dir.x, dir.y, dir.z).multiplyScalar(999999999);
+        positions.setXYZ(1, origin.x + _tmp.x, origin.y + _tmp.y, origin.z + _tmp.z);
+        positions.needsUpdate = true;
+        obj.material["color"].set(color);
+        obj.material["depthTest"] = depthTest;
+    }
+
+    static DrawLine(pt0: { x: number, y: number, z: number }, pt1: { x: number, y: number, z: number }, color: ColorRepresentation = 0x888888, duration: number = 0, depthTest: boolean = true) {
+        const obj = Internal.getLine(duration);
+
+        const positions = obj.geometry.getAttribute("position");
+        positions.setXYZ(0, pt0.x, pt0.y, pt0.z);
+        positions.setXYZ(1, pt1.x, pt1.y, pt1.z);
+        positions.needsUpdate = true;
+        obj.material["color"].set(color);
+        obj.material["depthTest"] = depthTest;
+    }
+
+    static DrawWireSphere(center: { x: number, y: number, z: number }, radius: number, color: ColorRepresentation = 0x888888, duration: number = 0, depthTest: boolean = true) {
+        const obj = Internal.getSphere(radius, duration, true);
+        setWorldPositionXYZ(obj, center.x, center.y, center.z);
+        obj.material["color"].set(color);
+        obj.material["depthTest"] = depthTest;
+    }
+
+    static DrawSphere(center: { x: number, y: number, z: number }, radius: number, color: ColorRepresentation = 0x888888, duration: number = 0, depthTest: boolean = true) {
+        const obj = Internal.getSphere(radius, duration, false);
+        setWorldPositionXYZ(obj, center.x, center.y, center.z);
+        obj.material["color"].set(color);
+        obj.material["depthTest"] = depthTest;
+    }
+}
+
+const box: BoxGeometry = new BoxGeometry(1, 1, 1);
+export function CreateWireCube(col: THREE.ColorRepresentation | null = null): THREE.LineSegments {
+    const color = new Color(col ?? 0xdddddd);
     // const material = new THREE.MeshBasicMaterial();
     // material.color = new THREE.Color(col ?? 0xdddddd);
     // material.wireframe = true;
     // const box = new THREE.Mesh(box, material);
     // box.name = "BOX_GIZMO";
-    const edges = new THREE.EdgesGeometry(box);
-    const line = new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: color }));
+    const edges = new EdgesGeometry(box);
+    const line = new LineSegments(edges, new LineBasicMaterial({ color: color }));
     return line;
+}
+
+
+
+const $cacheSymbol = Symbol("GizmoCache");
+class Internal {
+    // private static createdLines: number = 0;
+
+    static getLine(duration: number): Line {
+        let line = this.linesCache.pop();
+        if (!line) {
+            line = new Line();
+            let positions = line.geometry.getAttribute("position");
+            if (!positions) {
+                positions = new BufferAttribute(new Float32Array(2 * 3), 3);
+                line.geometry.setAttribute("position", positions);
+            }
+        }
+        this.registerTimedObject(Context.Current, line, duration, this.linesCache);
+        return line;
+    }
+
+    static getSphere(radius: number, duration: number, wireframe: boolean): Mesh {
+
+        let sphere = this.spheresCache.pop();
+        if (!sphere) {
+            sphere = new Mesh(new SphereGeometry(.5, 8, 8));
+        }
+        sphere.scale.set(radius, radius, radius);
+        sphere.material["wireframe"] = wireframe;
+        this.registerTimedObject(Context.Current, sphere, duration, this.spheresCache);
+        return sphere;
+    }
+
+    private static linesCache: Array<Line> = [];
+    private static spheresCache: Mesh[] = [];
+
+    private static registerTimedObject(context: Context, object: Object3D, duration: number, cache: Array<Object3D>) {
+        if (!this.contextPostRenderCallbacks.get(context)) {
+            const cb = () => { this.onPostRender(context, this.timedObjectsBuffer, this.timesBuffer) };
+            this.contextPostRenderCallbacks.set(context, cb);
+            context.post_render_callbacks.push(cb);
+        }
+        object[$cacheSymbol] = cache;
+        this.timedObjectsBuffer.push(object);
+        this.timesBuffer.push(Context.Current.time.time + duration);
+        context.scene.add(object);
+    }
+
+
+    private static timedObjectsBuffer = new Array<Object3D>();
+    private static timesBuffer = new Array<number>();
+    private static contextPostRenderCallbacks = new Map<Context, () => void>();
+
+    private static onPostRender(ctx: Context, objects: Array<Object3D>, times: Array<number>) {
+        const time = ctx.time.time;
+        for (let i = 0; i < objects.length; i++) {
+            if (time > times[i]) {
+                const obj = objects[i];
+                const cache = obj[$cacheSymbol];
+                cache.push(obj as Line);
+                ctx.scene.remove(obj);
+                objects.splice(i, 1);
+                times.splice(i, 1);
+            }
+        }
+    }
+
 }

package/src/engine/engine_gltf_builtin_components.ts

@@ -5,7 +5,7 @@ import { Component, GameObject } from "../engine-components/Component";
 import { InstantiateIdProvider } from "./engine_networking_instantiate"
 import { Context } from "./engine_setup";
 import { deserializeObject, serializeObject } from "./engine_serialization";
-import { assign, ISerializable, SerializationContext } from "./engine_serialization_core";
+import { assign, ImplementationInformation, ISerializable, SerializationContext } from "./engine_serialization_core";
 import { NEEDLE_components } from "./extensions/NEEDLE_components";
 import { debugExtension } from "./engine_default_parameters";
 import { builtinComponentKeyName } from "./engine_constants";
@@ -38,6 +38,8 @@ export function writeBuiltinComponentData(comp: Component, context: Serializatio
     return null;
 }
 
+const typeImplementationInformation = new ImplementationInformation();
+
 export async function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider = null, extension?: NEEDLE_components) {
     if (!gltf) return;
     const lateResolve: Array<(gltf: THREE.Object3D) => {}> = [];
@@ -52,6 +54,7 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
     serializationContext.context = context;
     serializationContext.gltf = gltf;
     serializationContext.nodeToObject = extension?.nodeToObjectMap;
+    serializationContext.implementationInformation = typeImplementationInformation;
 
     const deserialize: DeserializeData[] = [];
 
@@ -149,7 +152,7 @@ async function onCreateBuiltinComponents(context: SerializationContext, obj: THR
                         instance.sourceId = context.gltfId;
 
                         // assign basic fields
-                        assign(instance, compData);
+                        assign(instance, compData, context.implementationInformation);
                         // Object.assign(instance, compData);
                         // dont call awake here because some references might not be resolved yet and components that access those fields in awake will throw
                         // for example Duplicatable reference to object might still be { node: id }

package/src/engine/engine_input.ts

@@ -1,6 +1,8 @@
 import * as THREE from 'three';
+import { Vector2 } from 'three';
 import { assign } from './engine_serialization_core';
 import { Context } from './engine_setup';
+import { Vec2 } from './engine_types';
 
 export declare type PointerEventArgs = {
     button: number;
@@ -225,6 +227,11 @@ export class Input extends EventTarget {
         this.onUp(args);
     }
 
+    convertScreenspaceToRaycastSpace(vec2 : Vec2){
+        vec2.x = (vec2.x - this.context.domX) / this.context.domWidth * 2 - 1;
+        vec2.y = -((vec2.y - this.context.domY) / this.context.domHeight) * 2 + 1;
+    }
+
     constructor(context: Context) {
         super();
         this.context = context;
@@ -494,8 +501,11 @@ export class Input extends EventTarget {
         const px = evt.clientX + window.scrollX;
         const py = evt.clientY + window.scrollY;
         while (evt.button >= this._pointerPositionsRC.length) this._pointerPositionsRC.push(new THREE.Vector2());
-        this._pointerPositionsRC[evt.button].x = (px - this.context.domX) / this.context.domWidth * 2 - 1;
-        this._pointerPositionsRC[evt.button].y = -((py - this.context.domY) / this.context.domHeight) * 2 + 1;
+        const rc = this._pointerPositionsRC[evt.button];
+        rc.set(px, py);
+        this.convertScreenspaceToRaycastSpace(rc);
+        // this._pointerPositionsRC[evt.button].x = (px - this.context.domX) / this.context.domWidth * 2 - 1;
+        // this._pointerPositionsRC[evt.button].y = -((py - this.context.domY) / this.context.domHeight) * 2 + 1;
         // console.log(evt.button)
     }
 

package/src/engine/engine_networking.ts

@@ -327,6 +327,11 @@ export class NetworkConnection implements INetworkConnection {
         delete this._state[guid];
     }
 
+    public sendDeleteRemoteStateAll(){
+        this.send("delete-all-state");
+        this._state = {};
+    }
+
     public sendBinary(bin: Uint8Array) {
         if (debugNet) console.log("<< bin", bin.length);
         this._ws?.send(bin);
@@ -563,6 +568,11 @@ export class NetworkConnection implements INetworkConnection {
                     }
                     break;
 
+                case "all-room-state-deleted":
+                    if(debugNet) console.log("RECEIVED all-room-state-deleted");
+                    this._state = {};
+                    break;
+
                 case "ping":
                 case "pong":
                     const time = (message as any).data?.time;

package/src/engine/engine_physics.ts

@@ -1,14 +1,16 @@
 import { BasicDepthPacking, Box3, BufferAttribute, BufferGeometry, Camera, Intersection, Layers, LineBasicMaterial, LineSegments, Matrix4, Mesh, NormalAnimationBlendMode, NumberKeyframeTrack, Object3D, Quaternion, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
 import { Context } from './engine_setup';
-import { getParam } from "./engine_utils"
-import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
+import { CircularBuffer, getParam } from "./engine_utils"
+import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPositionXYZ, setWorldQuaternion, setWorldQuaternionXYZW } from "./engine_three_utils"
 import {
     IComponent,
     ICollider,
     IRigidbody,
     Collision,
     ContactPoint,
-    Vec3
+    Vec3,
+    IGameObject,
+    Vec2,
 } from './engine_types';
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
@@ -21,6 +23,7 @@ export type Rapier = typeof RAPIER;
 const debugPhysics = getParam("debugphysics");
 const debugColliderPlacement = getParam("debugphysicscolliders");
 const debugCollisions = getParam("debugcollisions");
+const showColliders = getParam("showcolliders");
 
 
 declare type PhysicsBody = {
@@ -28,7 +31,9 @@ declare type PhysicsBody = {
     rotation(): { x: number, y: number, z: number, w: number }
 }
 
+/** on physics body and references the needle component */
 const $componentKey = Symbol("needle component");
+/** on needle component and references physics body */
 const $bodyKey = Symbol("physics body");
 const $colliderRigidbody = Symbol("rigidbody");
 // const $removed = Symbol("removed");
@@ -75,6 +80,12 @@ export class SphereIntersection implements Intersection {
     }
 }
 
+declare type PhysicsRaycastResult = {
+    point: Vector3,
+    normal?: Vector3,
+    collider?: ICollider
+}
+
 export class Physics {
 
     // raycasting
@@ -140,6 +151,10 @@ export class Physics {
         return this.raycast(opts);
     }
 
+    /** raycast against rendered three objects. This might be very slow depending on your scene complexity.
+     * We recommend setting objects to IgnoreRaycast layer (2) when you don't need them to be raycasted.
+     * Raycasting SkinnedMeshes is specially expensive.
+     */
     public raycast(options: RaycastOptions | null = null): Array<Intersection> {
         if (!options) options = this.defaultRaycastOptions;
         const mp = options.screenPoint ?? this.context.input.mousePositionRC;
@@ -194,6 +209,7 @@ export class Physics {
         results.length = 0;
         rc.intersectObjects(targets, options.recursive, results);
 
+        // TODO: instead of doing this we should temporerly set these objects to layer 2 during raycasting
         const ignorelist = options.ignore;
         if (ignorelist !== undefined && ignorelist.length > 0) {
             results = results.filter(r => !ignorelist.includes(r.object));
@@ -201,8 +217,70 @@ export class Physics {
         return results;
     }
 
+    private rapierRay = new RAPIER.Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 1 });
+    private raycastVectorsBuffer = new CircularBuffer(() => new Vector3(), 10);
 
+    /** raycast against colliders */
+    public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
+        : null | { point: Vector3, collider:ICollider } {
 
+        const ray = this.getPhysicsRay(this.rapierRay, origin, direction);
+        if (!ray) return null;
+
+        const hit = this.world?.castRay(ray, maxDistance, solid);
+        if (hit) {
+            const point = ray.pointAt(hit.toi);
+            const vec = this.raycastVectorsBuffer.get();
+            vec.set(point.x, point.y, point.z);
+            return { point: vec, collider: hit.collider[$componentKey] };
+        }
+
+        return null;
+    }
+
+    private getPhysicsRay(ray: RAPIER.Ray, origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined): RAPIER.Ray | null {
+        const cam = this.context.mainCamera;
+        // if we get origin in 2d space we need to project it to 3d space
+        if (origin["z"] === undefined) {
+            if (!cam) {
+                console.error("Can not perform raycast from 2d point - no main camera found");
+                return null;
+            }
+            const vec3 = this.raycastVectorsBuffer.get();
+            // if the origin is in screen space we need to convert it to raycaster space
+            if (origin.x > 1 || origin.y > 1 || origin.y < -1 || origin.x < -1) {
+                this.context.input.convertScreenspaceToRaycastSpace(origin);
+            }
+            vec3.set(origin.x, origin.y, -1);
+            vec3.unproject(cam);
+            origin = vec3;
+        }
+
+        const o = origin as Vec3;
+
+        ray.origin.x = o.x;
+        ray.origin.y = o.y;
+        ray.origin.z = o.z;
+        const vec = this.raycastVectorsBuffer.get();
+        if (direction)
+            vec.set(direction.x, direction.y, direction.z);
+        else {
+            if (!cam) {
+                console.error("Can not perform raycast - no camera found");
+                return null;
+            }
+            vec.set(ray.origin.x, ray.origin.y, ray.origin.z);
+            const camPosition = getWorldPosition(cam);
+            vec.sub(camPosition);
+        }
+        // we need to normalize the ray because our input is a max travel length and the direction may be not normalized
+        vec.normalize();
+        ray.dir.x = vec.x;
+        ray.dir.y = vec.y;
+        ray.dir.z = vec.z;
+        // Gizmos.DrawRay(ray.origin, ray.dir, 0xff0000, Infinity);
+        return ray;
+    }
 
     // physics simulation
 
@@ -514,7 +592,7 @@ export class Physics {
     }
 
     private updateDebugRendering(world: World) {
-        if (debugPhysics || debugColliderPlacement) {
+        if (debugPhysics || debugColliderPlacement || showColliders) {
             if (!this.lines) {
                 let material = new LineBasicMaterial({
                     color: 0xffffff,
@@ -661,22 +739,62 @@ export class Physics {
     private static centerConnectionPos = { x: 0, y: 0, z: 0 };
     private static centerConnectionRot = { x: 0, y: 0, z: 0, w: 1 };
 
-    addFixedJoint(body1: IRigidbody, body2: IRigidbody, rel: { x: number, y: number, z: number }) {
+
+
+    addFixedJoint(body1: IRigidbody, body2: IRigidbody) {
         if (!this.world) {
             console.error("Physics world not initialized");
             return;
         }
         const b1 = body1[$bodyKey] as RigidBody;
         const b2 = body2[$bodyKey] as RigidBody;
-        const rot = body1.worldQuaternion.multiply(body2.worldQuaternion.invert());
+
+        this.calculateJointRelativeMatrices(body1.gameObject, body2.gameObject, this._tempMatrix);
+        this._tempMatrix.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
+
         const params = JointData.fixed(
             Physics.centerConnectionPos, Physics.centerConnectionRot,
-            rel, rot
+            this._tempPosition, this._tempQuaternion,
         );
         const joint = this.world.createImpulseJoint(params, b1, b2, true);
-        console.log("ADD JOINT", joint)
+        if (debugPhysics)
+            console.log("ADD FIXED JOINT", joint)
     }
 
+
+
+    addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: { x: number, y: number, z: number }, axis: { x: number, y: number, z: number }) {
+        if (!this.world) {
+            console.error("Physics world not initialized");
+            return;
+        }
+        const b1 = body1[$bodyKey] as RigidBody;
+        const b2 = body2[$bodyKey] as RigidBody;
+
+        this.calculateJointRelativeMatrices(body1.gameObject, body2.gameObject, this._tempMatrix);
+        this._tempMatrix.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
+
+        let params = RAPIER.JointData.revolute(anchor, this._tempPosition, axis);
+        let joint = this.world.createImpulseJoint(params, b1, b2, true);
+        if (debugPhysics)
+            console.log("ADD HINGE JOINT", joint)
+    }
+
+
+    private calculateJointRelativeMatrices(body1: IGameObject, body2: IGameObject, mat: Matrix4) {
+        body1.updateWorldMatrix(true, false);
+        body2.updateWorldMatrix(true, false);
+        const world1 = body1.matrixWorld;
+        const world2 = body2.matrixWorld;
+        // set scale to 1
+        world1.elements[0] = 1;
+        world1.elements[5] = 1;
+        world1.elements[10] = 1;
+        world2.elements[0] = 1;
+        world2.elements[5] = 1;
+        world2.elements[10] = 1;
+        mat.copy(world2).premultiply(world1.invert()).invert();
+    }
 }
 
 
@@ -693,6 +811,7 @@ class PhysicsCollisionHandler {
     }
 
     private activeCollisions: Array<{ collider: ICollider, component: IComponent, collision: Collision }> = [];
+    private activeCollisionsStay: Array<{ collider: ICollider, component: IComponent, collision: Collision }> = [];
     private activeTriggers: Array<{ collider: ICollider, component: IComponent, otherCollider: ICollider }> = [];
 
     handleCollisionEvents() {
@@ -739,22 +858,32 @@ class PhysicsCollisionHandler {
             // TODO: we dont respect the flip value here!
             this.world.contactPair(selfBody, otherBody, (manifold, _flipped) => {
                 foreachComponent(object, (c: IComponent) => {
-                    if (c.onCollisionEnter) {
+                    if (c.onCollisionEnter || c.onCollisionStay || c.onCollisionExit) {
                         if (!collision) {
                             const contacts: Array<ContactPoint> = [];
                             const normal = manifold.normal();
-                            for (let i = 0; i < manifold.numContacts(); i++) {
-                                const pt1 = manifold.localContactPoint1(i);
-                                const dist = manifold.contactDist(i);
-                                if (pt1) {
-                                    const contact = new ContactPoint(pt1, dist, normal);
+                            for (let i = 0; i < manifold.numSolverContacts(); i++) {
+                                // solver points are in world space
+                                // https://rapier.rs/docs/user_guides/javascript/advanced_collision_detection_js#the-contact-graph
+                                const pt = manifold.solverContactPoint(i);
+                                const impulse = manifold.contactImpulse(i);
+                                if (pt) {
+                                    const dist = manifold.contactDist(i);
+                                    const friction = manifold.solverContactFriction(i);
+                                    const contact = new ContactPoint(pt, dist, normal, impulse, friction);
                                     contacts.push(contact);
                                 }
                             }
                             collision = new Collision(object, other, contacts);
                         }
-                        c.onCollisionEnter.call(c, collision);
-                        this.activeCollisions.push({ collider: self, component: c, collision });
+
+                        const info = { collider: self, component: c, collision };
+                        this.activeCollisions.push(info);
+                        if (c.onCollisionStay) {
+                            this.activeCollisionsStay.push(info);
+                        }
+
+                        c.onCollisionEnter?.call(c, collision);
                     }
                 });
             });
@@ -762,7 +891,7 @@ class PhysicsCollisionHandler {
     }
 
     private onHandleCollisionStay() {
-        for (const active of this.activeCollisions) {
+        for (const active of this.activeCollisionsStay) {
             const c = active.component;
             if (c.activeAndEnabled && c.onCollisionStay) {
                 const arg = active.collision;
@@ -792,6 +921,19 @@ class PhysicsCollisionHandler {
                 }
             }
         }
+        for (let i = 0; i < this.activeCollisionsStay.length; i++) {
+            const active = this.activeCollisionsStay[i];
+            const collider = active.collider;
+            if (collider === self && active.collision.collider === other) {
+                const c = active.component;
+                this.activeCollisionsStay.splice(i, 1);
+                i--;
+                if (c.activeAndEnabled && c.onCollisionExit) {
+                    const collision = active.collision;
+                    c.onCollisionExit(collision);
+                }
+            }
+        }
         for (let i = 0; i < this.activeTriggers.length; i++) {
             const active = this.activeTriggers[i];
             const collider = active.collider;

package/src/engine/engine_serialization_core.ts

@@ -144,6 +144,29 @@ export interface ITypeInformation {
     type?: Constructor<any>;
 }
 
+/** holds information if a field was undefined before serialization. This gives us info if we might want to warn the user about missing attributes */
+export class ImplementationInformation {
+
+    private isDevMode = isLocalNetwork();
+    private cache: { [key: string]: string[] } = {};
+
+
+    /** only call when assigning values for the very first time */
+    registerDefinedKeys(typeName: string, type: object) {
+        if (!this.isDevMode) return;
+        if (this.cache[typeName] === undefined) {
+            this.cache[typeName] = Object.keys(type);
+        }
+    }
+
+
+    getDefinedKey(typeName: string, key: string) {
+        if (this.cache[typeName] === undefined) return false;
+        const keys = this.cache[typeName];
+        const res = keys.includes(key);
+        return res;
+    }
+}
 
 // passed to serializers
 export class SerializationContext {
@@ -158,6 +181,8 @@ export class SerializationContext {
     objectToNode?: ObjectToNodeMap;
     context?: Context;
     path?: string;
+    /** holds information if a field was undefined before serialization. This gives us info if we might want to warn the user about missing attributes */
+    implementationInformation?: ImplementationInformation;
 
     constructor(root: THREE.Object3D) {
         this.root = root;
@@ -231,6 +256,7 @@ function collectSerializedTypesInBaseTypes(obj: ISerializable, typeInfoObject?:
     return collectSerializedTypesInBaseTypes(parentTarget, typeInfoObject);
 }
 
+
 export function deserializeObject(obj: ISerializable, serializedData: object, context: SerializationContext): boolean {
     if (!obj) return false;
 
@@ -316,7 +342,7 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
         implictlyAssignPrimitiveTypes(obj, serializedData);
     }
 
-    checkObjectAssignments(obj, serializedData);
+    checkObjectAssignments(obj, serializedData, context.implementationInformation);
 
     if (obj.onAfterDeserialize !== undefined) {
         obj.onAfterDeserialize(serializedData, context);
@@ -327,25 +353,29 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
 }
 
 const blockChecks = getParam("noerrors");
-function checkObjectAssignments(obj: any, _serializedData?: any) {
-    if(blockChecks) return;
+function checkObjectAssignments(obj: any, serializedData: any, implementationInformation?: ImplementationInformation) {
+    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;
+    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);
+    const ownKeys = Object.getOwnPropertyNames(serializedData);
     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;
+        const serialized = serializedData[key];
+        if (implementationInformation?.getDefinedKey(typeName, key) === false) {
+            continue;
+        }
+        if (serialized === undefined || serialized === null) continue;
+        if (typeof serialized === "object") {
+            if (value === undefined || !value.isObject3D) {
+                if (typeof serialized["node"] === "number" || typeof serialized["guid"] === "string") {
+                    const hasOtherKeys = value !== undefined && 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);
@@ -354,7 +384,7 @@ function checkObjectAssignments(obj: any, _serializedData?: any) {
             }
         }
         else if (typeof value === "string") {
-            if (value.endsWith(".gltf") || value.endsWith(".glb")) {
+            if (serialized.endsWith(".gltf") || serialized.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);
             }
@@ -524,7 +554,7 @@ export const $isAssigningProperties = Symbol("assigned component properties");
 // const developmentMode = getParam("dev")
 
 /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
-export function assign(target: any, source: any) {
+export function assign(target: any, source: any, info?: ImplementationInformation) {
     if (source === undefined || source === null) return;
     if (target === undefined || target === null) return;
 
@@ -546,6 +576,13 @@ export function assign(target: any, source: any) {
     //     onlyDeclared = false;
 
     target[$isAssigningProperties] = true;
+    const typeName = target.constructor?.name ?? "unknown";
+
+    // register the keys that the actual type has defined
+    // this will be used later when checking if deserialization has assigned all properties
+    // or if anything could not be deserialized to warn the user
+    info?.registerDefinedKeys(typeName, target);
+
     for (const key of Object.keys(source)) {
         const desc = getPropertyDescriptor(target, key);
         if (onlyDeclared && desc === undefined) continue;