@needle-tools/engine 3.0.0-alpha → 3.0.1-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.0.0-alpha",
+    "version": "3.0.1-alpha",
     "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",
@@ -57,8 +57,8 @@
         "flatbuffers": "2.0.4",
         "md5": "^2.3.0",
         "peerjs": "1.3.2",
-        "simplex-noise": "^4.0.1",
         "postprocessing": "^6.30.1",
+        "simplex-noise": "^4.0.1",
         "stats.js": "^0.17.0",
         "three": "npm:@needle-tools/three@^0.146.6",
         "three-mesh-ui": "^6.4.5",
@@ -72,10 +72,9 @@
         "@needle-tools/helper": "^0.4.5",
         "@needle-tools/needle-component-compiler": "1.9.3",
         "@types/three": "0.146.0",
-        "copy-files-from-to": "^3.7.0",
         "esbuild": "^0.15.10",
         "esbuild-node-externals": "^1.5.0",
-        "fs-extra": "^11.1.0",
+        "fs-extra": "^11.1.1",
         "jsdoc-babel": "^0.5.0",
         "jsdoc-to-markdown": "^7.1.1",
         "madge": "^5.0.1",

package/plugins/vite/copyfiles.js

@@ -1,7 +1,6 @@
 
-import { copy } from 'fs-extra'
-import { resolve } from 'path'
-import { existsSync } from 'fs';
+import { resolve, join } from 'path'
+import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir } from 'fs';
 
 
 /** copy files on build from assets to dist */
@@ -11,32 +10,60 @@ export const needleCopyFiles = (command, config, userSettings) => {
         return;
     }
 
+    const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
+
     return {
         name: 'needle-copy-files',
         apply: 'build',
         async closeBundle() {
             const baseDir = process.cwd();
+            const pluginName = "needle-copy-files";
 
             const outdirName = "dist";
             const outDir = resolve(baseDir, outdirName);
             if (!existsSync(outDir)) {
-                console.log(`No ${outdirName} folder found, skipping copy files: ${outDir}`);
-                return;
+                mkdirSync(outDir);
+            }
+
+            if (copyIncludesFromEngine !== false) {
+                // copy include from engine
+                const engineIncludeDir = resolve(baseDir, 'node_modules', '@needle-tools', 'engine', 'src', 'include');
+                if (existsSync(engineIncludeDir)) {
+                    console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
+                    const targetDir = resolve(baseDir, 'include');
+                    copyRecursiveSync(engineIncludeDir, targetDir);
+                }
             }
+
             // copy assets dir
             const assetsDir = resolve(baseDir, 'assets');
             if (existsSync(assetsDir)) {
-                console.log(`Copy assets to ${outdirName}/assets`)
+                console.log(`[${pluginName}] - Copy assets to ${outdirName}/assets`)
                 const targetDir = resolve(outDir, 'assets');
-                await copy(assetsDir, targetDir, { overwrite: true });
+                copyRecursiveSync(assetsDir, targetDir);
             }
             // copy include dir
             const includeDir = resolve(baseDir, 'include');
             if (existsSync(includeDir)) {
-                console.log(`Copy include to ${outdirName}/include`)
+                console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
                 const targetDir = resolve(outDir, 'include');
-                await copy(includeDir, targetDir, { overwrite: true });
+                copyRecursiveSync(includeDir, targetDir);
             }
         }
     }
-}
+}
+
+function copyRecursiveSync(src, dest) {
+    var exists = existsSync(src);
+    var stats = exists && statSync(src);
+    var isDirectory = exists && stats.isDirectory();
+    if (isDirectory) {
+        if (!existsSync(dest))
+            mkdirSync(dest);
+        readdirSync(src).forEach(function (childItemName) {
+            copyRecursiveSync(join(src, childItemName), join(dest, childItemName));
+        });
+    } else {
+        copyFileSync(src, dest);
+    }
+};

package/plugins/vite/reload.js

