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

package/lib/engine/engine_serialization_builtin_serializer.js

@@ -1,370 +1,370 @@
-import * as THREE from "three";
-import { RGBAColor } from "../engine-components/js-extensions/RGBAColor.js";
-import { TypeSerializer } from "./engine_serialization_core.js";
-import { Behaviour, Component, GameObject } from "../engine-components/Component.js";
-import { debugExtension } from "./engine_default_parameters.js";
-import { CallInfo, EventList } from "../engine-components/EventList.js";
-import { Color, CompressedTexture, Object3D, Texture, WebGLRenderTarget } from "three";
-import { RenderTexture } from "./engine_texture.js";
-import { isDevEnvironment, showBalloonWarning } from "../engine/debug/index.js";
-import { resolveUrl } from "./engine_utils.js";
-import { AssetReference } from "./engine_addressables.js";
-// export class SourcePath {
-//     src?:string
-// };
-// class SourcePathSerializer extends TypeSerializer{
-//     constructor(){
-//         super(SourcePath);
-//     }
-//     onDeserialize(data: any, _context: SerializationContext) {
-//         if(data.src && typeof data.src === "string"){
-//             return data.src;
-//         }
-//     }
-//     onSerialize(_data: any, _context: SerializationContext) {
-//     }
-// }
-// new SourcePathSerializer();
-class ColorSerializer extends TypeSerializer {
-    constructor() {
-        super([Color, RGBAColor]);
-    }
-    onDeserialize(data) {
-        if (data === undefined || data === null)
-            return;
-        if (data.a !== undefined) {
-            return new RGBAColor(data.r, data.g, data.b, data.a);
-        }
-        else if (data.alpha !== undefined) {
-            return new RGBAColor(data.r, data.g, data.b, data.alpha);
-        }
-        return new THREE.Color(data.r, data.g, data.b);
-    }
-    onSerialize(data) {
-        if (data === undefined || data === null)
-            return;
-        if (data.a !== undefined)
-            return { r: data.r, g: data.g, b: data.b, a: data.a };
-        else
-            return { r: data.r, g: data.g, b: data.b };
-    }
-}
-export const colorSerializer = new ColorSerializer();
-class ObjectSerializer extends TypeSerializer {
-    constructor() {
-        super(Object3D);
-    }
-    onSerialize(data, context) {
-        if (context.objectToNode !== undefined && data.uuid) {
-            const node = context.objectToNode[data.uuid];
-            if (debugExtension)
-                console.log(node, data.name, data.uuid);
-            return { node: node };
-        }
-        return undefined;
-    }
-    onDeserialize(data, context) {
-        if (typeof data === "string") {
-            if (data.endsWith(".glb") || data.endsWith(".gltf")) {
-                // If the @serializable([Object3D, AssetReference]) looks like this we don't need to warn here. This is the case e.g. with SyncedCamera referencing a scene
-                if (context.serializable instanceof Array) {
-                    if (context.serializable.includes(AssetReference))
-                        return undefined;
-                }
-                if (isDevEnvironment())
-                    showBalloonWarning("Detected wrong usage of @serializable with Object3D or GameObject. Instead you should use AssetReference here! Please see the console for details.");
-                const scriptname = context.target?.constructor?.name;
-                console.warn(`Wrong usage of @serializable detected in your script \"${scriptname}\"\n\nIt looks like you used @serializable(Object3D) or @serializable(GameObject) for a prefab or scene reference which is exported to a separate glTF file.\n\nTo fix this please change your code to:\n\n@serializable(AssetReference)\n${context.path}! : AssetReference;\n\0`);
-            }
-            // ACTUALLY: this is already handled by the extension_utils where we resolve json pointers recursively
-            // if(data.startsWith("/nodes/")){
-            //     const node = parseInt(data.substring("/nodes/".length));
-            //     if (context.nodeToObject) {
-            //         const res = context.nodeToObject[node];
-            //         if (debugExtension)
-            //             console.log("Deserialized object reference?", data, res, context?.nodeToObject);
-            //         if (!res) console.warn("Did not find node: " + data, context.nodeToObject, context.object);
-            //         return res;
-            //     }
-            // }
-            return undefined;
-        }
-        if (data) {
-            if (data.node !== undefined && context.nodeToObject) {
-                const res = context.nodeToObject[data.node];
-                if (debugExtension)
-                    console.log("Deserialized object reference?", data, res, context?.nodeToObject);
-                if (!res)
-                    console.warn("Did not find node: " + data.node, context.nodeToObject, context.object);
-                return res;
-            }
-            else if (data.guid) {
-                if (!context.context) {
-                    console.error("Missing context");
-                    return undefined;
-                }
-                // it is possible that the object is not yet loaded 
-                // e.g. if we have a scene with multiple gltf files and the first gltf references something in the second gltf
-                // we need a way to wait for all components to be created before we can resolve those references
-                // independent of order of loading
-                let res = undefined;
-                // first try to search in the current gltf scene (if any)
-                const gltfScene = context.gltf?.scene;
-                if (gltfScene) {
-                    res = GameObject.findByGuid(data.guid, gltfScene);
-                }
-                // if not found, search in the whole scene
-                if (!res) {
-                    res = GameObject.findByGuid(data.guid, context.context.scene);
-                }
-                if (!res) {
-                    if (isDevEnvironment() || debugExtension)
-                        console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
-                    data["could_not_resolve"] = true;
-                }
-                else if (debugExtension)
-                    console.log("Deserialized object reference?", data, res, context?.nodeToObject);
-                return res;
-            }
-        }
-        return undefined;
-    }
-}
-export const objectSerializer = new ObjectSerializer();
-class ComponentSerializer extends TypeSerializer {
-    constructor() {
-        super([Component, Behaviour]);
-    }
-    onSerialize(data, _context) {
-        if (data?.guid) {
-            return { guid: data.guid };
-        }
-        return undefined;
-    }
-    onDeserialize(data, context) {
-        if (data?.guid) {
-            // TODO: need to serialize some identifier for referenced components as well, maybe just guid?
-            // because here the components are created but dont have their former guid assigned
-            // and will later in the stack just get a newly generated guid
-            if (debugExtension)
-                console.log(data.guid, context.root, context.object, context.target);
-            // first search within the gltf (e.g. necessary when using AssetReference and loading a gltf without adding it to the scene)
-            // if we would search JUST the scene those references would NEVER be resolved
-            let res = this.findObjectForGuid(data.guid, context.root);
-            if (res) {
-                return res;
-            }
-            if (context.context) {
-                // if not found within the gltf use the provided context scene
-                // to find references outside
-                res = this.findObjectForGuid(data.guid, context.context?.scene);
-                if (res)
-                    return res;
-            }
-            if (isDevEnvironment() || debugExtension)
-                console.warn("Could not resolve component reference", context.path, data, context.target);
-            data["could_not_resolve"] = true;
-            return undefined;
-        }
-        // if (data?.node !== undefined && context.nodeToObject) {
-        //     return context.nodeToObject[data.node];
-        // }
-        return undefined;
-    }
-    findObjectForGuid(guid, root) {
-        // recursively search root
-        // need to check the root object too
-        if (root["guid"] === guid)
-            return root;
-        const res = GameObject.foreachComponent(root, (c) => {
-            if (c.guid === guid)
-                return c;
-            return undefined;
-        }, false);
-        if (res !== undefined)
-            return res;
-        // if not found, search in children
-        for (let i = 0; i < root.children.length; i++) {
-            const child = root.children[i];
-            const res = this.findObjectForGuid(guid, child);
-            if (res)
-                return res;
-        }
-    }
-}
-export const componentSerializer = new ComponentSerializer();
-const $eventListDebugInfo = Symbol("eventListDebugInfo");
-class EventListSerializer extends TypeSerializer {
-    constructor() {
-        super([EventList]);
-    }
-    onSerialize(_data, _context) {
-        console.log("TODO: SERIALIZE EVENT");
-        return undefined;
-    }
-    onDeserialize(data, context) {
-        // TODO: check that we dont accidentally deserialize methods to EventList objects. This is here to make is easy for react-three-fiber to just add props as { () => { } } 
-        if (typeof data === "function") {
-            const evtList = new EventList([new CallInfo(data, true)]);
-            return evtList;
-        }
-        else if (data && data.type === "EventList") {
-            if (debugExtension)
-                console.log("DESERIALIZE EVENT", data);
-            const fns = new Array();
-            if (data.calls && Array.isArray(data.calls)) {
-                for (const call of data.calls) {
-                    if (debugExtension)
-                        console.log(call);
-                    let target = componentSerializer.findObjectForGuid(call.target, context.root);
-                    // if the object is not found in the current glb try find it in the whole scene
-                    if (!target && context.context?.scene) {
-                        target = componentSerializer.findObjectForGuid(call.target, context.context?.scene);
-                    }
-                    const hasMethod = call.method?.length > 0;
-                    if (target && hasMethod) {
-                        const printWarningMethodNotFound = () => {
-                            const uppercaseMethodName = call.method[0].toUpperCase() + call.method.slice(1);
-                            if (typeof target[uppercaseMethodName] === "function") {
-                                console.warn(`EventList method:\nCould not find method ${call.method} on object ${target.name}. Please rename ${call.method} to ${uppercaseMethodName}?\n`, target[uppercaseMethodName], "\n in script: ", target);
-                                showBalloonWarning("EventList methods must start with lowercase letter, see console for details");
-                                return;
-                            }
-                            else {
-                                console.warn(`EventList method:\nCould not find method ${call.method} on object ${target.name}`, target, typeof target[call.method]);
-                            }
-                        };
-                        const method = target[call.method];
-                        if (typeof method !== "function") {
-                            let foundMethod = false;
-                            let currentPrototype = target;
-                            // test if the target method is actually a property setter
-                            while (currentPrototype) {
-                                const desc = Object.getOwnPropertyDescriptor(currentPrototype, call.method);
-                                if (desc && (desc.writable === true || desc.set)) {
-                                    foundMethod = true;
-                                    break;
-                                }
-                                currentPrototype = Object.getPrototypeOf(currentPrototype);
-                            }
-                            if (!foundMethod && (isDevEnvironment() || debugExtension))
-                                printWarningMethodNotFound();
-                        }
-                    }
-                    function deserializeArgument(arg) {
-                        if (typeof arg === "object") {
-                            // Try to deserialize the call argument to either a object or a component reference
-                            let argRes = objectSerializer.onDeserialize(arg, context);
-                            if (!argRes)
-                                argRes = componentSerializer.onDeserialize(arg, context);
-                            if (argRes)
-                                return argRes;
-                        }
-                        return arg;
-                    }
-                    let args = call.argument;
-                    if (args !== undefined) {
-                        args = deserializeArgument(args);
-                    }
-                    else if (call.arguments !== undefined) {
-                        args = call.arguments.map(deserializeArgument);
-                    }
-                    // This is the final method we pass to the call info (or undefined if the method couldnt be resolved)
-                    const eventMethod = hasMethod ? this.createEventMethod(target, call.method, args) : undefined;
-                    const fn = new CallInfo(eventMethod, call.enabled);
-                    if (!fn.method)
-                        fn[$eventListDebugInfo] = context.object?.name;
-                    if (!target || !fn.method) {
-                        const debugInfo = context.object ? "Current object: " + context.object.name + ", " + context.object["guid"] : null;
-                        if (!target)
-                            console.warn("EventList is missing target - will be ignored", call.target, debugInfo, data);
-                        else
-                            console.warn("EventList method not found: \"" + call.method + "\" on", target);
-                    }
-                    else
-                        fns.push(fn);
-                }
-            }
-            const evt = new EventList(fns);
-            if (debugExtension)
-                console.log(evt);
-            const eventListOwner = context.target;
-            if (eventListOwner !== undefined && context.path !== undefined) {
-                evt.setEventTarget(context.path, eventListOwner);
-            }
-            return evt;
-        }
-        return undefined;
-    }
-    createEventMethod(target, methodName, args) {
-        return (...forwardedArgs) => {
-            const method = target[methodName];
-            if (typeof method === "function") {
-                if (args !== undefined) {
-                    // we now have support for creating event methods with multiple arguments
-                    // an argument can not be an array right now - so if we receive an array we assume it's the array of arguments that we want to call the method with
-                    // this means ["test", true] will invoke the method like this: myFunction("test", true) 
-                    if (Array.isArray(args))
-                        method?.call(target, ...args);
-                    // in any other case (when we just have one argument) we just call the method with the argument
-                    // we an not use ...args by default becaue that would break string arguments (it would then just use the first character)
-                    else
-                        method?.call(target, args);
-                }
-                else // support invoking EventList with any number of arguments (if none were declared in unity)
-                    method?.call(target, ...forwardedArgs);
-            }
-            else // the target "method" can be a property too
-             {
-                target[methodName] = args;
-            }
-        };
-    }
-}
-export const eventListSerializer = new EventListSerializer();
-export class RenderTextureSerializer extends TypeSerializer {
-    constructor() {
-        super([RenderTexture, WebGLRenderTarget]);
-    }
-    onSerialize(_data, _context) {
-    }
-    onDeserialize(data, context) {
-        if (data instanceof Texture && context.type === RenderTexture) {
-            const tex = data;
-            const rt = new RenderTexture(tex.image.width, tex.image.height, {
-                colorSpace: THREE.LinearSRGBColorSpace,
-            });
-            rt.texture = tex;
-            tex.isRenderTargetTexture = true;
-            tex.flipY = true;
-            tex.offset.y = 1;
-            tex.repeat.y = -1;
-            tex.needsUpdate = true;
-            if (tex instanceof CompressedTexture) {
-                //@ts-ignore
-                tex["isCompressedTexture"] = false;
-                //@ts-ignore
-                tex.format = THREE.RGBAFormat;
-            }
-            return rt;
-        }
-        return undefined;
-    }
-}
-new RenderTextureSerializer();
-export class UriSerializer extends TypeSerializer {
-    constructor() {
-        super([URL]);
-    }
-    onSerialize(_data, _context) {
-        return null;
-    }
-    onDeserialize(data, _context) {
-        if (typeof data === "string" && data.length > 0) {
-            return resolveUrl(_context.gltfId, data);
-        }
-        return undefined;
-    }
-}
-new UriSerializer();
+import * as THREE from "three";
+import { RGBAColor } from "../engine-components/js-extensions/RGBAColor.js";
+import { TypeSerializer } from "./engine_serialization_core.js";
+import { Behaviour, Component, GameObject } from "../engine-components/Component.js";
+import { debugExtension } from "./engine_default_parameters.js";
+import { CallInfo, EventList } from "../engine-components/EventList.js";
+import { Color, CompressedTexture, Object3D, Texture, WebGLRenderTarget } from "three";
+import { RenderTexture } from "./engine_texture.js";
+import { isDevEnvironment, showBalloonWarning } from "../engine/debug/index.js";
+import { resolveUrl } from "./engine_utils.js";
+import { AssetReference } from "./engine_addressables.js";
+// export class SourcePath {
+//     src?:string
+// };
+// class SourcePathSerializer extends TypeSerializer{
+//     constructor(){
+//         super(SourcePath);
+//     }
+//     onDeserialize(data: any, _context: SerializationContext) {
+//         if(data.src && typeof data.src === "string"){
+//             return data.src;
+//         }
+//     }
+//     onSerialize(_data: any, _context: SerializationContext) {
+//     }
+// }
+// new SourcePathSerializer();
+class ColorSerializer extends TypeSerializer {
+    constructor() {
+        super([Color, RGBAColor]);
+    }
+    onDeserialize(data) {
+        if (data === undefined || data === null)
+            return;
+        if (data.a !== undefined) {
+            return new RGBAColor(data.r, data.g, data.b, data.a);
+        }
+        else if (data.alpha !== undefined) {
+            return new RGBAColor(data.r, data.g, data.b, data.alpha);
+        }
+        return new THREE.Color(data.r, data.g, data.b);
+    }
+    onSerialize(data) {
+        if (data === undefined || data === null)
+            return;
+        if (data.a !== undefined)
+            return { r: data.r, g: data.g, b: data.b, a: data.a };
+        else
+            return { r: data.r, g: data.g, b: data.b };
+    }
+}
+export const colorSerializer = new ColorSerializer();
+class ObjectSerializer extends TypeSerializer {
+    constructor() {
+        super(Object3D);
+    }
+    onSerialize(data, context) {
+        if (context.objectToNode !== undefined && data.uuid) {
+            const node = context.objectToNode[data.uuid];
+            if (debugExtension)
+                console.log(node, data.name, data.uuid);
+            return { node: node };
+        }
+        return undefined;
+    }
+    onDeserialize(data, context) {
+        if (typeof data === "string") {
+            if (data.endsWith(".glb") || data.endsWith(".gltf")) {
+                // If the @serializable([Object3D, AssetReference]) looks like this we don't need to warn here. This is the case e.g. with SyncedCamera referencing a scene
+                if (context.serializable instanceof Array) {
+                    if (context.serializable.includes(AssetReference))
+                        return undefined;
+                }
+                if (isDevEnvironment())
+                    showBalloonWarning("Detected wrong usage of @serializable with Object3D or GameObject. Instead you should use AssetReference here! Please see the console for details.");
+                const scriptname = context.target?.constructor?.name;
+                console.warn(`Wrong usage of @serializable detected in your script \"${scriptname}\"\n\nIt looks like you used @serializable(Object3D) or @serializable(GameObject) for a prefab or scene reference which is exported to a separate glTF file.\n\nTo fix this please change your code to:\n\n@serializable(AssetReference)\n${context.path}! : AssetReference;\n\0`);
+            }
+            // ACTUALLY: this is already handled by the extension_utils where we resolve json pointers recursively
+            // if(data.startsWith("/nodes/")){
+            //     const node = parseInt(data.substring("/nodes/".length));
+            //     if (context.nodeToObject) {
+            //         const res = context.nodeToObject[node];
+            //         if (debugExtension)
+            //             console.log("Deserialized object reference?", data, res, context?.nodeToObject);
+            //         if (!res) console.warn("Did not find node: " + data, context.nodeToObject, context.object);
+            //         return res;
+            //     }
+            // }
+            return undefined;
+        }
+        if (data) {
+            if (data.node !== undefined && context.nodeToObject) {
+                const res = context.nodeToObject[data.node];
+                if (debugExtension)
+                    console.log("Deserialized object reference?", data, res, context?.nodeToObject);
+                if (!res)
+                    console.warn("Did not find node: " + data.node, context.nodeToObject, context.object);
+                return res;
+            }
+            else if (data.guid) {
+                if (!context.context) {
+                    console.error("Missing context");
+                    return undefined;
+                }
+                // it is possible that the object is not yet loaded 
+                // e.g. if we have a scene with multiple gltf files and the first gltf references something in the second gltf
+                // we need a way to wait for all components to be created before we can resolve those references
+                // independent of order of loading
+                let res = undefined;
+                // first try to search in the current gltf scene (if any)
+                const gltfScene = context.gltf?.scene;
+                if (gltfScene) {
+                    res = GameObject.findByGuid(data.guid, gltfScene);
+                }
+                // if not found, search in the whole scene
+                if (!res) {
+                    res = GameObject.findByGuid(data.guid, context.context.scene);
+                }
+                if (!res) {
+                    if (isDevEnvironment() || debugExtension)
+                        console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
+                    data["could_not_resolve"] = true;
+                }
+                else if (debugExtension)
+                    console.log("Deserialized object reference?", data, res, context?.nodeToObject);
+                return res;
+            }
+        }
+        return undefined;
+    }
+}
+export const objectSerializer = new ObjectSerializer();
+class ComponentSerializer extends TypeSerializer {
+    constructor() {
+        super([Component, Behaviour]);
+    }
+    onSerialize(data, _context) {
+        if (data?.guid) {
+            return { guid: data.guid };
+        }
+        return undefined;
+    }
+    onDeserialize(data, context) {
+        if (data?.guid) {
+            // TODO: need to serialize some identifier for referenced components as well, maybe just guid?
+            // because here the components are created but dont have their former guid assigned
+            // and will later in the stack just get a newly generated guid
+            if (debugExtension)
+                console.log(data.guid, context.root, context.object, context.target);
+            // first search within the gltf (e.g. necessary when using AssetReference and loading a gltf without adding it to the scene)
+            // if we would search JUST the scene those references would NEVER be resolved
+            let res = this.findObjectForGuid(data.guid, context.root);
+            if (res) {
+                return res;
+            }
+            if (context.context) {
+                // if not found within the gltf use the provided context scene
+                // to find references outside
+                res = this.findObjectForGuid(data.guid, context.context?.scene);
+                if (res)
+                    return res;
+            }
+            if (isDevEnvironment() || debugExtension)
+                console.warn("Could not resolve component reference", context.path, data, context.target);
+            data["could_not_resolve"] = true;
+            return undefined;
+        }
+        // if (data?.node !== undefined && context.nodeToObject) {
+        //     return context.nodeToObject[data.node];
+        // }
+        return undefined;
+    }
+    findObjectForGuid(guid, root) {
+        // recursively search root
+        // need to check the root object too
+        if (root["guid"] === guid)
+            return root;
+        const res = GameObject.foreachComponent(root, (c) => {
+            if (c.guid === guid)
+                return c;
+            return undefined;
+        }, false);
+        if (res !== undefined)
+            return res;
+        // if not found, search in children
+        for (let i = 0; i < root.children.length; i++) {
+            const child = root.children[i];
+            const res = this.findObjectForGuid(guid, child);
+            if (res)
+                return res;
+        }
+    }
+}
+export const componentSerializer = new ComponentSerializer();
+const $eventListDebugInfo = Symbol("eventListDebugInfo");
+class EventListSerializer extends TypeSerializer {
+    constructor() {
+        super([EventList]);
+    }
+    onSerialize(_data, _context) {
+        console.log("TODO: SERIALIZE EVENT");
+        return undefined;
+    }
+    onDeserialize(data, context) {
+        // TODO: check that we dont accidentally deserialize methods to EventList objects. This is here to make is easy for react-three-fiber to just add props as { () => { } } 
+        if (typeof data === "function") {
+            const evtList = new EventList([new CallInfo(data, true)]);
+            return evtList;
+        }
+        else if (data && data.type === "EventList") {
+            if (debugExtension)
+                console.log("DESERIALIZE EVENT", data);
+            const fns = new Array();
+            if (data.calls && Array.isArray(data.calls)) {
+                for (const call of data.calls) {
+                    if (debugExtension)
+                        console.log(call);
+                    let target = componentSerializer.findObjectForGuid(call.target, context.root);
+                    // if the object is not found in the current glb try find it in the whole scene
+                    if (!target && context.context?.scene) {
+                        target = componentSerializer.findObjectForGuid(call.target, context.context?.scene);
+                    }
+                    const hasMethod = call.method?.length > 0;
+                    if (target && hasMethod) {
+                        const printWarningMethodNotFound = () => {
+                            const uppercaseMethodName = call.method[0].toUpperCase() + call.method.slice(1);
+                            if (typeof target[uppercaseMethodName] === "function") {
+                                console.warn(`EventList method:\nCould not find method ${call.method} on object ${target.name}. Please rename ${call.method} to ${uppercaseMethodName}?\n`, target[uppercaseMethodName], "\n in script: ", target);
+                                showBalloonWarning("EventList methods must start with lowercase letter, see console for details");
+                                return;
+                            }
+                            else {
+                                console.warn(`EventList method:\nCould not find method ${call.method} on object ${target.name}`, target, typeof target[call.method]);
+                            }
+                        };
+                        const method = target[call.method];
+                        if (typeof method !== "function") {
+                            let foundMethod = false;
+                            let currentPrototype = target;
+                            // test if the target method is actually a property setter
+                            while (currentPrototype) {
+                                const desc = Object.getOwnPropertyDescriptor(currentPrototype, call.method);
+                                if (desc && (desc.writable === true || desc.set)) {
+                                    foundMethod = true;
+                                    break;
+                                }
+                                currentPrototype = Object.getPrototypeOf(currentPrototype);
+                            }
+                            if (!foundMethod && (isDevEnvironment() || debugExtension))
+                                printWarningMethodNotFound();
+                        }
+                    }
+                    function deserializeArgument(arg) {
+                        if (typeof arg === "object") {
+                            // Try to deserialize the call argument to either a object or a component reference
+                            let argRes = objectSerializer.onDeserialize(arg, context);
+                            if (!argRes)
+                                argRes = componentSerializer.onDeserialize(arg, context);
+                            if (argRes)
+                                return argRes;
+                        }
+                        return arg;
+                    }
+                    let args = call.argument;
+                    if (args !== undefined) {
+                        args = deserializeArgument(args);
+                    }
+                    else if (call.arguments !== undefined) {
+                        args = call.arguments.map(deserializeArgument);
+                    }
+                    // This is the final method we pass to the call info (or undefined if the method couldnt be resolved)
+                    const eventMethod = hasMethod ? this.createEventMethod(target, call.method, args) : undefined;
+                    const fn = new CallInfo(eventMethod, call.enabled);
+                    if (!fn.method)
+                        fn[$eventListDebugInfo] = context.object?.name;
+                    if (!target || !fn.method) {
+                        const debugInfo = context.object ? "Current object: " + context.object.name + ", " + context.object["guid"] : null;
+                        if (!target)
+                            console.warn("EventList is missing target - will be ignored", call.target, debugInfo, data);
+                        else
+                            console.warn("EventList method not found: \"" + call.method + "\" on", target);
+                    }
+                    else
+                        fns.push(fn);
+                }
+            }
+            const evt = new EventList(fns);
+            if (debugExtension)
+                console.log(evt);
+            const eventListOwner = context.target;
+            if (eventListOwner !== undefined && context.path !== undefined) {
+                evt.setEventTarget(context.path, eventListOwner);
+            }
+            return evt;
+        }
+        return undefined;
+    }
+    createEventMethod(target, methodName, args) {
+        return (...forwardedArgs) => {
+            const method = target[methodName];
+            if (typeof method === "function") {
+                if (args !== undefined) {
+                    // we now have support for creating event methods with multiple arguments
+                    // an argument can not be an array right now - so if we receive an array we assume it's the array of arguments that we want to call the method with
+                    // this means ["test", true] will invoke the method like this: myFunction("test", true) 
+                    if (Array.isArray(args))
+                        method?.call(target, ...args);
+                    // in any other case (when we just have one argument) we just call the method with the argument
+                    // we an not use ...args by default becaue that would break string arguments (it would then just use the first character)
+                    else
+                        method?.call(target, args);
+                }
+                else // support invoking EventList with any number of arguments (if none were declared in unity)
+                    method?.call(target, ...forwardedArgs);
+            }
+            else // the target "method" can be a property too
+             {
+                target[methodName] = args;
+            }
+        };
+    }
+}
+export const eventListSerializer = new EventListSerializer();
+export class RenderTextureSerializer extends TypeSerializer {
+    constructor() {
+        super([RenderTexture, WebGLRenderTarget]);
+    }
+    onSerialize(_data, _context) {
+    }
+    onDeserialize(data, context) {
+        if (data instanceof Texture && context.type === RenderTexture) {
+            const tex = data;
+            const rt = new RenderTexture(tex.image.width, tex.image.height, {
+                colorSpace: THREE.LinearSRGBColorSpace,
+            });
+            rt.texture = tex;
+            tex.isRenderTargetTexture = true;
+            tex.flipY = true;
+            tex.offset.y = 1;
+            tex.repeat.y = -1;
+            tex.needsUpdate = true;
+            if (tex instanceof CompressedTexture) {
+                //@ts-ignore
+                tex["isCompressedTexture"] = false;
+                //@ts-ignore
+                tex.format = THREE.RGBAFormat;
+            }
+            return rt;
+        }
+        return undefined;
+    }
+}
+new RenderTextureSerializer();
+export class UriSerializer extends TypeSerializer {
+    constructor() {
+        super([URL]);
+    }
+    onSerialize(_data, _context) {
+        return null;
+    }
+    onDeserialize(data, _context) {
+        if (typeof data === "string" && data.length > 0) {
+            return resolveUrl(_context.gltfId, data);
+        }
+        return undefined;
+    }
+}
+new UriSerializer();
 //# sourceMappingURL=engine_serialization_builtin_serializer.js.map