@zephyr3d/scene 0.9.24 → 0.9.26

package/dist/utility/serialization/manager.js

@@ -1,18 +1,19 @@
-import { ASSERT, DRef, randomUUID } from '@zephyr3d/base';
+import { DWeakRef, ASSERT, DRef, randomUUID } from '@zephyr3d/base';
 import { getAABBClass } from './scene/misc.js';
 import { getSceneNodeClass, getGraphNodeClass } from './scene/node.js';
 import { getBatchGroupClass } from './scene/batch.js';
 import { getCameraClass, getPerspectiveCameraClass, getOrthoCameraClass } from './scene/camera.js';
 import { getPunctualLightClass, getDirectionalLightClass, getSpotLightClass, getPointLightClass, getRectLightClass } from './scene/light.js';
-import { getSubsurfaceProfileClass, getMeshMaterialClass, getPBRBluePrintMaterialClass, getSpriteBlueprintMaterialClass, getUnlitMaterialClass, getMToonMaterialClass, getLambertMaterialClass, getBlinnMaterialClass, getSkinMaterialClass, getPBRMetallicRoughnessMaterialClass, getPBRSpecularGlossinessMaterialClass, getParticleMaterialClass, getSpriteMaterialClass, getStandardSpriteMaterialClass } from './scene/material.js';
+import { getSubsurfaceProfileClass, getMeshMaterialClass, getPBRBluePrintMaterialClass, getPBRBluePrintMaterialInstanceClass, getSpriteBlueprintMaterialClass, getUnlitMaterialClass, getMToonMaterialClass, getLambertMaterialClass, getBlinnMaterialClass, getHairMaterialClass, getSkinMaterialClass, getEyeMaterialClass, getPBRMetallicRoughnessMaterialClass, getPBRSpecularGlossinessMaterialClass, getParticleMaterialClass, getSpriteMaterialClass, getStandardSpriteMaterialClass } from './scene/material.js';
 import { getMeshClass } from './scene/mesh.js';
 import { getParticleNodeClass } from './scene/particle.js';
 import { getBoxShapeClass, getBoxFrameShapeClass, getCapsuleShapeClass, getSphereShapeClass, getTorusShapeClass, getCylinderShapeClass, getPlaneShapeClass, getTetrahedronShapeClass } from './scene/primitive.js';
 import { getSceneClass } from './scene/scene.js';
 import { getTerrainClass } from './scene/terrain.js';
 import { getWaterClass, getFFTWaveGeneratorClass, getFBMWaveGeneratorClass } from './scene/water.js';
+import { getHairNodeClass } from './scene/hair.js';
 import { getTextSpriteClass, getMSDFTextSpriteClass, getMSDFTextClass } from './scene/text.js';
-import { getInterpolatorClass, getInterpolatorScalarClass, getSkeletonClass, getSkeletonRigClass, getSkinBindingClass, getJointDynamicsModifierClass, getAnimationClass, getPropTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getNodeEulerRotationTrackClass, getFixedGeometryCacheTrackClass, getPCAGeometryCacheTrackClass, getMorphTrackClass, getMorphTargetGroupTrackClass } from './scene/animation.js';
+import { getInterpolatorClass, getInterpolatorScalarClass, getSkeletonClass, getSkeletonRigClass, getSkinBindingClass, getJointDynamicsModifierClass, getSpringModifierClass, getAnimationClass, getPropTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getNodeEulerRotationTrackClass, getFixedGeometryCacheTrackClass, getPCAGeometryCacheTrackClass, getMorphTrackClass, getMorphTargetGroupTrackClass } from './scene/animation.js';
 import '../../scene/scene.js';
 import '../../values.js';
 import '../../render/render_queue.js';
@@ -25,18 +26,22 @@ import '../../material/unlit.js';
 import '../../material/particle.js';
 import '../../material/subsurfaceprofile.js';
 import '../../material/skin.js';
+import '../../material/eye.js';
+import { Material } from '../../material/material.js';
 import '../../material/meshmaterial.js';
+import '../../material/hair.js';
+import '../../material/hairstrand.js';
 import '../../material/grassmaterial.js';
 import '../../material/terrain-cm.js';
 import '../../material/pbrmr.js';
 import '../../material/pbrsg.js';
 import '../../material/mtoon.js';
