Needle Engine 3.10.0-alpha

Files changed (4) hide show

src/engine/engine_mainloop_utils.ts +8 -3
src/engine/engine_networking_auto.ts +48 -22
src/engine/engine_types.ts +6 -3
src/engine-components/webxr/WebXR.ts +6 -0

src/engine/engine_mainloop_utils.ts CHANGED Viewed

@@ -5,6 +5,7 @@
 import { IComponent, IContext } from './engine_types';
 import { isActiveSelf } from './engine_gameobject';
 import { ContextRegistry } from "./engine_context_registry";
+import { showBalloonWarning, isDevEnvironment, showBalloonMessage, LogType } from "./debug";
 const debug = getParam("debugnewscripts");
 const debugHierarchy = getParam("debughierarchy");
@@ -171,8 +172,7 @@
             // keep them in queue until script has started
             // call awake if the script was inactive before
             utils.safeInvoke(script.__internalAwake.bind(script));
-            if(script.enabled)
-            {
+            if (script.enabled) {
                 utils.safeInvoke(script.__internalEnable.bind(script));
                 // now call start
                 utils.safeInvoke(script.__internalStart.bind(script));
@@ -232,8 +232,13 @@
     const activeSelf = isActiveSelf(obj);
     const wasSuccessful = updateIsActiveInHierarchyRecursiveRuntime(obj, activeSelf, true);
     if (!wasSuccessful) {
-        console.error("Failed to update active state in hierarchy of \"" + obj.name + "\"", obj);
+        if (debug || isDevEnvironment()) {
+            console.error("Error updating hierarchy\nDo you have circular references in your project? <a target=\"_blank\" href=\"https://docs.needle.tools/circular-reference\"> Click here for more information.", obj)
+        }
+        else
+            console.error("Failed to update active state in hierarchy of \"" + obj.name + "\"", obj);
         console.warn(" ↑ this error might be caused by circular references. Please make sure you don't have files with circular references (e.g. one GLB 1 is loading GLB 2 which is then loading GLB 1 again).")
     }
 }

src/engine/engine_networking_auto.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { getParam } from "./engine_utils";
-import { Component } from "../engine-components/Component";
-import { RoomEvents } from "./engine_networking";
+import { isDevEnvironment } from "./debug";
+import { IComponent } from "./engine_types";
 const debug = getParam("debugautosync");
@@ -8,7 +8,7 @@
 class ComponentsSyncerManager {
     private _syncers: { [key: string]: ComponentPropertiesSyncer } = {};
-    getOrCreateSyncer(comp: Component): ComponentPropertiesSyncer | null {
+    getOrCreateSyncer(comp: IComponent): ComponentPropertiesSyncer | null {
         if (!comp.guid) return null;
         if (this._syncers[comp.guid]) return this._syncers[comp.guid];
         const syncer = new ComponentPropertiesSyncer(comp);
@@ -28,9 +28,9 @@
  */
 class ComponentPropertiesSyncer {
-    comp: Component;
+    comp: IComponent;
-    constructor(comp: Component) {
+    constructor(comp: IComponent) {
         // console.log("CREATE NEW SYNC", comp.name, comp.guid);
         this.comp = comp;
     }
@@ -115,8 +115,7 @@
         if (!this.comp) return;
         const guid = val.guid;
         if (guid && guid !== this.comp.guid) return;
-        if (debug)
-            console.log("RECEIVED", this.comp.name, this.comp.guid, val);
+        if (debug) console.log("RECEIVED", this.comp.name, this.comp.guid, val);
         try {
             this._isReceiving = true;
             for (const key in val) {
@@ -124,6 +123,7 @@
                 // TODO: maybe use serializable here?!
                 const value = val[key];
                 this.comp[key] = value;
+                if(debug) console.log("SET", key, value);
             }
         }
         catch (err) {
@@ -164,13 +164,16 @@
             // }
         }
         else if (typeof newValue === "object" && typeof previousValue === "object") {
-            // do we want to traverse / recursively check if anything changed???
-            for (const key of Object.keys(newValue)) {
-                if (newValue[key] !== previousValue[key]) {
-                    valueChanged = true;
-                    break;
-                }
-            }
+            valueChanged = true;
+            // The following code doesnt work because the object is a reference type
+            // To properly detect changes we would have to detect assignments for each property #
+            // OR keep a copy of the previous object
+            // for (const key of Object.keys(newValue)) {
+            //     if (newValue[key] !== previousValue[key]) {
+            //         valueChanged = true;
+            //         break;
+            //     }
+            // }
         }
     }
     return valueChanged;
@@ -203,14 +206,17 @@
 export declare type FieldChangedCallbackFn = (newValue: any, previousValue: any) => void | boolean;
 /**
- * Decorate a field to be automatically networked synced
+ * **Decorate a field to be automatically networked synced**
+ * *Primitive* values are all automatically synced (like string, boolean, number).
+ * For *arrays or objects* make sure to re-assign them (e.g. `this.mySyncField = this.mySyncField`) to trigger an update
+ *
  * @param onFieldChanged name of a callback function that will be called when the field is changed.
  * You can also pass in a function like so: syncField(myClass.prototype.myFunctionToBeCalled)
  * This function may return false to prevent notifyChanged from being called
  * (for example a networked color is sent as a number and may be converted to a color in the receiver again)
  * Parameters: (newValue, previousValue)
  */
-export const syncField = function(onFieldChanged?: string | FieldChangedCallbackFn) {
+export const syncField = function (onFieldChanged?: string | FieldChangedCallbackFn) {
     return function (target: any, propertyKey: string) {
@@ -225,6 +231,11 @@
         const t = target;
         const internalAwake = t.__internalAwake;
+        if (typeof internalAwake !== "function") {
+            if (debug || isDevEnvironment())
+                console.error("@syncField can currently only used on Needle Engine Components, custom object of type \"" + target?.constructor?.name + "\" is not supported", target);
+            return;
+        }
         if (debug)
             console.log(propertyKey);
         const backingFieldName = Symbol(propertyKey);
@@ -234,20 +245,35 @@
                 return;
             }
             this[backingFieldName] = this[propertyKey];
-            internalAwake.call(this);
             syncer = syncerHandler.getOrCreateSyncer(this);
             const desc = Object.getOwnPropertyDescriptor(this, propertyKey);
             if (desc?.set === undefined) {
+                let invokingCallback = false;
                 Object.defineProperty(this, propertyKey, {
                     set: function (value) {
                         const oldValue = this[backingFieldName];
                         this[backingFieldName] = value;
-                        if (testValueChanged(value, oldValue)) {
-                            if (fn?.call(this, value, oldValue) !== false)
-                                getSyncer(this)?.notifyChanged(propertyKey, value);
+                        // Prevent recursive calls when object is assigned in callback
+                        if (invokingCallback) {
+                            if (isDevEnvironment())
+                                console.warn("Recursive call detected", propertyKey);
+                            return;
                         }
+                        invokingCallback = true;
+                        try {
+                            const valueChanged = testValueChanged(value, oldValue);
+                            if (debug) console.log("SyncField assignment", propertyKey, "changed?", valueChanged, value);
+                            if (valueChanged) {
+                                if (fn?.call(this, value, oldValue) !== false) {
+                                    getSyncer(this)?.notifyChanged(propertyKey, value);
+                                }
+                            }
+                        }
+                        finally {
+                            invokingCallback = false;
+                        }
                     },
                     get: function () {
                         return this[backingFieldName];
@@ -258,7 +284,7 @@
             }
             syncer?.init(this);
+            internalAwake.call(this);
         }
         const internalDestroy = t.__internalDestroy;
@@ -281,7 +307,7 @@
     return function <T>(target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
         // override awake
-        const comp = target as Component;
+        const comp = target as IComponent;
         let syncer: ComponentPropertiesSyncer | null;
         const internalAwake = comp.__internalAwake.bind(comp);
         comp.__internalAwake = function () {

src/engine/engine_types.ts CHANGED Viewed

@@ -123,12 +123,15 @@
     getComponentsInParent<T>(type: Constructor<T>, arr?: T[]): Array<T>;
 }
-export interface IComponent {
+export interface IHasGuid {
+    guid: string;
+}
+export interface IComponent extends IHasGuid {
     get isComponent(): boolean;
     gameObject: IGameObject;
-    guid: string;
+    // guid: string;
     enabled: boolean;
     sourceId?: SourceIdentifier;

src/engine-components/webxr/WebXR.ts CHANGED Viewed

@@ -604,6 +604,12 @@
         if (!this.sessionRoot || this.sessionRoot.destroyed || !this.sessionRoot.activeAndEnabled)
             this.sessionRoot = GameObject.findObjectOfType(WebARSessionRoot, context);
+        if (!this.sessionRoot) {
+            // TODO: adding it on the scene directly doesnt work (probably because then everything in the scene is disabled including this component). See code a bit furhter below where we add this component to a temporary object inside the scene
+            const obj = this.webxr.gameObject;
+            this.sessionRoot = GameObject.addNewComponent(obj, WebARSessionRoot);
+            console.warn("WebAR: No ARSessionRoot found, creating one automatically on the WebXR object");
+        }
         this.previousBackground = context.scene.background;
         this.previousEnvironment = context.scene.environment;