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

package/src/engine/engine_assetdatabase.ts

@@ -1,44 +1,10 @@
-import * as THREE from 'three';
-import { Scene } from 'three';
-// import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
-import * as utils from "./engine_utils";
-
-const debug = utils.getParam("debugassets");
-
-class TextureInfo {
-    name!: string;
-    sampler!: number;
-    source!: number;
-    extras: { guid: string } | undefined;
-}
-
-class ImageInfo {
-    bufferView!: number;
-    mimeType: string | undefined;
-    extras: { guid: string } | undefined;
-}
+import { InternalUsageTrackerPlugin } from "./extensions/usage_tracker";
+import { Bone, BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute, Material, Mesh, Object3D, Skeleton, SkinnedMesh, Texture, WebGLRenderer } from "three";
+import { addPatch } from "./engine_patcher";
+import { getParam } from "./engine_utils";
 
-class GltfJson {
-    textures!: TextureInfo[];
-    bufferViews!: Array<{ buffer: number, byteOffset: number, byteLength: number }>;
-}
 
-declare class GltfParser {
-    cache: any;
-    json: GltfJson;
-    associations: Map<any, any>;
-    textureLoader: THREE.TextureLoader;
-    loadTexture: Function;
-}
-
-declare class Gltf {
-    parser: GltfParser;
-    scene: Scene;
-}
-
-/** @deprecated */
 export class AssetDatabase {
-
     constructor() {
         window.addEventListener('unhandledrejection', (event: PromiseRejectionEvent) => {
             if (event.defaultPrevented) return;
@@ -52,164 +18,305 @@ export class AssetDatabase {
             }
         });
     }
+}
+
+const trackUsageParam = getParam("trackusage");
+
+function autoDispose() {
+    return trackUsageParam === "dispose";
+}
 
-    private texturesLoader: THREE.TextureLoader = new THREE.TextureLoader();
-    private textures: { [key: string]: THREE.Texture | PromiseLike<THREE.Texture> } = {};
-    private texturesLoading: { [key: string]: THREE.Texture | PromiseLike<THREE.Texture> } = {};
+// For testing only track when explictly enabled
+let allowUsageTracking = trackUsageParam !== undefined && trackUsageParam !== false && trackUsageParam !== 0;
 