@@ -43,7 +43,8 @@ export const needleReload = (command, config, userSettings) => {
             else if (!config.server.watch.ignored) config.server.watch.ignored = [];
             for (const pattern of ignorePatterns)
                 config.server.watch.ignored.push(pattern);
-            setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
+            if(config?.debug === true || userSettings?.debug === true)
+                setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
         },
         handleHotUpdate(args) {
             args.buildDirectory = buildDirectory;

package/src/engine/engine_addressables.ts

@@ -163,7 +163,7 @@ export class AssetReference {
         }
         else {
             if (debug) console.log("Load async", this.uri);
-            this._loading = getLoader().loadSync(context, this._hashedUri, null, true, prog => {
+            this._loading = getLoader().loadSync(context, this._hashedUri, this.uri, null, prog => {
                 this.raiseProgressEvent(prog);
             });
         }

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

@@ -87,15 +87,12 @@ export function registerComponent(script: IComponent, context?: Context) {
 
 export class Context implements IContext {
 
-	private static _current: Context;
-
 	static get Current(): Context {
-		return this._current;
+		return ContextRegistry.Current as Context;
 	}
 
 	static set Current(context: Context) {
 		ContextRegistry.Current = context;
-		this._current = context;
 	}
 
 	name: string;
@@ -307,7 +304,7 @@ export class Context implements IContext {
 	// private _requestSizeUpdate : boolean = false;
 
 	updateSize() {
-		if (!this.isManagedExternally && !this.renderer.xr.isPresenting) {
+		if (!this.isManagedExternally && this.renderer.xr?.isPresenting === false) {
 			this._sizeChanged = false;
 			const scaleFactor = this.resolutionScaleFactor;
 			const width = this.domWidth * scaleFactor;
@@ -516,10 +513,10 @@ export class Context implements IContext {
 		if (!this.isManagedExternally)
 			this.domElement.prepend(this.renderer.domElement);
 
-		Context._current = this;
+		Context.Current = this;
 
 		// Setup
-		Context._current = this;
+		Context.Current = this;
 		for (let i = 0; i < this.new_scripts.length; i++) {
 			const script = this.new_scripts[i];
 			if (script.gameObject !== undefined && script.gameObject !== null) {
@@ -546,13 +543,13 @@ export class Context implements IContext {
 		// resolve post setup callbacks (things that rely on threejs objects having references to components)
 		if (this.post_setup_callbacks) {
 			for (let i = 0; i < this.post_setup_callbacks.length; i++) {
-				Context._current = this;
+				Context.Current = this;
 				await this.post_setup_callbacks[i](this);
 			}
 		}
 
 		if (!this.mainCamera) {
-			Context._current = this;
+			Context.Current = this;
 			let camera: ICamera | null = null;
 			foreachComponent(this.scene, comp => {
 				const cam = comp as ICamera;
@@ -577,7 +574,7 @@ export class Context implements IContext {
 			}
 		}
 
-		Context._current = this;
+		Context.Current = this;
 		looputils.processNewScripts(this);
 
 		// const mainCam = this.mainCameraComponent as Camera;
@@ -624,10 +621,10 @@ export class Context implements IContext {
 		
 		this._stats?.begin();
 
-		Context._current = this;
+		Context.Current = this;
 		if (this.onHandlePaused()) return;
 
-		Context._current = this;
+		Context.Current = this;
 		this.time.update();
 		if (debugframerate)
 			console.log("FPS", (this.time.smoothedFps).toFixed(0));
@@ -655,7 +652,7 @@ export class Context implements IContext {
 			const script = this.scripts_earlyUpdate[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.earlyUpdate !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.earlyUpdate();
 			}
 		}
@@ -668,7 +665,7 @@ export class Context implements IContext {
 			const script = this.scripts_update[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.update !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.update();
 			}
 		}
@@ -681,7 +678,7 @@ export class Context implements IContext {
 			const script = this.scripts_lateUpdate[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.lateUpdate !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.lateUpdate();
 			}
 		}
@@ -712,7 +709,7 @@ export class Context implements IContext {
 				if (!script.activeAndEnabled) continue;
 				// if(script.isActiveAndEnabled === false) continue;
 				if (script.onBeforeRender !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onBeforeRender(frame);
 				}
 			}
@@ -741,7 +738,7 @@ export class Context implements IContext {
 				const script = this.scripts_onAfterRender[i];
 				if (!script.activeAndEnabled) continue;
 				if (script.onAfterRender !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onAfterRender();
 				}
 			}
@@ -798,7 +795,7 @@ export class Context implements IContext {
 				const script = this.scripts_pausedChanged[i];
 				if (!script.activeAndEnabled) continue;
 				if (script.onPausedChanged !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onPausedChanged(paused, this._wasPaused);
 				}
 			}

package/src/engine/engine_context_registry.ts

@@ -14,7 +14,13 @@ export type ContextEventArgs = {
 export type ContextCallback = (evt: ContextEventArgs) => void;
 
 export class ContextRegistry {
-    static Current: IContext;
+
+    static get Current(): IContext{
+        return globalThis["NeedleEngine.Context.Current"]
+    }
+    static set Current(ctx: IContext) {
+        globalThis["NeedleEngine.Context.Current"] = ctx;
+    }
 
     static Registered: IContext[] = [];
 

package/src/engine/engine_element.ts

@@ -240,7 +240,7 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
                             totalProgress01: this._loadingProgress01
                         }
                     }
-                    const res = await loader.loadSync(ctx, url, hash, false, prog => {
+                    const res = await loader.loadSync(ctx, url, url, hash, prog => {
                         // Calc progress
                         progress.progress = prog;
                         this._loadingProgress01 = calculateProgress01(progress);

package/src/engine/engine_gltf.ts

@@ -8,8 +8,8 @@ import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js'
 export interface INeedleGltfLoader {
     createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider, extension?: NEEDLE_components): Promise<void>
     writeBuiltinComponentData(comp: object, context: SerializationContext);
-    parseSync(context: Context, data, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
-    loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: (prog : ProgressEvent) => void): Promise<GLTF | undefined>
+    parseSync(context: Context, data : string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
+    loadSync(context: Context, url: string, sourceId:string, seed: number | UIDProvider | null, prog?: (prog : ProgressEvent) => void): Promise<GLTF | undefined>
 }
 
 let gltfLoader: INeedleGltfLoader;

package/src/engine/engine_mainloop_utils.ts

@@ -370,17 +370,19 @@ export function runPrewarm(context: IContext) {
     if (cam) {
         if (debugPrewarm) console.log("prewarm", list.length, "objects", [...list]);
         const renderer = context.renderer;
-        const scene = context.scene;
-        renderer.compile(scene, cam!)
-        prewarmTarget ??= new WebGLCubeRenderTarget(64)
-        prewarmCamera ??= new CubeCamera(0.001, 9999999, prewarmTarget);
-        prewarmCamera.update(renderer, scene);
-        for (const obj of list) {
-            obj[$prewarmedFlag] = true;
-            obj[$waitingForPrewarm] = false;
+        if (renderer.compile) {
+            const scene = context.scene;
+            renderer.compile(scene, cam!)
+            prewarmTarget ??= new WebGLCubeRenderTarget(64)
+            prewarmCamera ??= new CubeCamera(0.001, 9999999, prewarmTarget);
+            prewarmCamera.update(renderer, scene);
+            for (const obj of list) {
+                obj[$prewarmedFlag] = true;
+                obj[$waitingForPrewarm] = false;
+            }
+            list.length = 0;
+            if (debugPrewarm) console.log("prewarm done");
         }
-        list.length = 0;
-        if (debugPrewarm) console.log("prewarm done");
     }
 }
 

package/src/engine/engine_networking_files.ts

@@ -48,13 +48,13 @@ export async function addFile(file: File, context: Context, backendUrl?: string)
     if (name.endsWith(".gltf") || name.endsWith(".glb")) {
         return new Promise((resolve, _reject) => {
             const reader = new FileReader()
-            reader.readAsDataURL(file);
+            reader.readAsArrayBuffer(file);
             reader.onloadend = async (_ev: ProgressEvent<FileReader>) => {
-                const content = reader.result as string;
+                const content = reader.result as ArrayBuffer;
                 // first load it locally
                 const seed = generateSeed();
                 const prov = new InstantiateIdProvider(seed);
-                const gltf: GLTF = await getLoader().loadSync(context, content, prov, true) as GLTF;
+                const gltf: GLTF = await getLoader().parseSync(context, content, file.name, prov) as GLTF;
                 if (gltf && gltf.scene) {
                     const obj = gltf.scene as unknown as IGameObject;
                     // if we dont have a guid yet (because components guids are actually created in a callback a bit later)
@@ -85,7 +85,8 @@ export async function addFileFromUrl(url: URL, context: Context): Promise<GLTF |
     return new Promise(async (resolve, _reject) => {
         const seed = generateSeed();
         const prov = new InstantiateIdProvider(seed);
-        const gltf: GLTF = await getLoader().loadSync(context, url.toString(), prov, true) as GLTF;
+        const urlStr = url.toString();
+        const gltf: GLTF = await getLoader().loadSync(context, urlStr, urlStr, prov) as GLTF;
         if (gltf && gltf.scene) {
             const obj = gltf.scene as unknown as IGameObject;
             // handleUpload(context.connection, file, seed, obj); // TODO needs to upload the URL only and store that

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