@needle-tools/engine 3.0.0-alpha → 3.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.0.0-alpha",
+    "version": "3.0.0-alpha.1",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development, and can be deployed anywhere. It is flexible, extensible, and collaboration and XR come naturally.",
     "main": "dist/needle-engine.umd.cjs",
     "module": "lib/needle-engine.js",

package/src/engine/engine_assetdatabase.ts

@@ -278,27 +278,21 @@ function updateUsers(symbol: symbol, user: object, object: object | object[], ad
 
 // We dont want to update users during rendering
 
-const $renderMethod = Symbol("render-method");
-
-Object.defineProperty(WebGLRenderer.prototype, "render", {
-    set: function (this: WebGLRenderer, value: Function) {
-        this[$renderMethod] = wrapMethod(value);
-    },
-    get: function (this: WebGLRenderer) {
-        return this[$renderMethod];
-    }
-});
 
+try {
 
-function wrapMethod(fn: Function) {
-    return function (this: WebGLRenderer, ...args) {
-        noUpdateScope++;
-        const result = fn.apply(this, args);
-        noUpdateScope--;
-        return result;
-    }
+    // addPatch(WebGLRenderer.prototype, "render",
+    //     () => {
+    //         noUpdateScope++;
+    //     },
+    //     () => {
+    //         noUpdateScope--;
+    //     }
+    // );
+}
+catch (e) {
+    console.warn("Could not wrap WebGLRenderer.render", e);
 }
-
 
 
 // addGltfLoadEventListener(GltfLoadEventType.BeforeLoad, (_) => {
@@ -320,3 +314,20 @@ function wrapMethod(fn: Function) {
 //     }
 // });
 
+
+
+
+
+// class MyObject {
+//     myNumber: number = 1;
+// }
+
+// addPatch(MyObject.prototype, "myNumber", (obj, oldValue, newValue) => {
+//     console.log("myNumber changed", oldValue, newValue);
+// });
+
+// const i = new MyObject();
+// setInterval(() => {
+//     console.log("RUN");
+//     i.myNumber += 1;
+// }, 1000);  

package/src/engine/engine_patcher.ts

@@ -3,67 +3,102 @@
 
 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;
+
+// export function wrap<T>(prototype: object, methodName: string, before: (t: T) => void, after: (t: T) => void) {
+
+//     const $key = Symbol(methodName + "-patched");
+
+//     const alreadyDefined = Object.getOwnPropertyDescriptor(prototype, methodName);
+//     if (alreadyDefined) {
+//         const originalRender = alreadyDefined.get;
+//         if (originalRender) {
+//             // Object.defineProperty(prototype, "render", {
+//             //     set: function (this: any, value: Function) {
+//             //         originalRender.call(this);
+//             //     },
+//             //     get: function (this: ) {
+//             //         return originalRender.call(this);
+//             //     }
+//             // });
+//         }
+//     }
+//     else {
+//         Object.defineProperty(prototype, methodName, {
+//             set: function (this: any, value: Function) {
+//                 this[$key] = value;
+//             },
+//             get: function (this: any) {
+//                 return this[$key];
+//             }
+//         });
+//     }
+// }
+
+
+// export declare type FieldPatch = (instance: object, oldValue: any, newValue: any) => any;
+
+export type Prefix = (...args) => any;
+export type Postfix = (...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) {
+export function addPatch<T extends object>(prototype: T, fieldName: string, beforeCallback?: Prefix, afterCallback?: Postfix) {
+
+    // TODO
+    return;
 
     // 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)";
+    const backingField = Symbol(fieldName + "__needle");// Symbol(fieldName);// + " (patched)";
 
-    internalAddPatch(prototype, fieldName, cb);
+    internalAddPatch(prototype, fieldName, afterCallback, beforeCallback);
 
     const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
+    
+    const existing = prototype[fieldName];
+    console.log(prototype);
 
     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);
+                console.log("setting", fieldName, value);
+                if (typeof value === "function") {
+                    this[backingField] = addWrapper(value, prototype, fieldName);
+                }
+                else {
+                    const prev = this[backingField];
+                    executePrefixes(prototype, fieldName, this, prev, value);
+                    this[backingField] = value;
+                    executePostFixes(prototype, fieldName, this, prev, value);
+                }
             },
             get: function (this: any) {
-                return this[backingField];
+                console.log("GET", fieldName);
+                const value = this[backingField];
+                if (typeof value === "function") {
+                    if (value[backingField]) {
+                        return value[backingField];
+                    }
+                }
+                return value;
             }
         });
     }
 }
 
+function addWrapper(originalFunction: Function, prototype, fieldname) {
+    return function (this: object, ...args: any[]) {
+        executePrefixes(prototype, fieldname, this, ...args);
+        const result = originalFunction.apply(this, args);
+        executePostFixes(prototype, fieldname, this, result, ...args);
+        return result;
+    }
+}
+
 export function removePatch(prototype: object, fieldName: string, cb: Function) {
     const patches = getPatches(prototype, fieldName);
     if (patches) {
@@ -76,38 +111,60 @@ export function removePatch(prototype: object, fieldName: string, cb: Function)
 }
 
 
+export const NeedlePatchesKey = "Needle:Patches";
 
-
-const patches = new WeakMap<object, Map<string, Function[]>>();
+declare type PatchInfo = {
+    prefix?: Prefix;
+    postfix?: Postfix;
+}
+function patches(): WeakMap<object, Map<string, PatchInfo[]>> {
+    if (!globalThis[NeedlePatchesKey]) {
+        globalThis[NeedlePatchesKey] = new WeakMap<object, Map<string, PatchInfo[]>>();
+    }
+    return globalThis[NeedlePatchesKey];
+}
 
 function getPatches(prototype, fieldName: string) {
-    let patchesMap = patches.get(prototype);
+    let patchesMap = patches().get(prototype);
     if (!patchesMap) {
         return null;
     }
     return patchesMap.get(fieldName);;
 }
 
-function internalAddPatch(prototype, fieldName: string, cb: Function) {
-    let patchesMap = patches.get(prototype);
+function internalAddPatch(prototype, fieldName: string, postfix?: Postfix, prefix?: Prefix) {
+    let patchesMap = patches().get(prototype);
     if (!patchesMap) {
         patchesMap = new Map();
-        patches.set(prototype, patchesMap);
+        patches().set(prototype, patchesMap);
     }
     let patchList = patchesMap.get(fieldName);
     if (!patchList) {
         patchList = [];
         patchesMap.set(fieldName, patchList);
     }
-    patchList.push(cb);
+    patchList.push({
+        prefix: prefix,
+        postfix: postfix
+    });
+}
+
+function executePrefixes(prototype, fieldName: string, instance: object, ...args) {
+    if (!instance) return;
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (const patchInfo of patches) {
+            patchInfo.prefix?.call(instance, ...args);
+        }
+    }
 }
 
-function executePatches(prototype, fieldName: string, instance: object, oldValue: any, newValue: any) {
+function executePostFixes(prototype, fieldName: string, instance: object, result: any, ...args) {
     if (!instance) return;
     const patches = getPatches(prototype, fieldName);
     if (patches) {
-        for (const patch of patches) {
-            patch(instance, oldValue, newValue);
+        for (const patchInfo of patches) {
+            patchInfo.postfix?.call(instance, result, ...args);
         }
     }
 }