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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.67.10-pre",
+    "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",
@@ -25,8 +25,6 @@
         "build:dist": "vite build",
         "build:src": "tsc --outDir ./lib --noEmit false --declaration",
         "build:license": "node plugins/publish/create-license.mjs",
-        "pack-gltf": "node --no-experimental-fetch node_modules/@needle-tools/gltf-transform-extensions/pack-gltf.mjs",
-        "transform:make-progressive": "node node_modules/@needle-tools/gltf-transform-extensions/make-progressive.mjs",
         "test:circular-imports": "node plugins/check-circular-imports.js",
         "test:tsc": "tsc"
     },
@@ -62,7 +60,7 @@
         "simplex-noise": "^4.0.1",
         "postprocessing": "^6.30.1",
         "stats.js": "^0.17.0",
-        "three": "npm:@needle-tools/three@^0.146.7",
+        "three": "npm:@needle-tools/three@^0.146.6",
         "three-mesh-ui": "^6.4.5",
         "three.quarks": "^0.7.3",
         "uuid": "^9.0.0",
@@ -71,7 +69,6 @@
     "devDependencies": {
         "@babel/runtime": "^7.16.0",
         "@luncheon/esbuild-plugin-gzip": "^0.1.0",
-        "@needle-tools/gltf-transform-extensions": "^0.11.2-pre",
         "@needle-tools/helper": "^0.4.5",
         "@needle-tools/needle-component-compiler": "1.9.3",
         "@types/three": "0.146.0",
@@ -82,7 +79,6 @@
         "jsdoc-babel": "^0.5.0",
         "jsdoc-to-markdown": "^7.1.1",
         "madge": "^5.0.1",
-        "msdf-bmfont-xml": "^2.7.0",
         "npm-watch": "^0.11.0",
         "typescript": "^4.5.5",
         "vite": "^4.0.4"

package/plugins/vite/alias.js

@@ -0,0 +1,45 @@
+import { existsSync } from 'fs';
+import path from 'path';
+
+const projectDir = process.cwd() + "/";
+
+const packages_to_resolve = {
+    'three': {},
+    '@needle-tools/engine': {},
+    'peerjs': {},
+    'websocket-ts': {},
+    'md5': {},
+}
+
+export const needleViteAlias = (command, config, userSettings) => {
+
+    if (config?.noAlias === true || userSettings?.noAlias === true)
+        return;
+
+    return {
+        name: "needle-alias",
+        config(config) {
+            setTimeout(() => {
+                console.log('[needle-alias] ProjectDirectory: ' + projectDir);
+            }, 150);
+
+            if (!config.resolve) config.resolve = {};
+            if (!config.resolve.alias) config.resolve.alias = {};
+            const aliasDict = config.resolve.alias;
+            for (const name in packages_to_resolve) {
+                if (!aliasDict[name]) {
+                    addPathResolver(name, aliasDict);
+                }
+            }
+        }
+    }
+
+    function addPathResolver(name, aliasList) {
+        // If a package at the node_modules path exist we resolve the request there
+        // introduced in 89a50718c38940abb99ee16c5e029065e41d7d65
+        const res = path.resolve(projectDir, 'node_modules', name);
+        if (existsSync(res)) {
+            aliasList[name] = () => res;
+        }
+    }
+};

package/plugins/vite/index.js

@@ -5,6 +5,7 @@ import { needleReload } from "./reload.js"
 import { needleDrop } from "./drop.js";
 import { editorConnection } from "./editor-connection.js";
 import { needleCopyFiles } from "./copyfiles.js";
+import { needleViteAlias } from "./alias.js";
 
 export * from "./gzip.js";
 export * from "./config.js";
@@ -18,6 +19,7 @@ export const needlePlugins = async (command, config, userSettings) => {
     // ensure we have user settings initialized with defaults
     userSettings = { ...defaultUserSettings, ...userSettings }
     const array = [
+        needleViteAlias(command, config, userSettings),
         needleMeta(command, config, userSettings),
         needlePoster(command),
         needleReload(command, config, userSettings),

package/src/engine/api.ts

@@ -1,10 +1,11 @@
-
+export * from "./engine_constants";
 export { TypeStore } from "./engine_typestore";
 export * from "./engine_context_registry";
 export * from "./extensions/extensions"
 export { InstancingUtil } from "./engine_instancing";
 export * from "./engine_gameobject";
-export * from "./engine_components"
+export * from "./engine_components";
+export * from "./engine_components_internal";
 export { AssetReference } from "./engine_addressables";
 export { Context, FrameEvent } from "./engine_setup";
 export * from "./debug/debug";

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_components.ts

@@ -6,7 +6,7 @@ import { removeScriptFromContext, updateActiveInHierarchyWithoutEventCall } from
 import { activeInHierarchyFieldName } from "./engine_constants";
 import { apply } from "../engine-components/js-extensions/Object3D";
 import { InstantiateIdProvider } from "./engine_networking_instantiate";
-import { ComponentEvents, __internalDispatchComponentLifecycleEvent } from "./engine_components_internal";
+import { ComponentEvents, ComponentLifecycleEvents } from "./engine_components_internal";
 
 const debug = getParam("debuggetcomponent");
 
@@ -30,7 +30,7 @@ export function removeComponent(go: Object3D, componentInstance: IComponent) {
     const index = go.userData.components.indexOf(componentInstance);
     if (index < 0) return;
 
-    __internalDispatchComponentLifecycleEvent(ComponentEvents.Removing, componentInstance);
+    ComponentLifecycleEvents.dispatchComponentLifecycleEvent(ComponentEvents.Removing, componentInstance);
 
     //@ts-ignore
     componentInstance.gameObject = null;
@@ -66,7 +66,7 @@ export function addNewComponent<T extends IComponent>(obj: Object3D, componentIn
             updateActiveInHierarchyWithoutEventCall(obj);
             componentInstance.__internalAwake();
         }
-        __internalDispatchComponentLifecycleEvent(ComponentEvents.Added, componentInstance);
+        ComponentLifecycleEvents.dispatchComponentLifecycleEvent(ComponentEvents.Added, componentInstance);
     }
     catch (err) {
         console.error(err);

package/src/engine/engine_components_internal.ts

@@ -1,30 +1,43 @@
 import { IComponent } from "./engine_types";
-
-
-const eventListeners = new Map<string, ((data: IComponent) => void)[]>();
+import { getParam } from "./engine_utils";
 
 export enum ComponentEvents {
     Added = "component-added",
     Removing = "removing-component"
 }
 
-export function __internalAddComponentLifecycleEventListener(evt: string, cb: (data: IComponent) => void) {
-    if (!eventListeners.has(evt)) eventListeners.set(evt, []);
-    eventListeners.get(evt)?.push(cb);
-}
+const debug = getParam("debugcomponentevents");
 
-export function __internalRemoveComponentLifecycleEventListener(evt: string, cb: (data: IComponent) => void) {
-    const listeners = eventListeners.get(evt);
-    if (!listeners) return;
-    const index = listeners.indexOf(cb);
-    if (index < 0) return;
-    listeners.splice(index, 1);
-}
+export class ComponentLifecycleEvents {
+
+    private static eventListeners = new Map<string, ((data: IComponent) => void)[]>();
 
-export function __internalDispatchComponentLifecycleEvent(evt: string, data: IComponent) {
-    const listeners = eventListeners.get(evt);
-    if (!listeners) return;
-    for (const listener of listeners) {
-        listener(data);
+    static addComponentLifecylceEventListener(evt: string, cb: (data: IComponent) => void) {
+        if (this.eventListeners.has(evt)) {
+            this.eventListeners.set(evt, []);
+        }
+        let arr = this.eventListeners.get(evt);
+        if (!arr) arr = [];
+        arr.push(cb);
+        this.eventListeners.set(evt, arr);
+        if(debug) console.log("Added event listener for " + evt, this.eventListeners)
     }
-}
+
+    static removeComponentLifecylceEventListener(evt: string, cb: (data: IComponent) => void) {
+        const listeners = this.eventListeners.get(evt);
+        if (!listeners) return;
+        const index = listeners.indexOf(cb);
+        if (index < 0) return;
+        listeners.splice(index, 1);
+        
+    }
+
+    static dispatchComponentLifecycleEvent(evt: string, data: IComponent) {
+        const listeners = this.eventListeners.get(evt);
+        if(debug) console.log("Dispatching event " + evt, listeners)
+        if (!listeners) return;
+        for (const listener of listeners) {
+            listener(data);
+        }
+    }
+}

package/src/engine/engine_constants.ts

@@ -1,6 +1,5 @@
 
 export const activeInHierarchyFieldName = Symbol("isActiveInHierarchy");
 export const builtinComponentKeyName = "builtin_components";
-
-
-export const $originalGuid = Symbol("originalGuid");
+// It's easier to use a string than a symbol here because the symbol might not be the same when imported in other packages
+export const editorGuidKeyName = "needle_editor_guid";

package/src/engine/engine_gameobject.ts

@@ -10,8 +10,8 @@ import { $isUsingInstancing, InstancingUtil } from "./engine_instancing";
 import { activeInHierarchyFieldName } from "./engine_constants";
 import { assign } from "./engine_serialization_core";
 import { disposeObjectResources, __internalNotifyObjectDestroyed as __internalRemoveReferences } from "./engine_assetdatabase";
-import { $originalGuid } from "./engine_constants";
-import { __internalDispatchComponentLifecycleEvent, ComponentEvents } from "./engine_components_internal";
+import { editorGuidKeyName } from "./engine_constants";
+import { ComponentLifecycleEvents, ComponentEvents } from "./engine_components_internal";
 
 const debug = getParam("debuggetcomponent");
 const debugInstantiate = getParam("debuginstantiate");
@@ -373,13 +373,13 @@ function internalInstantiate(
             const copy = new comp.constructor();
             assign(copy, comp);
             // make sure the original guid stays intact
-            if (comp[$originalGuid] !== undefined)
-                copy[$originalGuid] = comp[$originalGuid];
+            if (comp[editorGuidKeyName] !== undefined)
+                copy[editorGuidKeyName] = comp[editorGuidKeyName];
             newComponents.push(copy);
             copy.gameObject = clone;
             // copy.transform = clone;
             componentsList.push(copy);
-            __internalDispatchComponentLifecycleEvent(ComponentEvents.Added, copy);
+            ComponentLifecycleEvents.dispatchComponentLifecycleEvent(ComponentEvents.Added, copy);
         }
     }
 

package/src/engine/engine_gltf_builtin_components.ts

@@ -8,7 +8,7 @@ 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 { $originalGuid, builtinComponentKeyName } from "./engine_constants";
+import { editorGuidKeyName, builtinComponentKeyName } from "./engine_constants";
 import { GuidsMap, IComponent, IGameObject, SourceIdentifier } from "./engine_types";
 import { UIDProvider } from "./engine_types";
 import { addNewComponent } from "./engine_components";
@@ -174,7 +174,7 @@ async function onCreateBuiltinComponents(context: SerializationContext, obj: THR
                         
                         // assign the guid of the original instance
                         if("guid" in compData)
-                            instance[$originalGuid] = compData.guid;
+                            instance[editorGuidKeyName] = 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

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);
         }
     }
 }

package/plugins/generate-font.js

@@ -1,65 +0,0 @@
-import generateBMFont from 'msdf-bmfont-xml';
-import fs from 'fs';
-import path from 'path';
-
-const args = process.argv;
-
-const fontPath = args[2];
-const outputDir = args[3];
-const charsetPath = args.length > 4 ? args[4] : null;
-
-if (!fontPath || !fs.existsSync(fontPath)) {
-    console.error("Missing font path. Please call this script with a path to a font file. Called with: \"" + fontPath + "\"");
-    process.exit(1);
-}
-if (!outputDir || !fs.existsSync(outputDir)) {
-    console.error("Missing output directory, please provide an output directory as the second argument. Called with: \"" + outputDir + "\"");
-    process.exit(1);
-}
-
-// https://soimy.github.io/msdf-bmfont-xml/#module-usage-examples
-
-
-let message = "Generate font texture " + fontPath + " to " + outputDir;
-
-let charset = null;
-if (charsetPath && fs.existsSync(charsetPath)) {
-    message += " using chars from \"" + charsetPath + "\"";
-    charset = fs.readFileSync(charsetPath, 'utf8');
-    console.log("charset: ", charset);
-    if (charset.length <= 0) {
-        console.warn("WARN: Charset file is empty, using default charset");
-        charset = null;
-    }
-}
-
-console.log(message);
-const opts = {
-    outputType: "json",
-    fieldType: "msdf",
-    textureSize: [4096, 4096],
-    smartSize: true, // shrink atlas to the smallest possible square
-    // rtl: true, // use RTL(Arabic/Persian) charators fix
-};
-if (charset?.length)
-    opts.charset = charset;
-
-generateBMFont(fontPath, opts,
-    (error, textures, font) => {
-        if (error) throw error;
-        textures.forEach((texture, index) => {
-            const fileName = path.parse(texture.filename).name.toLocaleLowerCase() + ".png";
-            const outputPath = outputDir + "/" + fileName;
-            console.log("Write to", outputPath);
-            if (index > 0) console.log("WARN: Multiple font textures generated but they will override each other. You have currently " + charset?.length + " characters configured. Maybe too many?");
-            fs.writeFile(outputPath, texture.texture, (err) => {
-                if (err) throw err;
-            });
-        });
-
-        const fileName = path.parse(font.filename).name;
-        const name = outputDir + "/" + fileName.toLocaleLowerCase() + "-msdf.json";
-        fs.writeFile(name, font.data, (err) => {
-            if (err) throw err;
-        });
-    });