-    /** @deprecated */
-    public async loadTexture(url: string): Promise<THREE.Texture | null> {
-        if (this.textures[url]) {
-            return this.textures[url];
+export function setUsageTrackingEnabled(enabled: boolean) {
+    allowUsageTracking = enabled;
+}
+export function isUsageTrackingEnabled() {
+    return allowUsageTracking;
+}
+
+
+/** Recursive disposes all referenced resources by this object. Does not traverse children */
+export function disposeObjectResources(obj: object) {
+    if (!obj) return;
+
+    if (obj instanceof SkinnedMesh) {
+        disposeObjectResources(obj.geometry);
+        disposeObjectResources(obj.material);
+        disposeObjectResources(obj.skeleton);
+    }
+    else if (obj instanceof Mesh) {
+        disposeObjectResources(obj.geometry);
+        disposeObjectResources(obj.material);
+    }
+    else if (obj instanceof BufferGeometry) {
+        free(obj);
+        for (const key of Object.keys(obj.attributes)) {
+            const value = obj.attributes[key];
+            disposeObjectResources(value);
+        }
+    }
+    else if (obj instanceof BufferAttribute || obj instanceof InterleavedBufferAttribute) {
+        // Currently not supported by three 
+        // https://github.com/mrdoob/three.js/issues/15261
+        // https://github.com/mrdoob/three.js/pull/17063#issuecomment-737993363
+    }
+    else if (obj instanceof Array<Material>) {
+        for (const entry of obj) {
+            if (entry)
+                disposeObjectResources(entry);
+        }
+    }
+    else if (obj instanceof Material) {
+        for (const key of Object.keys(obj)) {
+            const value = obj[key];
+            if (value instanceof Texture)
+                disposeObjectResources(value);
         }
-        if (this.texturesLoading[url]) {
-            return await this.texturesLoading[url];
+        free(obj);
+    }
+    else if (obj instanceof Texture) {
+        free(obj);
+        if (obj.source?.data instanceof ImageBitmap) {
+            free(obj.source.data);
         }
-        const loading = this.texturesLoader.loadAsync(url);
-        this.texturesLoading[url] = loading;
-        const res = await loading;
-        delete this.texturesLoading[url];
-        this.textures[url] = res;
-        return res;
     }
+    else if (obj instanceof Skeleton) {
+        free(obj.boneTexture);
+    }
+    else if (obj instanceof Bone) {
 
-    /** @deprecated */
-    public getTexture(guid: string): THREE.Texture | null {
-        return this._textures.get(guid) || null;
     }
+    else {
+        if (!(obj instanceof Object3D) && debug)
+            console.warn("Unknown object type", obj);
+    }
+}
 
-    /** @deprecated */
-    public findTexture(name: string): THREE.Texture | null {
-        for (const texture of this._textures.values()) {
-            if (texture.name === name) {
-                return texture;
-            }
+function free(obj: any) {
+    if (debug || autoDispose() || trackUsageParam) console.warn("🧨 FREE", obj);
+    if (!obj) {
+        return;
+    }
+    if (obj instanceof ImageBitmap) {
+        obj.close();
+    }
+    else {
+        obj.dispose();
+    }
+}
+
+export function __internalNotifyObjectDestroyed(obj: Object3D) {
+    if (obj instanceof Mesh || obj instanceof SkinnedMesh) {
+        obj.material = null;
+        obj.geometry = null;
+    }
+}
+
+const usersBuffer = new Set<object>();
+
+export type UserFilter = (user: object) => boolean;
+
+/**
+ * Find all users of an object
+ * @param object Object to find users of
+ * @param recursive Find users of users
+ * @param predicate Filter users
+ * @param set Set to add users to, a new one will be created if none is provided
+ * @returns a set of users
+ */
+export function findUsers(object: object, recursive: boolean, predicate: UserFilter | null | undefined = null, set?: Set<object>): Set<object> {
+    if (!set) {
+        set = usersBuffer;
+        set.clear();
+    }
+    if (!object) return set;
+    const users = object[$objectUsersKey] as Set<object>;
+    if (users) {
+        for (const user of users) {
+            // Prevent infinite loop if recursive references
+            if (set.has(user)) continue;
+            //  Allow filtering
+            if (predicate?.call(null, user) === false) continue;
+            set.add(user);
+            if (recursive)
+                findUsers(user, true, predicate, set);
+        }
+    }
+    return set;
+}
+
+export function getUserCount(object: object): number | undefined {
+    return object[$objectUsersCountKey];
+}
+
+
+
+const debug = getParam("debugusers");
+
+// Should we check if the type has the
+const $objectUsersKey = Symbol("needle-users");
+const $objectUsersCountKey = Symbol("needle-users-count");
+
+function trackValueChange(prototype, fieldName) {
+    addPatch(prototype, fieldName, (obj, oldValue, newValue) => {
+        if (allowUsageTracking) {
+            updateUsers($objectUsersKey, obj, oldValue, false);
+            updateUsers($objectUsersKey, obj, newValue, true);
+        }
+    });
+}
+
+// function stopTracking(prototype, fieldName) {
+//     const $key = Symbol("needle-using-" + fieldName);
+//     const currentValue = prototype[$key];
+//     delete prototype[$key];
+//     prototype[fieldName] = currentValue;
+//     updateUsers($objectUsersKey, fieldName, prototype, currentValue, true);
+// }
+
+
+trackValueChange(Mesh.prototype, "material");
+trackValueChange(Mesh.prototype, "geometry");
+trackValueChange(Material.prototype, "map");
+trackValueChange(Material.prototype, "bumpMap");
+trackValueChange(Material.prototype, "alphaMap");
+trackValueChange(Material.prototype, "normalMap");
+trackValueChange(Material.prototype, "displacementMap");
+trackValueChange(Material.prototype, "roughnessMap");
+trackValueChange(Material.prototype, "metalnessMap");
+trackValueChange(Material.prototype, "emissiveMap");
+trackValueChange(Material.prototype, "specularMap");
+trackValueChange(Material.prototype, "envMap");
+trackValueChange(Material.prototype, "lightMap");
+trackValueChange(Material.prototype, "aoMap");
+trackValueChange(Material.prototype, "gradientMap");
+// trackValueChange(Object3D.prototype, "parent");
+
+
+// setTimeout(()=>{
+//     stopTracking(Mesh.prototype, "material");
+// },100);
+
+
+// TODO: patch dispose?
+
+
+function onDispose(obj: object) {
+    if (allowUsageTracking === false) return;
+    const users = obj[$objectUsersKey] as Set<object>;
+    if (users) {
+        for (const user of users) {
+            updateUsers($objectUsersKey, user, obj, false);
         }
-        return null;
     }
+}
 
-    /** @deprecated */
-    public findMesh(name: string): THREE.Mesh | null {
-        for (const mesh of this._meshes.values()) {
-            if (mesh.name === name)
-                return mesh;
+function trackDispose(prototype, methodName: string) {
+    addPatch(prototype, methodName, (instance) => {
+        onDispose(instance);
+    });
+}
+
+trackDispose(Material.prototype, "dispose");
+
+
+
+
+
+let noUpdateScope = 0;
+
+// Main method called by wrapped fields/properties to update the users for an object
+function updateUsers(symbol: symbol, user: object, object: object | object[], added: boolean) {
+
+    // If we are rendering we dont want to update users
+    if (noUpdateScope > 0) return;
+
+    if (Array.isArray(object)) {
+        for (const m of object) {
+            updateUsers(symbol, user, m, added);
         }
-        return null;
+        return;
     }
+    if (!object) return;
 
-    /** @deprecated */
-    public findMaterial(name:string) : THREE.Material | null {
-        for (const material of this._materials.values()) {
-            if (material.name === name)
-                return material;
+    let users = object[symbol];
+    if (!users) users = new Set();
+    if (added) {
+        if (user && !users.has(user)) {
+            users.add(user);
+            let count = object[$objectUsersCountKey] || 0;
+            count += 1;
+            object[$objectUsersCountKey] = count;
+            if (debug) console.warn(`🟢 Added user of "${object["type"]}"`, user, object, count, "users:", users);
+        }
+    } else {
+        if (user && users.has(user)) {
+            users.delete(user);
+            let count = object[$objectUsersCountKey] || 0;
+            if (count > 0) {
+                count -= 1;
+                object[$objectUsersCountKey] = count;
+            }
+            if (debug) console.warn(`🔴 Removed user of "${object["type"]}"`, user, object, count, "users:", users);
+            if (count <= 0) {
+                if (!InternalUsageTrackerPlugin.isLoading(object)) {
+                    if (trackUsageParam)
+                        console.warn(`🔴 Removed all user of "${object["type"]}"`, object);
+                    if (autoDispose())
+                        disposeObjectResources(object);
+                }
+            }
         }
-        return null;
-    }
-
-    /** @deprecated */
-    public async registerGltf(_gltf: Gltf) {
-        // if (debug)
-        //     console.log("register gltf", gltf.scene.name, gltf);
-        // const parser = gltf.parser;
-        // const json = parser.json;
-        // const textures = json.textures;
-        // const associations = parser.associations;
-        // const alreadyLoaded = new Set<string>();
-        // associations.forEach((value, key) => {
-        //     // when minified instanceOf doesnt work but the texture type is 1009
-        //     if (key instanceof THREE.Texture || key.type === 1009) {
-        //         const index = value.textures;
-        //         const textureInfo = textures[index];
-        //         // TODO: a lot of information is gone when compressing with ktx2
-        //         // this.registerTexture(parser, index, textureInfo, key, alreadyLoaded);
-        //     }
-        //     else if (key instanceof THREE.Mesh || key.type == "Mesh") {
-        //         this.registerAsset(key);
-
-        //         // saving materials,
-        //         // FIXME: this is unlike the other things by name here as a hack for forma, it should probably saved by name and by guid just like anything else here
-        //         if(key.material){
-        //             this._materials.set(key.material.name, key.material);
-        //         }
-        //     }
-        // });
-
-        // // for (const ti in textures) {
-        // //     const textureInfo = textures[ti];
-        // //     await this.registerTexture(parser, ti, textureInfo, null, alreadyLoaded);
-        // // }
-
-        // if (debug)
-        //     console.log(this);
-    }
-
-    /** @deprecated */
-    public registerAsset(_asset: any) {
-        // if (debug) console.log("register asset", asset);
-        // console.assert(asset, "Asset is null or undefined");
-        // const guid: string = asset.userData?.guid;
-        // if (guid === null || guid === undefined || guid.length === 0) {
-        //     // asset has no guid, this can happen e.g. when using multi material meshes
-        //     // should we ask the parent for the guid if it's a group? 
-        //     // we need a more stable way to preserve ids anyways
-        //     return;
-        // }
-        // if (asset instanceof THREE.Texture || asset.type === 1009) {
-        //     if (this._textures.has(guid) && this._textures.get(guid) !== asset) {
-        //         if (debug)
-        //             console.warn("found duplicate texture " + guid, asset);
-        //         return;
-        //     }
-        //     if (debug)
-        //         console.log("register texture", guid, asset);
-        //     // should we check if an asset has been registered already? 
-        //     // should not matter as long as we only export guid from unity?
-        //     this._textures.set(guid, asset);
-        // }
-        // else if (asset instanceof THREE.Mesh || asset.type == "Mesh") {
-        //     this._meshes.set(guid, asset);
-        // }
-    }
-
-
-    private _materials: Map<string, THREE.Material> = new Map<string, THREE.Material>();
-    private _meshes: Map<string, THREE.Mesh> = new Map();
-    // private async registerMesh(parser: GltfParser, mesh : THREE.Mesh){        
-    //     const guid = mesh?.userData?.guid;
-    // }
-
-
-    private _textures: Map<string, THREE.Texture> = new Map();
-
-    // private async registerTexture(parser: GltfParser, index: number | string, textureInfo: TextureInfo, texture: THREE.Texture | null, alreadyLoaded: Set<string>) {
-
-    //     // const guid = textureInfo?.extras?.guid || texture?.userData?.guid;
-    //     // if (!guid) {
-    //     //     if (debug) console.warn("missing guid", texture, textureInfo)
-    //     //     return;
-    //     // }
-    //     // console.assert(guid !== null && guid !== undefined && guid.length > 0, "Texture has no guid in userData", texture);
-    //     // if (guid) {
-    //     //     if (alreadyLoaded.has(guid)) {
-    //     //         // console.warn("texture already loaded", textureInfo.name, guid);
-    //     //         return;
-    //     //     }
-    //     //     alreadyLoaded.add(guid);
-    //     // }
-
-    //     // if (!texture) {
-    //     //     texture = await parser.loadTexture(index);
-    //     //     if (!texture) {
-    //     //         if (debug)
-    //     //             console.warn("failed to load texture", guid);
-    //     //         return;
-    //     //     }
-    //     // }
-
-    //     // if (textureInfo.extras) {
-    //     //     texture.userData = { ...texture.userData, ...textureInfo.extras };
-    //     // }
-    //     // this.registerAsset(texture);
-    // }
-
-}
+    }
+    object[symbol] = users;
+}
+
+
+
+
+// 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];
+    }
+});
+
+
+function wrapMethod(fn: Function) {
+    return function (this: WebGLRenderer, ...args) {
+        noUpdateScope++;
+        const result = fn.apply(this, args);
+        noUpdateScope--;
+        return result;
+    }
+}
+
+
+
+// addGltfLoadEventListener(GltfLoadEventType.BeforeLoad, (_) => {
+//     noUpdateScope++;
+// });
+// addGltfLoadEventListener(GltfLoadEventType.AfterLoaded, (_) => {
+//     noUpdateScope--;
+// });
+
+
+
+
+// addPatch(Object3D.prototype, "add", (obj: Object3D) => {
+// });
+
+
+// addPatch(Object3D.prototype, "remove", (obj: Object3D) => {
+//     if(obj instanceof Mesh) {
+//     }
+// });
+

package/src/engine/engine_components.ts

@@ -5,10 +5,16 @@ import { getParam } from "./engine_utils";
 import { removeScriptFromContext, updateActiveInHierarchyWithoutEventCall } from "./engine_mainloop_utils";
 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";
 
 const debug = getParam("debuggetcomponent");
 
 
+
+
+
+
 function tryGetObject(obj) {
     if (obj === null || obj === undefined) return obj;
     if (obj.isObject3D) return obj;
@@ -23,6 +29,9 @@ export function removeComponent(go: Object3D, componentInstance: IComponent) {
     if (!go.userData.components) return;
     const index = go.userData.components.indexOf(componentInstance);
     if (index < 0) return;
+
+    __internalDispatchComponentLifecycleEvent(ComponentEvents.Removing, componentInstance);
+
     //@ts-ignore
     componentInstance.gameObject = null;
     go.userData.components.splice(index, 1);
@@ -35,6 +44,8 @@ export function getOrAddComponent<T extends IComponent>(go: Object3D, typeName:
     return addNewComponent(go, newInstance) as unknown as T;
 }
 
+const idProvider = new InstantiateIdProvider("addComponentIdProvider");
+
 export function addNewComponent<T extends IComponent>(obj: Object3D, componentInstance: T, callAwake = true): IComponent {
     if (!obj) {
         new Error("Can not add componet to null object");
@@ -43,14 +54,19 @@ export function addNewComponent<T extends IComponent>(obj: Object3D, componentIn
     if (!obj.userData.components) obj.userData.components = [];
     obj.userData.components.push(componentInstance);
     componentInstance.gameObject = obj as IGameObject;
+    // TODO: currently add component does not ensure a new component instance has a guid
+    if (componentInstance.guid === undefined || componentInstance.guid === "invalid") {
+        componentInstance.guid = idProvider.generateUUID();
+    }
     apply(obj);
     // componentInstance.transform = obj;
     registerComponent(componentInstance);
     try {
-        if (componentInstance.__internalAwake && callAwake) {
+        if (callAwake && componentInstance.__internalAwake) {
             updateActiveInHierarchyWithoutEventCall(obj);
             componentInstance.__internalAwake();
         }
+        __internalDispatchComponentLifecycleEvent(ComponentEvents.Added, componentInstance);
     }
     catch (err) {
         console.error(err);
@@ -67,8 +83,11 @@ export function moveComponentInstance(obj: Object3D, componentInstance: ICompone
     }
     if (!obj.userData.components) obj.userData.components = [];
     else if (obj.userData.components.includes(componentInstance)) return;
+    // TODO: do we want to disable and enable when moving?
+    // componentInstance.__internalDisable();
     obj.userData.components.push(componentInstance);
     componentInstance.gameObject = obj as IGameObject;
+    // componentInstance.__internalEnable();
     // componentInstance.transform = obj;
 }
 

package/src/engine/engine_components_internal.ts

@@ -0,0 +1,30 @@
+import { IComponent } from "./engine_types";
+
+
+const eventListeners = new Map<string, ((data: IComponent) => void)[]>();
+
+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);
+}
+
+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 function __internalDispatchComponentLifecycleEvent(evt: string, data: IComponent) {
+    const listeners = eventListeners.get(evt);
+    if (!listeners) return;
+    for (const listener of listeners) {
+        listener(data);
+    }
+}

package/src/engine/engine_constants.ts

@@ -1,3 +1,6 @@
 
 export const activeInHierarchyFieldName = Symbol("isActiveInHierarchy");
-export const builtinComponentKeyName = "builtin_components";
+export const builtinComponentKeyName = "builtin_components";
+
+
+export const $originalGuid = Symbol("originalGuid");

package/src/engine/engine_context_registry.ts

@@ -47,4 +47,11 @@ export class ContextRegistry {
         const args = { event: evt, context }
         this._callbacks[evt].forEach(cb => cb(args));
     }
+
+    static addContextCreatedCallback(callback: ContextCallback) {
+        this.registerCallback(ContextEvent.ContextCreated, callback);
+    }
+    static addContextDestroyedCallback(callback: ContextCallback) {
+        this.registerCallback(ContextEvent.ContextDestroyed, callback);
+    }
 }

package/src/engine/engine_editor-sync.ts

@@ -0,0 +1,21 @@
+
+
+
+
+export declare type EditorModification = {
+    guid: string,
+    propertyName: string,
+    value: any
+}
+
+export interface IEditorModification {
+    onEditorModification(modification: EditorModification): void | undefined | boolean;
+}
+
+// let editorCache = new Map<string, EditorModification>();
+// export function setEditorModificationCache(cache: Map<string, EditorModification>) {
+//     cache = editorCache;
+// }
+export function getEditorModificationCache() {
+    return globalThis["NeedleEditorSync.ModificationCache"] as null | undefined | Map<string, EditorModification>;
+}