@needle-tools/engine 3.28.7-beta → 3.28.7-beta.1

package/src/engine/extensions/NEEDLE_components.ts

@@ -1,251 +1,251 @@
-import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { type NodeToObjectMap, type ObjectToNodeMap, SerializationContext } from "../engine_serialization_core.js";
-import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import { debugExtension } from "../engine_default_parameters.js";
-import { builtinComponentKeyName } from "../engine_constants.js";
-import { resolveReferences } from "./extension_utils.js";
-import { apply } from "../../engine-components/js-extensions/Object3D.js";
-import { getLoader } from "../engine_gltf.js";
-import { Object3D } from "three";
-
-export const debug = debugExtension
-const componentsArrayExportKey = "$___Export_Components";
-
-export const EXTENSION_NAME = "NEEDLE_components";
-
-class ExtensionData {
-    [builtinComponentKeyName]?: Array<object | null>
-}
-
-class ExportData {
-    node: Object3D;
-    nodeIndex: number;
-    nodeDef: any;
-
-    constructor(node: Object3D, nodeIndex: number, nodeDef: any) {
-        this.node = node;
-        this.nodeIndex = nodeIndex;
-        this.nodeDef = nodeDef;
-    }
-}
-
-export class NEEDLE_components implements GLTFLoaderPlugin {
-
-    get name(): string {
-        return EXTENSION_NAME;
-    }
-
-    // import
-    parser?: GLTFParser;
-    nodeToObjectMap: NodeToObjectMap = {};
-
-    // export
-    exportContext!: { [nodeIndex: number]: ExportData };
-    objectToNodeMap: ObjectToNodeMap = {};
-    context!: SerializationContext;
-    writer?: any;
-
-    registerExport(exp: GLTFExporter) {
-        //@ts-ignore
-        exp.register(writer => {
-            // we want to hook into BEFORE user data is written
-            // because we want to remove the components list (circular references)
-            // and replace them with the serialized data
-            // the write node callback is called after user data is serialized
-            // we could also traverse everything before export and remove components
-            // but doing it like that we avoid traversing multiple times
-            if ("serializeUserData" in writer) {
-                //@ts-ignore
-                const originalFunction = writer.serializeUserData.bind(writer);
-                this.writer = writer;
-                //@ts-ignore
-                writer.serializeUserData = (o, def) => {
-                    try {
-                        this.serializeUserData(o, def);
-                        originalFunction(o, def);
-                    }
-                    finally {
-                        this.afterSerializeUserData(o, def);
-                    }
-                }
-            }
-            return this;
-        });
-    }
-
-    beforeParse() {
-        this.exportContext = {};
-        this.objectToNodeMap = {};
-    }
-
-    // https://github.com/mrdoob/three.js/blob/efbfc67edc7f65cfcc61a389ffc5fd43ea702bc6/examples/jsm/exporters/GLTFExporter.js#L532
-    serializeUserData(node: Object3D, _nodeDef: any) {
-        const components = node.userData?.components;
-        if (!components || components.length <= 0) return;
-        // delete components before serializing user data to avoid circular references
-        delete node.userData.components;
-        node[componentsArrayExportKey] = components;
-    }
-
-    afterSerializeUserData(node: Object3D, _nodeDef) {
-        if (node.type === "Scene") {
-            if (debug)
-                console.log("DONE", JSON.stringify(_nodeDef));
-        }
-        // reset userdata
-        if (node[componentsArrayExportKey] === undefined) return;
-        const components = node[componentsArrayExportKey];
-        delete node[componentsArrayExportKey];
-        if (components !== null) {
-            node.userData.components = components;
-        }
-
-        // console.log(_nodeDef, _nodeDef.mesh);
-    }
-
-    writeNode(node: Object3D, nodeDef) {
-        const nodeIndex = this.writer.json.nodes.length;
-        if (debug) 
-            console.log(node.name, nodeIndex, node.uuid);
-        const context = new ExportData(node, nodeIndex, nodeDef);
-        this.exportContext[nodeIndex] = context;
-        this.objectToNodeMap[node.uuid] = nodeIndex;
-    };
-
-    afterParse(input) {
-        if (debug)
-            console.log("AFTER", input);
-        for (const i in this.exportContext) {
-            const context = this.exportContext[i];
-            const node = context.node;
-            const nodeDef = context.nodeDef;
-            const nodeIndex = context.nodeIndex;
-
-            const components = node.userData?.components;
-            if (!components || components.length <= 0) continue;
-            // create data container
-            const data: ExtensionData = new ExtensionData();
-            nodeDef.extensions = nodeDef.extensions || {};
-            nodeDef.extensions[this.name] = data;
-            this.context.object = node;
-            this.context.nodeId = nodeIndex;
-            this.context.objectToNode = this.objectToNodeMap;
-
-            const serializedComponentData: Array<object | null> = [];
-            for (const comp of components) {
-                this.context.target = comp;
-                const res = getLoader().writeBuiltinComponentData(comp, this.context);
-                if (res !== null) {
-                    serializedComponentData.push(res);
-                    // (comp as unknown as ISerializationCallbackReceiver)?.onAfterSerialize?.call(comp);
-                }
-            }
-            if (serializedComponentData.length > 0) {
-                data[builtinComponentKeyName] = serializedComponentData;
-                if (debug)
-                    console.log("DID WRITE", node, "nodeIndex", nodeIndex, serializedComponentData);
-            }
-        }
-    }
-
-
-
-    // -------------------------------------
-    // LOADING 
-    // called by GLTFLoader
-    beforeRoot() {
-        if (debug)
-            console.log("BEGIN LOAD");
-        this.nodeToObjectMap = {};
-        return null;
-    }
-
-    // called by GLTFLoader
-    async afterRoot(result: GLTF): Promise<void> {
-        const parser = result.parser;
-        const ext = parser?.extensions;
-        if (!ext) return;
-        const hasExtension = ext[this.name];
-        if (debug)
-            console.log("After root", result, this.parser, ext);
-
-        const loadComponents: Array<Promise<void>> = [];
-        if (hasExtension === true) {
-            const nodes = parser.json.nodes;
-            if (nodes) {
-                for (let i = 0; i < nodes.length; i++) {
-                    const obj = await parser.getDependency('node', i);
-                    this.nodeToObjectMap[i] = obj;
-                }
-
-                for (let i = 0; i < nodes.length; i++) {
-                    const node = nodes[i];
-                    const index = i;// node.mesh;
-                    const ext = node.extensions;
-                    if (!ext) continue;
-                    const data = ext[this.name];
-                    if (!data) continue;
-                    if (debug)
-                        console.log("NODE", node);
-                    const obj = this.nodeToObjectMap[index];
-                    if (!obj) {
-                        console.error("Could not find object for node index: " + index, node, parser);
-                        continue;
-                    }
-
-                    apply(obj);
-
-                    loadComponents.push(this.createComponents(obj, data));
-                }
-            }
-        }
-        await Promise.all(loadComponents);
-    }
-
-    private async createComponents(obj: Object3D, data: ExtensionData) {
-        if (!data) return;
-        const componentData = data[builtinComponentKeyName];
-        if (componentData) {
-            const tasks = new Array<Promise<any>>();
-            if (debug)
-                console.log(obj.name, componentData);
-            for (const i in componentData) {
-                const serializedData = componentData[i];
-                if (debug)
-                    console.log("Serialized data", JSON.parse(JSON.stringify(serializedData)));
-
-                if (serializedData && this.parser) {
-                    tasks.push(
-                        resolveReferences(this.parser, serializedData)
-                            .catch(e => console.error(`Error while resolving references (see console for details)\n`, e, obj, serializedData))
-                    );
-                }
-
-                obj.userData = obj.userData || {};
-                obj.userData[builtinComponentKeyName] = obj.userData[builtinComponentKeyName] || [];
-                obj.userData[builtinComponentKeyName].push(serializedData);
-            }
-            await Promise.all(tasks).catch((e) => {
-                console.error("Error while loading components", e);
-            });
-        }
-    }
-
-    // parse function https://github.com/mrdoob/three.js/blob/efbfc67edc7f65cfcc61a389ffc5fd43ea702bc6/examples/jsm/loaders/GLTFLoader.js#L2290
-
-
-    // createNodeAttachment(nodeIndex: number): null {
-    //     // if(!this.parser){
-    //     //     console.error("Parser not set, call registerLoad with on this");
-    //     //     return null;
-    //     // }
-    //     // const node = this.parser.json.nodes[nodeIndex];
-    //     // const extenstions = node.extensions;
-    //     // const data = extenstions && extenstions[this.name];
-    //     // if (!data) return null;
-    //     // const components = data[builtinComponentKeyName];
-    //     // if (!components) return null;
-    //     // console.log(components);
-    //     return null;
-    // }
+import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { type NodeToObjectMap, type ObjectToNodeMap, SerializationContext } from "../engine_serialization_core.js";
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+import { debugExtension } from "../engine_default_parameters.js";
+import { builtinComponentKeyName } from "../engine_constants.js";
+import { resolveReferences } from "./extension_utils.js";
+import { apply } from "../../engine-components/js-extensions/Object3D.js";
+import { getLoader } from "../engine_gltf.js";
+import { Object3D } from "three";
+
+export const debug = debugExtension
+const componentsArrayExportKey = "$___Export_Components";
+
+export const EXTENSION_NAME = "NEEDLE_components";
+
+class ExtensionData {
+    [builtinComponentKeyName]?: Array<object | null>
+}
+
+class ExportData {
+    node: Object3D;
+    nodeIndex: number;
+    nodeDef: any;
+
+    constructor(node: Object3D, nodeIndex: number, nodeDef: any) {
+        this.node = node;
+        this.nodeIndex = nodeIndex;
+        this.nodeDef = nodeDef;
+    }
+}
+
+export class NEEDLE_components implements GLTFLoaderPlugin {
+
+    get name(): string {
+        return EXTENSION_NAME;
+    }
+
+    // import
+    parser?: GLTFParser;
+    nodeToObjectMap: NodeToObjectMap = {};
+
+    // export
+    exportContext!: { [nodeIndex: number]: ExportData };
+    objectToNodeMap: ObjectToNodeMap = {};
+    context!: SerializationContext;
+    writer?: any;
+
+    registerExport(exp: GLTFExporter) {
+        //@ts-ignore
+        exp.register(writer => {
+            // we want to hook into BEFORE user data is written
+            // because we want to remove the components list (circular references)
+            // and replace them with the serialized data
+            // the write node callback is called after user data is serialized
+            // we could also traverse everything before export and remove components
+            // but doing it like that we avoid traversing multiple times
+            if ("serializeUserData" in writer) {
+                //@ts-ignore
+                const originalFunction = writer.serializeUserData.bind(writer);
+                this.writer = writer;
+                //@ts-ignore
+                writer.serializeUserData = (o, def) => {
+                    try {
+                        this.serializeUserData(o, def);
+                        originalFunction(o, def);
+                    }
+                    finally {
+                        this.afterSerializeUserData(o, def);
+                    }
+                }
+            }
+            return this;
+        });
+    }
+
+    beforeParse() {
+        this.exportContext = {};
+        this.objectToNodeMap = {};
+    }
+
+    // https://github.com/mrdoob/three.js/blob/efbfc67edc7f65cfcc61a389ffc5fd43ea702bc6/examples/jsm/exporters/GLTFExporter.js#L532
+    serializeUserData(node: Object3D, _nodeDef: any) {
+        const components = node.userData?.components;
+        if (!components || components.length <= 0) return;
+        // delete components before serializing user data to avoid circular references
+        delete node.userData.components;
+        node[componentsArrayExportKey] = components;
+    }
+
+    afterSerializeUserData(node: Object3D, _nodeDef) {
+        if (node.type === "Scene") {
+            if (debug)
+                console.log("DONE", JSON.stringify(_nodeDef));
+        }
+        // reset userdata
+        if (node[componentsArrayExportKey] === undefined) return;
+        const components = node[componentsArrayExportKey];
+        delete node[componentsArrayExportKey];
+        if (components !== null) {
+            node.userData.components = components;
+        }
+
+        // console.log(_nodeDef, _nodeDef.mesh);
+    }
+
+    writeNode(node: Object3D, nodeDef) {
+        const nodeIndex = this.writer.json.nodes.length;
+        if (debug) 
+            console.log(node.name, nodeIndex, node.uuid);
+        const context = new ExportData(node, nodeIndex, nodeDef);
+        this.exportContext[nodeIndex] = context;
+        this.objectToNodeMap[node.uuid] = nodeIndex;
+    };
+
+    afterParse(input) {
+        if (debug)
+            console.log("AFTER", input);
+        for (const i in this.exportContext) {
+            const context = this.exportContext[i];
+            const node = context.node;
+            const nodeDef = context.nodeDef;
+            const nodeIndex = context.nodeIndex;
+
+            const components = node.userData?.components;
+            if (!components || components.length <= 0) continue;
+            // create data container
+            const data: ExtensionData = new ExtensionData();
+            nodeDef.extensions = nodeDef.extensions || {};
+            nodeDef.extensions[this.name] = data;
+            this.context.object = node;
+            this.context.nodeId = nodeIndex;
+            this.context.objectToNode = this.objectToNodeMap;
+
+            const serializedComponentData: Array<object | null> = [];
+            for (const comp of components) {
+                this.context.target = comp;
+                const res = getLoader().writeBuiltinComponentData(comp, this.context);
+                if (res !== null) {
+                    serializedComponentData.push(res);
+                    // (comp as unknown as ISerializationCallbackReceiver)?.onAfterSerialize?.call(comp);
+                }
+            }
+            if (serializedComponentData.length > 0) {
+                data[builtinComponentKeyName] = serializedComponentData;
+                if (debug)
+                    console.log("DID WRITE", node, "nodeIndex", nodeIndex, serializedComponentData);
+            }
+        }
+    }
+
+
+
+    // -------------------------------------
+    // LOADING 
+    // called by GLTFLoader
+    beforeRoot() {
+        if (debug)
+            console.log("BEGIN LOAD");
+        this.nodeToObjectMap = {};
+        return null;
+    }
+
+    // called by GLTFLoader
+    async afterRoot(result: GLTF): Promise<void> {
+        const parser = result.parser;
+        const ext = parser?.extensions;
+        if (!ext) return;
+        const hasExtension = ext[this.name];
+        if (debug)
+            console.log("After root", result, this.parser, ext);
+
+        const loadComponents: Array<Promise<void>> = [];
+        if (hasExtension === true) {
+            const nodes = parser.json.nodes;
+            if (nodes) {
+                for (let i = 0; i < nodes.length; i++) {
+                    const obj = await parser.getDependency('node', i);
+                    this.nodeToObjectMap[i] = obj;
+                }
+
+                for (let i = 0; i < nodes.length; i++) {
+                    const node = nodes[i];
+                    const index = i;// node.mesh;
+                    const ext = node.extensions;
+                    if (!ext) continue;
+                    const data = ext[this.name];
+                    if (!data) continue;
+                    if (debug)
+                        console.log("NODE", node);
+                    const obj = this.nodeToObjectMap[index];
+                    if (!obj) {
+                        console.error("Could not find object for node index: " + index, node, parser);
+                        continue;
+                    }
+
+                    apply(obj);
+
+                    loadComponents.push(this.createComponents(obj, data));
+                }
+            }
+        }
+        await Promise.all(loadComponents);
+    }
+
+    private async createComponents(obj: Object3D, data: ExtensionData) {
+        if (!data) return;
+        const componentData = data[builtinComponentKeyName];
+        if (componentData) {
+            const tasks = new Array<Promise<any>>();
+            if (debug)
+                console.log(obj.name, componentData);
+            for (const i in componentData) {
+                const serializedData = componentData[i];
+                if (debug)
+                    console.log("Serialized data", JSON.parse(JSON.stringify(serializedData)));
+
+                if (serializedData && this.parser) {
+                    tasks.push(
+                        resolveReferences(this.parser, serializedData)
+                            .catch(e => console.error(`Error while resolving references (see console for details)\n`, e, obj, serializedData))
+                    );
+                }
+
+                obj.userData = obj.userData || {};
+                obj.userData[builtinComponentKeyName] = obj.userData[builtinComponentKeyName] || [];
+                obj.userData[builtinComponentKeyName].push(serializedData);
+            }
+            await Promise.all(tasks).catch((e) => {
+                console.error("Error while loading components", e);
+            });
+        }
+    }
+
+    // parse function https://github.com/mrdoob/three.js/blob/efbfc67edc7f65cfcc61a389ffc5fd43ea702bc6/examples/jsm/loaders/GLTFLoader.js#L2290
+
+
+    // createNodeAttachment(nodeIndex: number): null {
+    //     // if(!this.parser){
+    //     //     console.error("Parser not set, call registerLoad with on this");
+    //     //     return null;
+    //     // }
+    //     // const node = this.parser.json.nodes[nodeIndex];
+    //     // const extenstions = node.extensions;
+    //     // const data = extenstions && extenstions[this.name];
+    //     // if (!data) return null;
+    //     // const components = data[builtinComponentKeyName];
+    //     // if (!components) return null;
+    //     // console.log(components);
+    //     return null;
+    // }
 }

package/src/engine/extensions/NEEDLE_gameobject_data.ts

@@ -1,83 +1,83 @@
-import { Object3D } from "three";
-import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
-
-export const EXTENSION_NAME = "NEEDLE_gameobject_data";
-
-declare type GameObjectData = {
-    layers: number,
-    visible: boolean,
-    tag: string,
-    hideFlags: number,
-    static: boolean,
-    activeSelf: boolean,
-    guid: string
-}
-
-export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
-
-    get name(): string {
-        return EXTENSION_NAME;
-    }
-
-    private parser: GLTFParser;
-
-    constructor(parser: GLTFParser) {
-        this.parser = parser;
-    }
-
-    // private _lastIndex: number = -1;
-    // createNodeAttachment(index): null {
-    //     if (index === this._lastIndex) return null;
-    //     this._lastIndex = index;
-    //     const node = this.parser.json.nodes[index];
-    //     if (node && node.extensions) {
-    //         const ext = node.extensions[EXTENSION_NAME];
-    //         if (ext)
-    //             this.findAndApplyExtensionData(index, ext);
-    //     }
-    //     return null;
-    // }
-
-    // private lastIndex: number = -1;
-    afterRoot(_result: GLTF): Promise<void> | null {
-        // console.log("AFTER ROOT", _result);
-        const promises: Promise<void>[] = [];
-        for (let index = 0; index < this.parser.json.nodes?.length; index++) {
-            const node = this.parser.json.nodes[index];
-            if (node && node.extensions) {
-                const ext = node.extensions[EXTENSION_NAME];
-                if (ext) {
-                    const p = this.findAndApplyExtensionData(index, ext);
-                    promises.push(p);
-                }
-            }
-        }
-        return Promise.all(promises).then(() => { });
-    }
-
-    private async findAndApplyExtensionData(nodeId: number, ext: GameObjectData) {
-        const obj = await this.parser.getDependency("node", nodeId);
-        if (obj) {
-            this.applyExtensionData(obj, ext);
-        }
-    }
-
-
-    private applyExtensionData(node: Object3D, ext: GameObjectData) {
-        if (ext.layers === undefined) ext.layers = 0;
-        node.userData.layer = ext.layers;
-        node.layers.disableAll();
-        node.layers.set(ext.layers);
-
-        node.userData.tag = ext.tag ?? "none";
-
-        node.userData.hideFlags = ext.hideFlags ?? 0;
-
-        node.userData.static = ext.static ?? false;
-
-        node.visible = ext.activeSelf ?? true;
-        
-        node["guid"] = ext.guid;
-        // console.log(node.name, ext.activeSelf, node);
-    }
+import { Object3D } from "three";
+import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+
+export const EXTENSION_NAME = "NEEDLE_gameobject_data";
+
+declare type GameObjectData = {
+    layers: number,
+    visible: boolean,
+    tag: string,
+    hideFlags: number,
+    static: boolean,
+    activeSelf: boolean,
+    guid: string
+}
+
+export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
+
+    get name(): string {
+        return EXTENSION_NAME;
+    }
+
+    private parser: GLTFParser;
+
+    constructor(parser: GLTFParser) {
+        this.parser = parser;
+    }
+
+    // private _lastIndex: number = -1;
+    // createNodeAttachment(index): null {
+    //     if (index === this._lastIndex) return null;
+    //     this._lastIndex = index;
+    //     const node = this.parser.json.nodes[index];
+    //     if (node && node.extensions) {
+    //         const ext = node.extensions[EXTENSION_NAME];
+    //         if (ext)
+    //             this.findAndApplyExtensionData(index, ext);
+    //     }
+    //     return null;
+    // }
+
+    // private lastIndex: number = -1;
+    afterRoot(_result: GLTF): Promise<void> | null {
+        // console.log("AFTER ROOT", _result);
+        const promises: Promise<void>[] = [];
+        for (let index = 0; index < this.parser.json.nodes?.length; index++) {
+            const node = this.parser.json.nodes[index];
+            if (node && node.extensions) {
+                const ext = node.extensions[EXTENSION_NAME];
+                if (ext) {
+                    const p = this.findAndApplyExtensionData(index, ext);
+                    promises.push(p);
+                }
+            }
+        }
+        return Promise.all(promises).then(() => { });
+    }
+
+    private async findAndApplyExtensionData(nodeId: number, ext: GameObjectData) {
+        const obj = await this.parser.getDependency("node", nodeId);
+        if (obj) {
+            this.applyExtensionData(obj, ext);
+        }
+    }
+
+
+    private applyExtensionData(node: Object3D, ext: GameObjectData) {
+        if (ext.layers === undefined) ext.layers = 0;
+        node.userData.layer = ext.layers;
+        node.layers.disableAll();
+        node.layers.set(ext.layers);
+
+        node.userData.tag = ext.tag ?? "none";
+
+        node.userData.hideFlags = ext.hideFlags ?? 0;
+
+        node.userData.static = ext.static ?? false;
+
+        node.visible = ext.activeSelf ?? true;
+        
+        node["guid"] = ext.guid;
+        // console.log(node.name, ext.activeSelf, node);
+    }
 }