@needle-tools/engine 2.65.2-pre → 2.67.0-pre

package/src/engine/engine_gizmos.ts

@@ -145,10 +145,9 @@ class Internal {
     }
 
     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 = new Mesh(new SphereGeometry(1, 8, 8));
         }
         sphere.scale.set(radius, radius, radius);
         sphere.material["wireframe"] = wireframe;
@@ -176,6 +175,8 @@ class Internal {
             this.contextPostRenderCallbacks.set(context, cb);
             context.post_render_callbacks.push(cb);
         }
+        object.layers.disableAll();
+        object.layers.enable(2);
         object[$cacheSymbol] = cache;
         this.timedObjectsBuffer.push(object);
         this.timesBuffer.push(Context.Current.time.time + duration);

package/src/engine/engine_gltf_builtin_components.ts

@@ -1,15 +1,15 @@
 import "./codegen/register_types";
 import { TypeStore } from "./engine_typestore";
 import * as THREE from "three";
-import { Component, GameObject } from "../engine-components/Component";
+// import { GameObject } from "../engine-components/Component";
 import { InstantiateIdProvider } from "./engine_networking_instantiate"
 import { Context } from "./engine_setup";
 import { deserializeObject, serializeObject } from "./engine_serialization";
 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";
-import { GuidsMap, SourceIdentifier } from "./engine_types";
+import { $originalGuid, builtinComponentKeyName } from "./engine_constants";
+import { GuidsMap, IComponent, IGameObject, SourceIdentifier } from "./engine_types";
 import { UIDProvider } from "./engine_types";
 import { addNewComponent } from "./engine_components";
 import { getParam } from "./engine_utils";
@@ -21,7 +21,7 @@ const debug = debugExtension;
 const debugTypeStore = getParam("debugtypestore");
 if (debugTypeStore) console.log(TypeStore);
 