-import '../../material/pbrblueprint.js';
+import { PBRBluePrintMaterial } from '../../material/pbrblueprint.js';
 import '../../material/sprite.js';
 import '../../material/sprite_std.js';
 import { PBRBlockNode, SpriteBlockNode, VertexBlockNode } from '../blueprint/material/pbr.js';
 import { ConstantScalarNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstantBooleanNode, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node } from '../blueprint/common/constants.js';
-import { ConstantTexture2DNode, ConstantTexture2DArrayNode, ConstantTextureCubeNode, PannerNode, TextureSampleNode } from '../blueprint/material/texture.js';
+import { ConstantTexture2DNode, ConstantTexture2DArrayNode, ConstantTextureCubeNode, ChannelSDFMaskNode, MorphBlurNode, PannerNode, TexturePropertyNode, TextureSampleNode } from '../blueprint/material/texture.js';
 import { MakeVectorNode, SwizzleNode, EqualNode, NotEqualNode, LogicallyAndNode, LogicallyOrNode, CompComparisonNode, AnyConditionNode, AllConditionNode, SelectionNode, Degrees2RadiansNode, Radians2DegreesNode, SinNode, CosNode, TanNode, ArcSinNode, ArcCosNode, ArcTanNode, ArcTan2Node, SinHNode, CosHNode, TanHNode, ArcsineHNode, ArccosineHNode, ArctangentHNode, ExpNode, Exp2Node, LogNode, Log2Node, SqrtNode, InvSqrtNode, AbsNode, SignNode, FloorNode, CeilNode, FractNode, DDXNode, DDYNode, FWidthNode, CompAddNode, CompSubNode, CompMulNode, CompDivNode, ModNode, MinNode, MaxNode, PowNode, StepNode, SmoothStepNode, FmaNode, ClampNode, SaturateNode, MixNode, NormalizeNode, TransformNode, RotateAboutAxisNode, FaceForwardNode, ReflectNode, RefractNode, LengthNode, DistanceNode, DotProductNode, CrossProductNode, Hash1Node, Hash2Node, Hash3Node, SimplexNoise2DNode, PerlinNoise2DNode } from '../blueprint/common/math.js';
 import { VertexColorNode, VertexUVNode, VertexPositionNode, PixelWorldPositionNode, VertexNormalNode, PixelNormalNode, VertexTangentNode, VertexBinormalNode, ViewMatrixNode, ProjectionMatrixNode, ViewProjMatrixNode, InvProjMatrixNode, InvViewProjMatrixNode, BillboardMatrixNode, CameraPositionNode, CameraVectorNode, CameraNearFarNode, SkyEnvTextureNode, ElapsedTimeNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResolveVertexNormalNode, VertexOutputNode, VertexIndexNode, InstanceIndexNode } from '../blueprint/material/inputs.js';
 import { FunctionInputNode, FunctionOutputNode, FunctionCallNode } from '../blueprint/material/func.js';
@@ -55,6 +60,7 @@ import '../../scene/meshdrawable.js';
 import '../../scene/basesprite.js';
 import '../../material/msdf_text.js';
 import '../../scene/water.js';
+import '../../scene/hair.js';
 import '../../scene/particlesys.js';
 import '../../scene/batchgroup.js';
 import '../../scene/terrain-cm/terrain-cm.js';