-export function writeBuiltinComponentData(comp: Component, context: SerializationContext): object | null {
+export function writeBuiltinComponentData(comp: IComponent, context: SerializationContext): object | null {
 
     // const fn = (comp as unknown as ISerializable)?.onBeforeSerialize;
     // if (fn) {
@@ -39,6 +39,7 @@ export function writeBuiltinComponentData(comp: Component, context: Serializatio
 }
 
 const typeImplementationInformation = new ImplementationInformation();
+const $context_deserialize_queue = Symbol("deserialize-queue");
 
 export async function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider = null, extension?: NEEDLE_components) {
     if (!gltf) return;
@@ -56,26 +57,34 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
     serializationContext.nodeToObject = extension?.nodeToObjectMap;
     serializationContext.implementationInformation = typeImplementationInformation;
 
-    const deserialize: DeserializeData[] = [];
+    // If we're loading multiple gltf files in one scene we need to make sure we deserialize all of them in one go
+    // for that we collect them in one list per context
+    let deserializeQueue = context[$context_deserialize_queue];
+    if (!deserializeQueue) deserializeQueue = context[$context_deserialize_queue] = [];
 
     if (gltf.scenes) {
         for (const scene of gltf.scenes) {
-            await onCreateBuiltinComponents(serializationContext, scene, deserialize, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, scene, deserializeQueue, lateResolve);
         }
     }
     if (gltf.children) {
         for (const ch of gltf.children) {
-            await onCreateBuiltinComponents(serializationContext, ch, deserialize, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, ch, deserializeQueue, lateResolve);
         }
     }
 
-
     context.new_scripts_pre_setup_callbacks.push(() => {
-
-        for (const des of deserialize) {
-            handleDeserialization(des, serializationContext);
+        // First deserialize ALL components that were loaded before pre setup
+        // Down below they get new guids assigned so we have to do all of them first
+        // E.g. in cases where we load multiple glb files on startup from one scene
+        // and they might have cross-glb references
+        const queue = context[$context_deserialize_queue];
+        if (queue) {
+            for (const des of queue) {
+                handleDeserialization(des, serializationContext);
+            }
+            queue.length = 0;
         }
-
         // when dropping the same file multiple times we need to generate new guids
         // e.g. SyncTransform sends its own guid to the server to know about ownership
         // so it requires a unique guid for a new instance
@@ -95,7 +104,7 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
     // console.log("finished creating builtin components", gltf.scene?.name, gltf);
 }
 
-function recursiveCreateGuids(obj: GameObject, idProvider: UIDProvider | null, guidsMap: GuidsMap) {
+function recursiveCreateGuids(obj: IGameObject, idProvider: UIDProvider | null, guidsMap: GuidsMap) {
     if (idProvider === null) return;
     if (!obj) return;
     const prev = obj.guid;
@@ -117,7 +126,7 @@ function recursiveCreateGuids(obj: GameObject, idProvider: UIDProvider | null, g
     }
     if (obj.children) {
         for (const child of obj.children) {
-            recursiveCreateGuids(child as GameObject, idProvider, guidsMap);
+            recursiveCreateGuids(child as IGameObject, idProvider, guidsMap);
         }
     }
 }
@@ -140,6 +149,7 @@ declare type LateResolveCallback = (gltf: THREE.Object3D) => void;
 
 const unknownComponentsBuffer: Array<string> = [];
 
+
 async function onCreateBuiltinComponents(context: SerializationContext, obj: THREE.Object3D,
     deserialize: DeserializeData[], lateResolve: LateResolveCallback[]) {
     if (!obj) return;
@@ -156,11 +166,16 @@ async function onCreateBuiltinComponents(context: SerializationContext, obj: THR
                     const type = TypeStore.get(compData.name);
                     // console.log(compData, compData.name, type, TypeStore);
                     if (type !== undefined && type !== null) {
-                        const instance: Component = new type() as Component;
+                        const instance: IComponent = new type() as IComponent;
                         instance.sourceId = context.gltfId;
 
                         // assign basic fields
                         assign(instance, compData, context.implementationInformation);
+                        
+                        // assign the guid of the original instance
+                        if("guid" in compData)
+                            instance[$originalGuid] = compData.guid;
+                        
                         // 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_networking.ts

@@ -147,7 +147,7 @@ export class OwnershipModel {
         // console.log(res);
         if (res.guid === this.guid) {
             if (this._isWaitingForOwnershipResponseCallback) {
-                this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+                this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
                 this._isWaitingForOwnershipResponseCallback = null;
             }
             this._isOwned = res.value;
@@ -185,18 +185,18 @@ export class OwnershipModel {
         // TODO: abort "requestOwnershipIfNotOwned"
         this.connection.send(OwnershipEvent.RemoveOwnership, { guid: this.guid });
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
         return this;
     }
 
     public destroy() {
-        this.connection.stopListening(OwnershipEvent.GainedOwnership, this._gainSubscription);
-        this.connection.stopListening(OwnershipEvent.LostOwnership, this._lostSubscription);
-        this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
+        this.connection.stopListen(OwnershipEvent.GainedOwnership, this._gainSubscription);
+        this.connection.stopListen(OwnershipEvent.LostOwnership, this._lostSubscription);
+        this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
     }
@@ -368,7 +368,9 @@ export class NetworkConnection implements INetworkConnection {
         return callback;
     }
 
-    public stopListening(key: string | OwnershipEvent, callback: Function | null) {
+    /**@deprecated please use stopListen instead (2.65.2-pre) */
+    public stopListening(key: string | OwnershipEvent, callback: Function | null) { return this.stopListen(key, callback); }
+    public stopListen(key: string | OwnershipEvent, callback: Function | null) {
         if (!callback) return;
         if (!this._listeners[key]) return;
         const index = this._listeners[key].indexOf(callback);
@@ -377,7 +379,7 @@ export class NetworkConnection implements INetworkConnection {
         }
     }
 
-    public beginListenBinrary(identifier: string, callback: BinaryCallback): BinaryCallback {
+    public beginListenBinary(identifier: string, callback: BinaryCallback): BinaryCallback {
         if (!this._listenersBinary[identifier])
             this._listenersBinary[identifier] = [];
         this._listenersBinary[identifier].push(callback);

package/src/engine/engine_networking_auto.ts

@@ -4,6 +4,7 @@ import { RoomEvents } from "./engine_networking";
 
 const debug = getParam("debugautosync");
 
+const $syncerId = Symbol("syncerId");
 class ComponentsSyncerManager {
     private _syncers: { [key: string]: ComponentPropertiesSyncer } = {};
 
@@ -11,9 +12,14 @@ class ComponentsSyncerManager {
         if (!comp.guid) return null;
         if (this._syncers[comp.guid]) return this._syncers[comp.guid];
         const syncer = new ComponentPropertiesSyncer(comp);
-        this._syncers[comp.guid] = syncer;
+        syncer[$syncerId] = comp.guid;
+        this._syncers[syncer[$syncerId]] = syncer;
         return syncer;
     }
+
+    removeSyncer(syncer: ComponentPropertiesSyncer) {
+        delete this._syncers[syncer[$syncerId]];
+    }
 }
 const syncerHandler = new ComponentsSyncerManager();
 
@@ -35,6 +41,7 @@ class ComponentPropertiesSyncer {
     private data = {};
 
     private _boundEvent?: Function;
+    private _handleReceivingMethod?: Function;
 
     get networkingKey(): string {
         const obj = this.comp as object;
@@ -46,6 +53,7 @@ class ComponentPropertiesSyncer {
     private _isReceiving: boolean = false;
     private _isInit = false;
 
+
     init(comp) {
         if (this._isInit) return;
         this._isInit = true;
@@ -53,10 +61,22 @@ class ComponentPropertiesSyncer {
         // console.log("INIT", this.comp.name, this.networkingKey);
         this._boundEvent = this.onHandleSending.bind(this);
         this.comp.context.post_render_callbacks.push(this._boundEvent);
-        this.comp.context.connection.beginListen(this.networkingKey, this.onHandleReceiving.bind(this));
+        this._handleReceivingMethod = this.onHandleReceiving.bind(this);
+        this.comp.context.connection.beginListen(this.networkingKey, this._handleReceivingMethod);
 
         const state = this.comp.context.connection.tryGetState(this.comp.guid);
-        if(state) this.onHandleReceiving(state);
+        if (state) this.onHandleReceiving(state);
+    }
+
+    destroy() {
+        if (!this._isInit) return;
+        if (this._boundEvent)
+            this.comp.context.post_render_callbacks.splice(this.comp.context.post_render_callbacks.indexOf(this._boundEvent), 1);
+        if (this._handleReceivingMethod)
+            this.comp.context.connection.stopListen(this.networkingKey, this._handleReceivingMethod);
+        //@ts-ignore
+        this.comp = null;
+        this._isInit = false;
     }
 
     notifyChanged(propertyName: string, value: any) {
@@ -156,16 +176,26 @@ function testValueChanged(newValue, previousValue): boolean {
     return valueChanged;
 }
 
+const $syncer = Symbol("AutoSyncHandler");
 function getSyncer(instance): ComponentPropertiesSyncer | null {
-    if (instance["__autoPropertySyncHandler"]) {
-        return instance["__autoPropertySyncHandler"];
+    if (instance[$syncer]) {
+        return instance[$syncer];
     }
     const syncer = syncerHandler.getOrCreateSyncer(instance);
     syncer?.init(instance);
-    instance["__autoPropertySyncHandler"] = syncer;
+    instance[$syncer] = syncer;
     return syncer;
 }
 
+function destroySyncer(instance) {
+    const syncer = instance[$syncer];
+    if (syncer) {
+        syncerHandler.removeSyncer(syncer);
+        syncer.destroy();
+        delete instance[$syncer];
+    }
+}
+
 export declare type SyncFieldOptions = {
     onPropertyChanged: Function,
 };
@@ -190,7 +220,7 @@ export const syncField = function (onFieldChanged?: string) {
         const internalAwake = t.__internalAwake;
         if (debug)
             console.log(propertyKey);
-        const backingFieldName = propertyKey + "k__BackingField";
+        const backingFieldName = Symbol(propertyKey);
 
         t.__internalAwake = function () {
             if (this[backingFieldName] !== undefined) {
@@ -221,7 +251,13 @@ export const syncField = function (onFieldChanged?: string) {
             }
 
             syncer?.init(this);
-            
+
+        }
+
+        const internalDestroy = t.__internalDestroy;
+        t.__internalDestroy = function () {
+            destroySyncer(this);
+            internalDestroy.call(this);
         }
 
     }
@@ -233,6 +269,7 @@ export declare type SyncOptions = {
     fieldName?: string,
 };
 
+/** experimental - use syncField instead */
 export const sync = function (_options?: SyncOptions) {
 
     return function <T>(target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
@@ -253,14 +290,14 @@ export const sync = function (_options?: SyncOptions) {
         // inject getter and setter
         if (!descriptor.get) {
             const previousSetter = descriptor.set;
-            const backingFieldName = _propertyKey + "k__BackingField";
+            const $backingField = Symbol(_propertyKey);
             Object.defineProperty(target, _propertyKey, {
                 set: function (value) {
-                    this[backingFieldName] = value;
+                    this[$backingField] = value;
                     previousSetter?.call(this, value);
                 },
                 get: function () {
-                    return this[backingFieldName];
+                    return this[$backingField];
                 }
             });
             const newDescriptor = Object.getOwnPropertyDescriptor(target, _propertyKey);

package/src/engine/engine_patcher.ts

@@ -0,0 +1,113 @@
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
+
+const _wrappedMethods = new WeakSet();
+
+export declare type FieldPatch = (instance: object, oldValue: any, newValue: any) => any;
+export type MethodPatch<T> = (instance: T, result: any, ...args) => any;
+
+/**
+ * Use patcher for patching properties insteadof calling Object.defineProperty individually 
+ * since this will cause conflicts if multiple patches need to be applied to the same property
+ */
+export function addPatch<TType extends object, TCallback extends (FieldPatch | MethodPatch<any>)>(prototype: TType, fieldName: string, cb: TCallback) {
+
+    // TODO: we probably want to turn this into a symbol to prevent anyone from overriding it
+    // But when we need to store the symbol per prototype to allow e.g. material disposing to iterate those and dispose all
+    const backingField = fieldName + "__needle";// Symbol(fieldName);// + " (patched)";
+
+    internalAddPatch(prototype, fieldName, cb);
+
+    const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
+
+    if (desc) {
+        // TODO: check if the property is writable
+        // the property might be a method in which case we want to wrap it
+        if (typeof desc.value === "function") {
+            const method = desc.value;
+            if (method) {
+                if (_wrappedMethods.has(method)) {
+                    return;
+                }
+                _wrappedMethods.add(method);
+                prototype[fieldName] = function (this: object, ...args: any[]) {
+                    // call the original method
+                    const result = method.apply(this, args);
+                    // call the patches
+                    const patches = getPatches(prototype, fieldName);
+                    if (patches) {
+                        for (const patch of patches) {
+                            patch(this, result, ...args);
+                        }
+                    }
+                    return result;
+                }
+            }
+            else {
+                // TODO: declare method?
+            }
+        }
+    }
+    else if (prototype.hasOwnProperty(backingField)) {
+    }
+    else {
+        Object.defineProperty(prototype, fieldName, {
+            set: function (this: object, value: any) {
+                const prev = this[backingField];
+                this[backingField] = value;
+                executePatches(prototype, fieldName, this, prev, value);
+            },
+            get: function (this: any) {
+                return this[backingField];
+            }
+        });
+    }
+}
+
+export function removePatch(prototype: object, fieldName: string, cb: Function) {
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (let i = patches.length - 1; i >= 0; i--) {
+            if (patches[i] === cb) {
+                patches.splice(i, 1);
+            }
+        }
+    }
+}
+
+
+
+
+const patches = new WeakMap<object, Map<string, Function[]>>();
+
+function getPatches(prototype, fieldName: string) {
+    let patchesMap = patches.get(prototype);
+    if (!patchesMap) {
+        return;
+    }
+    return patchesMap.get(fieldName);;
+}
+
+function internalAddPatch(prototype, fieldName: string, cb: Function) {
+    let patchesMap = patches.get(prototype);
+    if (!patchesMap) {
+        patchesMap = new Map();
+        patches.set(prototype, patchesMap);
+    }
+    let patchList = patchesMap.get(fieldName);
+    if (!patchList) {
+        patchList = [];
+        patchesMap.set(fieldName, patchList);
+    }
+    patchList.push(cb);
+}
+
+function executePatches(prototype, fieldName: string, instance: object, oldValue: any, newValue: any) {
+    if (!instance) return;
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (const patch of patches) {
+            patch(instance, oldValue, newValue);
+        }
+    }
+}