@@ -154,6 +160,8 @@ const defaultValues = {
     _assetManager;
     _editorMode;
     _allocated;
+    _materialsByAssetId;
+    _prefabContentCache;
     /**
    * Create a ResourceManager bound to a virtual file system.
    *
@@ -162,6 +170,8 @@ const defaultValues = {
         this._vfs = vfs;
         this._editorMode = editorMode;
         this._allocated = new WeakMap();
+        this._materialsByAssetId = new Map();
+        this._prefabContentCache = null;
         this._assetManager = new AssetManager(this);
         this._propMap = {};
         this._propNameMap = new Map();
@@ -181,6 +191,7 @@ const defaultValues = {
             getSkeletonRigClass(),
             getSkinBindingClass(),
             getJointDynamicsModifierClass(),
+            getSpringModifierClass(),
             getAnimationClass(this),
             getPropTrackClass(this),
             getNodeRotationTrackClass(),
@@ -193,12 +204,13 @@ const defaultValues = {
             getMorphTargetGroupTrackClass(),
             getSceneNodeClass(this),
             getGraphNodeClass(),
-            getMeshClass(),
+            getMeshClass(this),
             getSpriteClass(),
             getTextSpriteClass(),
             getMSDFTextSpriteClass(),
             getMSDFTextClass(),
             getWaterClass(this),
+            getHairNodeClass(),
             getTerrainClass(this),
             getFFTWaveGeneratorClass(),
             getFBMWaveGeneratorClass(),
@@ -216,12 +228,15 @@ const defaultValues = {
             getSubsurfaceProfileClass(),
             ...getMeshMaterialClass(),
             ...getPBRBluePrintMaterialClass(),
+            ...getPBRBluePrintMaterialInstanceClass(),
             ...getSpriteBlueprintMaterialClass(),
             ...getUnlitMaterialClass(this),
             ...getMToonMaterialClass(this),
             ...getLambertMaterialClass(this),
             ...getBlinnMaterialClass(this),
+            ...getHairMaterialClass(this),
             ...getSkinMaterialClass(this),
+            ...getEyeMaterialClass(this),
             ...getPBRMetallicRoughnessMaterialClass(this),
             ...getPBRSpecularGlossinessMaterialClass(this),
             ...getParticleMaterialClass(this),
@@ -342,11 +357,14 @@ const defaultValues = {
             FunctionInputNode.getSerializationCls(),
             FunctionOutputNode.getSerializationCls(),
             FunctionCallNode.getSerializationCls(this),
+            ChannelSDFMaskNode.getSerializationCls(),
+            MorphBlurNode.getSerializationCls(),
             PannerNode.getSerializationCls(),
-            TextureSampleNode.getSerializationCls(),
             VertexOutputNode.getSerializationCls(),
             VertexIndexNode.getSerializationCls(),
-            InstanceIndexNode.getSerializationCls()
+            InstanceIndexNode.getSerializationCls(),
+            TexturePropertyNode.getSerializationCls(),
+            TextureSampleNode.getSerializationCls()
         ].map((val)=>[
                 val.ctor,
                 val
@@ -354,6 +372,7 @@ const defaultValues = {
         for (const k of this._classMap){
             this.registerProps(k[1]);
         }
+        this._vfs.on('changed', this.handleVFSChanged, this);
     }
     /**
    * The virtual file system used by this manager.
@@ -364,7 +383,12 @@ const defaultValues = {
         return this._vfs;
     }
     set VFS(vfs) {
-        this._vfs = vfs;
+        if (vfs !== this._vfs) {
+            this._vfs?.off('changed', this.handleVFSChanged, this);
+            this._vfs = vfs;
+            this.clearCache();
+            this._vfs?.on('changed', this.handleVFSChanged, this);
+        }
     }
     /**
    * Wethether editor mode is enabled
@@ -526,13 +550,224 @@ const defaultValues = {
    *
    */ setAssetId(asset, id) {
         if (asset) {
+            const material = asset instanceof Material ? asset : null;
+            const prevId = material ? this.getAssetId(material) : null;
+            if (material && prevId && prevId !== id) {
+                this.unregisterMaterialReference(prevId, material);
+            }
             if (id) {
                 this._allocated.set(asset, id);
+                if (material) {
+                    this.registerMaterialReference(id, material);
+                }
             } else {
                 this._allocated.delete(asset);
             }
         }
     }
+    getMaterialRefsByAssetId(id) {
+        return this._materialsByAssetId.get(id) ?? null;
+    }
+    /** @internal */ getTrackedMaterialAssetIds() {
+        const ids = [];
+        for (const [id, refs] of this._materialsByAssetId){
+            for (const ref of [
+                ...refs
+            ]){
+                const material = ref.get();
+                if (!material || material.disposed) {
+                    ref.dispose();
+                    refs.delete(ref);
+                }
+            }
+            if (refs.size === 0) {
+                this._materialsByAssetId.delete(id);
+            } else {
+                ids.push(id);
+            }
+        }
+        return ids;
+    }
+    syncMaterialReferences(source) {
+        const id = this.getAssetId(source);
+        if (!id) {
+            return;
+        }
+        const refs = this._materialsByAssetId.get(id);
+        if (!refs) {
+            return;
+        }
+        for (const ref of [
+            ...refs
+        ]){
+            const material = ref.get();
+            if (!material || material.disposed) {
+                ref.dispose();
+                refs.delete(ref);
+            } else if (material !== source && material.constructor === source.constructor) {
+                const instance = material;
+                if (instance.$isInstance && instance.getInstancedUniforms) {
+                    const coreMaterial = instance.coreMaterial;
+                    if (coreMaterial && coreMaterial !== source && coreMaterial.constructor === source.constructor) {
+                        coreMaterial.copyFrom(source);
+                    }
+                    for (const { prop } of instance.getInstancedUniforms()){
+                        instance[prop] = source[prop];
+                    }
+                } else {
+                    material.copyFrom(source);
+                }
+            }
+        }
+        if (refs.size === 0) {
+            this._materialsByAssetId.delete(id);
+        }
+    }
+    syncMaterialUniformReferences(source) {
+        const id = this.getAssetId(source);
+        if (!id) {
+            return;
+        }
+        const refs = this._materialsByAssetId.get(id);
+        if (!refs) {
+            return;
+        }
+        const synced = new Set();
+        for (const ref of [
+            ...refs
+        ]){
+            const material = ref.get();
+            if (!material || material.disposed) {
+                ref.dispose();
+                refs.delete(ref);
+                continue;
+            }
+            const runtimeInstance = material;
+            const target = runtimeInstance.$isInstance ? runtimeInstance.coreMaterial : material;
+            if (!target || target === source || synced.has(target) || !(target instanceof PBRBluePrintMaterial) || target.constructor !== source.constructor) {
+                continue;
+            }
+            synced.add(target);
+            const targetWithOverrides = target;
+            if (targetWithOverrides.setOverrides) {
+                targetWithOverrides.setOverrides(source.uniformValues, source.uniformTextures);
+            } else {
+                target.uniformValues = source.uniformValues;
+                target.uniformTextures = source.uniformTextures;
+            }
+            target.uniformChanged();
+        }
+        if (refs.size === 0) {
+            this._materialsByAssetId.delete(id);
+        }
+    }
+    async syncMaterialPropertyReferences(source, prop) {
+        const id = this.getAssetId(source);
+        const refs = id ? this._materialsByAssetId.get(id) : null;
+        if (!refs || !prop.get || !prop.set) {
+            return;
+        }
+        const sourceValue = {
+            num: [
+                0,
+                0,
+                0,
+                0
+            ],
+            str: [
+                ''
+            ],
+            bool: [
+                false
+            ],
+            object: [
+                null
+            ]
+        };
+        prop.get.call(source, sourceValue);
+        const tasks = [];
+        for (const ref of [
+            ...refs
+        ]){
+            const material = ref.get();
+            if (!material || material.disposed) {
+                ref.dispose();
+                refs.delete(ref);
+                continue;
+            }
+            if (material === source || material.constructor !== source.constructor) {
+                continue;
+            }
+            const instance = material;
+            const isInstanceUniform = !!instance.$isInstance && !!instance.getInstancedUniforms?.().some((uniform)=>uniform.name === prop.name);
+            const target = instance.$isInstance && !isInstanceUniform ? instance.coreMaterial : material;
+            if (!target || target === source || target.constructor !== source.constructor) {
+                continue;
+            }
+            const value = {
+                num: [
+                    ...sourceValue.num
+                ],
+                str: [
+                    ...sourceValue.str
+                ],
+                bool: [
+                    ...sourceValue.bool
+                ],
+                object: [
+                    ...sourceValue.object
+                ]
+            };
+            tasks.push(Promise.resolve(prop.set.call(target, value)));
+        }
+        await Promise.all(tasks);
+        if (refs.size === 0) {
+            this._materialsByAssetId.delete(id);
+        }
+    }
+    trackMaterialReference(material, id) {
+        if (!material || !id) {
+            return;
+        }
+        this.setAssetId(material, id);
+    }
+    registerMaterialReference(id, material) {
+        let refs = this._materialsByAssetId.get(id);
+        if (!refs) {
+            refs = new Set();
+            this._materialsByAssetId.set(id, refs);
+        }
+        for (const ref of [
+            ...refs
+        ]){
+            const obj = ref.get();
+            if (!obj) {
+                ref.dispose();
+                refs.delete(ref);
+            } else if (obj === material) {
+                return;
+            }
+        }
+        refs.add(new DWeakRef(material));
+    }
+    unregisterMaterialReference(id, material) {
+        const refs = this._materialsByAssetId.get(id);
+        if (!refs) {
+            return;
+        }
+        for (const ref of [
+            ...refs
+        ]){
+            const obj = ref.get();
+            if (!obj || obj === material) {
+                ref.dispose();
+                refs.delete(ref);
+            }
+        }
+        if (refs.size === 0) {
+            this._materialsByAssetId.delete(id);
+        }
+    }
     /**
    * Fetch a binary asset by ID via the asset manager.
    *
@@ -540,13 +775,31 @@ const defaultValues = {
    * - Associates the returned data with the given ID for future reverse lookup.
    * - The ID is typically a VFS path or locator.
    *
-   * @param id - Asset identifier or path.
+   * @param path - VFS path.
+   * @param options - Optional fetch options
    *
    * @returns A Promise that resolves to the binary content, or `null` if not found.
-   */ async fetchBinary(id) {
-        const data = await this._assetManager.fetchBinaryData(id);
+   */ async fetchBinary(path, options) {
+        const data = await this._assetManager.fetchBinaryData(path, null, null, options);
         if (data) {
-            this._allocated.set(data, id);
+            this._allocated.set(data, path);
+        }
+        return data;
+    }
+    /**
+   * Fetch a JSON resource via VFS.
+   *
+   * - Parses as JSON after text load.
+   * - Cached per resolved URL. Post-process is applied only on the first load for a given cache key.
+   *
+   * @param path - Resource URL or VFS path.
+   * @param options - Optional fetch options
+   *
+   * @returns A promise that resolves to the loaded JSON value.
+   */ async fetchJsonData(path, options) {
+        const data = await this._assetManager.fetchJsonData(path, null, null, options);
+        if (data) {
+            this._allocated.set(data, path);
         }
         return data;
     }
@@ -730,11 +983,18 @@ const defaultValues = {
    */ async fetchMaterial(id, options) {
         const material = await this._assetManager.fetchMaterial(id, options);
         if (material) {
-            this._allocated.set(material, id);
+            this.setAssetId(material, id);
         }
         return material;
     }
     /**
+   * Remove one material from the asset cache.
+   *
+   * @param id - Material identifier or path.
+   */ invalidateMaterial(id) {
+        this._assetManager.invalidateMaterial(id);
+    }
+    /**
    * Reload specific blue print materials
    *
    * @param filter - Determine whether a blue print material should reload.
@@ -792,16 +1052,25 @@ const defaultValues = {
    * @param path - Path to the prefab JSON file in VFS.
    * @returns A Promise resolving to the prefab json object, or `null` on failure.
    */ async loadPrefabContent(path) {
-        try {
-            const content = await this._vfs.readFile(path, {
-                encoding: 'utf8'
-            });
-            const json = JSON.parse(content);
-            return json;
-        } catch (err) {
-            console.error(`Failed to load prefab from ${path}:`, err);
-            return null;
+        const normalizedPath = this._vfs.normalizePath(path);
+        const cached = this._prefabContentCache?.get(normalizedPath);
+        if (cached) {
+            return cached;
         }
+        const loadTask = (async ()=>{
+            try {
+                const content = await this._vfs.readFile(normalizedPath, {
+                    encoding: 'utf8'
+                });
+                const json = JSON.parse(content);
+                return json;
+            } catch (err) {
+                console.error(`Failed to load prefab from ${normalizedPath}:`, err);
+                return null;
+            }
+        })();
+        this._prefabContentCache?.set(normalizedPath, loadTask);
+        return loadTask;
     }
     /**
    * Instantiate a prefab from a JSON file via VFS.
@@ -854,12 +1123,20 @@ const defaultValues = {
    * @param filename - Destination path in VFS.
    */ async saveScene(scene, filename) {
         const asyncTasks = [];
-        const content = await this.serializeObject(scene, null, asyncTasks);
-        await Promise.all(asyncTasks);
-        await this._vfs.writeFile(filename, JSON.stringify(content, null, 2), {
-            encoding: 'utf8',
-            create: true
-        });
+        const previousPrefabContentCache = this._prefabContentCache;
+        if (!previousPrefabContentCache) {
+            this._prefabContentCache = new Map();
+        }
+        try {
+            const content = await this.serializeObject(scene, null, asyncTasks);
+            await Promise.all(asyncTasks);
+            await this._vfs.writeFile(filename, JSON.stringify(content, null, 2), {
+                encoding: 'utf8',
+                create: true
+            });
+        } finally{
+            this._prefabContentCache = previousPrefabContentCache;
+        }
     }
     rebuildGraphStructure(nodes, links) {
         const gs = {
@@ -990,8 +1267,47 @@ const defaultValues = {
    * Useful when reloading content or changing VFS mounts.
    */ clearCache() {
         this._allocated = new WeakMap();
+        this._prefabContentCache?.clear();
         this._assetManager.clearCache();
     }
+    handleVFSChanged(type, path, itemType, oldPath) {
+        if (type === 'moved') {
+            if (!oldPath) {
+                this._prefabContentCache?.clear();
+                this._assetManager.clearCache();
+                return;
+            }
+            const normalizedOldPath = this._vfs.normalizePath(oldPath);
+            const normalizedPath = this._vfs.normalizePath(path);
+            const recursive = itemType === 'directory';
+            this._assetManager.invalidateAsset(normalizedOldPath, recursive);
+            this._assetManager.invalidateAsset(normalizedPath, recursive);
+            this.invalidatePrefabContent(normalizedOldPath, recursive);
+            this.invalidatePrefabContent(normalizedPath, recursive);
+            return;
+        }
+        const normalizedPath = this._vfs.normalizePath(path);
+        const recursive = itemType === 'directory';
+        this._assetManager.invalidateAsset(normalizedPath, recursive);
+        this.invalidatePrefabContent(normalizedPath, recursive);
+    }
+    invalidatePrefabContent(path, recursive) {
+        if (!this._prefabContentCache) {
+            return;
+        }
+        if (recursive) {
+            const prefix = path.endsWith('/') ? path : `${path}/`;
+            for (const key of [
+                ...this._prefabContentCache.keys()
+            ]){
+                if (key === path || key.startsWith(prefix)) {
+                    this._prefabContentCache.delete(key);
+                }
+            }
+        } else {
+            this._prefabContentCache.delete(path);
+        }
+    }
     static _pathPattern = /^([^\][]+)(?:\[(\d+)\])?$/;
     static parsePropertyPath(str) {
         const match = str.match(this._pathPattern);
@@ -1111,81 +1427,96 @@ const defaultValues = {
                 continue;
             }
             const k = prop.name;
-            const v = json[k] ?? this.getDefaultValue(obj, prop);
-            const tmpVal = {
-                num: [
-                    0,
-                    0,
-                    0,
-                    0
-                ],
-                str: [
-                    ''
-                ],
-                bool: [
-                    false
-                ],
-                object: [
-                    null
-                ]
-            };
-            switch(prop.type){
-                case 'object':
-                    if (typeof v === 'string' && v) {
-                        tmpVal.str[0] = v;
-                    } else {
-                        tmpVal.object[0] = v ? Array.isArray(v) ? v : this.isSerializedObjectEnvelope(v) ? await this.deserializeObject(obj, v) ?? null : v : null;
-                    }
-                    break;
-                case 'object_array':
-                    tmpVal.object = [];
-                    if (Array.isArray(v)) {
-                        for (const p of v){
-                            if (typeof p === 'string' && p) {
-                                tmpVal.str[0] = p;
+            promises.push((async ()=>{
+                try {
+                    const v = json[k] ?? this.getDefaultValue(obj, prop);
+                    const tmpVal = {
+                        num: [
+                            0,
+                            0,
+                            0,
+                            0
+                        ],
+                        str: [
+                            ''
+                        ],
+                        bool: [
+                            false
+                        ],
+                        object: [
+                            null
+                        ]
+                    };
+                    switch(prop.type){
+                        case 'object':
+                            if (typeof v === 'string' && v) {
+                                tmpVal.str[0] = v;
                             } else {
-                                tmpVal.object.push(p ? this.isSerializedObjectEnvelope(p) ? await this.deserializeObject(obj, p) ?? null : p : null);
+                                tmpVal.object[0] = v ? Array.isArray(v) ? v : this.isSerializedObjectEnvelope(v) ? await this.deserializeObject(obj, v) ?? null : v : null;
                             }
-                        }
+                            break;
+                        case 'object_array':
+                            tmpVal.object = [];
+                            if (Array.isArray(v)) {
+                                const values = await Promise.all(v.map(async (p)=>typeof p === 'string' && p ? {
+                                        kind: 'ref',
+                                        ref: p
+                                    } : {
+                                        kind: 'value',
+                                        value: p ? this.isSerializedObjectEnvelope(p) ? await this.deserializeObject(obj, p) ?? null : p : null
+                                    }));
+                                for (const value of values){
+                                    if (value.kind === 'ref') {
+                                        tmpVal.str[0] = value.ref;
+                                    } else {
+                                        tmpVal.object.push(value.value);
+                                    }
+                                }
+                            }
+                            break;
+                        case 'embedded':
+                            if (typeof v === 'string' && v) {
+                                tmpVal.str[0] = v;
+                            }
+                            break;
+                        case 'float':
+                        case 'int':
+                            tmpVal.num[0] = v;
+                            break;
+                        case 'string':
+                            tmpVal.str[0] = v;
+                            break;
+                        case 'bool':
+                            tmpVal.bool[0] = v;
+                            break;
+                        case 'vec2':
+                        case 'int2':
+                            tmpVal.num[0] = v[0];
+                            tmpVal.num[1] = v[1];
+                            break;
+                        case 'vec3':
+                        case 'int3':
+                        case 'rgb':
+                            tmpVal.num[0] = v[0];
+                            tmpVal.num[1] = v[1];
+                            tmpVal.num[2] = v[2];
+                            break;
+                        case 'vec4':
+                        case 'int4':
+                        case 'rgba':
+                            tmpVal.num[0] = v[0];
+                            tmpVal.num[1] = v[1];
+                            tmpVal.num[2] = v[2];
+                            tmpVal.num[3] = v[3];
+                            break;
                     }
-                    break;
-                case 'embedded':
-                    if (typeof v === 'string' && v) {
-                        tmpVal.str[0] = v;
+                    if (prop.set) {
+                        await Promise.resolve(prop.set.call(obj, tmpVal, -1));
                     }
-                    break;
-                case 'float':
-                case 'int':
-                    tmpVal.num[0] = v;
-                    break;
-                case 'string':
-                    tmpVal.str[0] = v;
-                    break;
-                case 'bool':
-                    tmpVal.bool[0] = v;
-                    break;
-                case 'vec2':
-                case 'int2':
-                    tmpVal.num[0] = v[0];
-                    tmpVal.num[1] = v[1];
-                    break;
-                case 'vec3':
-                case 'int3':
-                case 'rgb':
-                    tmpVal.num[0] = v[0];
-                    tmpVal.num[1] = v[1];
-                    tmpVal.num[2] = v[2];
-                    break;
-                case 'vec4':
-                case 'int4':
-                case 'rgba':
-                    tmpVal.num[0] = v[0];
-                    tmpVal.num[1] = v[1];
-                    tmpVal.num[2] = v[2];
-                    tmpVal.num[3] = v[3];
-                    break;
-            }
-            promises.push(Promise.resolve(prop.set.call(obj, tmpVal, -1)));
+                } catch (err) {
+                    console.warn(`Deserialize property failed: ${cls.name}.${k} on ${obj?.constructor?.name ?? 'UnknownObject'}: ${String(err)}`);
+                }
+            })());
         }
         if (promises.length > 0) {
             await Promise.all(promises);