@zephyr3d/scene 0.9.4 → 0.9.5

package/dist/asset/model.js

@@ -1,20 +1,26 @@
-import { Vector3, Quaternion, Matrix4x4, Disposable, DRef } from '@zephyr3d/base';
+import { Vector3, Quaternion, Matrix4x4, Disposable, uint8ArrayToBase64, ASSERT, DRef, Vector4 } from '@zephyr3d/base';
+import { getVertexFormatComponentCount } from '@zephyr3d/device';
 import { Mesh } from '../scene/mesh.js';
-import { SceneNode } from '../scene/scene_node.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { SceneNode, setSceneMeshAssetBinding } from '../scene/scene_node.js';
+import { SkeletonRig, SkinBinding } from '../animation/skeleton.js';
 import { NodeRotationTrack } from '../animation/rotationtrack.js';
 import '../animation/eulerrotationtrack.js';
 import { NodeTranslationTrack } from '../animation/translationtrack.js';
 import { NodeScaleTrack } from '../animation/scaletrack.js';
-import { Skeleton } from '../animation/skeleton.js';
 import { MorphTargetTrack } from '../animation/morphtrack.js';
 import { FixedGeometryCacheTrack } from '../animation/fixed_geometry_cache_track.js';
+import { getDevice } from '../app/api.js';
 import { PCAGeometryCacheTrack } from '../animation/pca_geometry_cache_track.js';
-import '@zephyr3d/device';
 import '../animation/joint_dynamics/collision.js';
 import '../animation/joint_dynamics/solver.js';
-import '../animation/joint_dynamics/joint_dynamics_system.js';
-import { processMorphData } from '../animation/morphtarget.js';
-import { MAX_MORPH_TARGETS } from '../values.js';
+import { createTransformAccess, JointDynamicsSystem } from '../animation/joint_dynamics/joint_dynamics_system.js';
+import { JointDynamicsModifier } from '../animation/joint_dynamics_modifier.js';
+import { MAX_MORPH_TARGETS, MAX_MORPH_ATTRIBUTES } from '../values.js';
+import { Primitive } from '../render/primitive.js';
+import { UnlitMaterial } from '../material/unlit.js';
+import { PBRSpecularGlossinessMaterial } from '../material/pbrsg.js';
+import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
 
 /**
  * Named object interface for model loading
@@ -39,7 +45,6 @@ import { MAX_MORPH_TARGETS } from '../values.js';
     _mesh;
     _skeleton;
     _attachToSkeleton;
-    _meshAttached;
     _matrix;
     _worldMatrix;
     _weights;
@@ -49,8 +54,9 @@ import { MAX_MORPH_TARGETS } from '../values.js';
    * Creates an instance of AssetHierarchyNode
    * @param name - Name of the node
    * @param parent - Parent of the node
-   */ constructor(name, parent){
+   */ constructor(name, model, parent){
         super(name);
+        model.nodes.push(this);
         this._parent = null;
         this._position = Vector3.zero();
         this._rotation = Quaternion.identity();
@@ -59,7 +65,6 @@ import { MAX_MORPH_TARGETS } from '../values.js';
         this._mesh = null;
         this._skeleton = null;
         this._attachToSkeleton = null;
-        this._meshAttached = false;
         this._matrix = null;
         this._weights = null;
         this._worldMatrix = null;
@@ -80,10 +85,9 @@ import { MAX_MORPH_TARGETS } from '../values.js';
     }
     set mesh(data) {
         this._mesh = data;
-        this.setMeshAttached();
     }
     /** instances */ get instances() {
-        return this._instances ?? null;
+        return this._instances;
     }
     /** Default morph target weights */ get weights() {
         return this._weights;
@@ -115,16 +119,22 @@ import { MAX_MORPH_TARGETS } from '../values.js';
     set scaling(val) {
         this._scaling = val;
     }
-    /** true if the node is parent of a mesh node */ get meshAttached() {
-        return this._meshAttached;
-    }
     /** Children of the node */ get children() {
         return this._children;
     }
     /** The skeleton to which the node belongs if this is a joint node */ get skeletonAttached() {
         return this._attachToSkeleton;
     }
-    /** @internal */ computeTransforms(parentTransform) {
+    isParentOf(child) {
+        while(child && child !== this){
+            child = child.parent;
+        }
+        return child === this;
+    }
+    getWorldPosition() {
+        return new Vector3(this.worldMatrix.m03, this.worldMatrix.m13, this.worldMatrix.m23);
+    }
+    computeTransforms(parentTransform) {
         this._matrix = Matrix4x4.scaling(this._scaling).rotateLeft(this._rotation).translateLeft(this._position);
         this._worldMatrix = parentTransform ? Matrix4x4.multiply(parentTransform, this._matrix) : new Matrix4x4(this._matrix);
         for (const child of this._children){
@@ -140,9 +150,6 @@ import { MAX_MORPH_TARGETS } from '../values.js';
         }
         this._children.push(child);
         child._parent = this;
-        if (child.meshAttached) {
-            this.setMeshAttached();
-        }
     }
     /**
    * Removes a child of this node
@@ -165,10 +172,6 @@ import { MAX_MORPH_TARGETS } from '../values.js';
         }
         this._attachToSkeleton.add(skeleton);
     }
-    /** @internal */ setMeshAttached() {
-        this._meshAttached = true;
-        this._parent?.setMeshAttached();
-    }
 }
 /**
  * Skeleton information for model loading
@@ -203,6 +206,18 @@ import { MAX_MORPH_TARGETS } from '../values.js';
             scale: joint.scaling.clone()
         });
     }
+    get root() {
+        if (this.pivot) {
+            return this.pivot;
+        }
+        let root = this.joints[0];
+        for(let i = 1; i < this.joints.length; i++){
+            while(root && !root.isParentOf(this.joints[i])){
+                root = root.parent;
+            }
+        }
+        return root;
+    }
 }
 /**
  * Scene for model loading
@@ -221,41 +236,75 @@ import { MAX_MORPH_TARGETS } from '../values.js';
  * Model information that can be shared by multiple model nodes
  * @public
  */ class SharedModel extends Disposable {
-    /** @internal */ _name;
-    /** @internal */ _skeletons;
     /** @internal */ _nodes;
+    /** @internal */ _skeletons;
     /** @internal */ _animations;
     /** @internal */ _scenes;
     /** @internal */ _activeScene;
+    /** @internal */ _imageList;
+    /** @internal */ _primitiveList;
+    /** @internal */ _materialList;
+    /** @internal */ _springBoneColliders;
+    /** @internal */ _springBoneColliderGroups;
+    /** @internal */ _springBones;
+    /** @internal */ _jointDynamicsColliders;
+    /** @internal */ _jointDynamicsSpringBones;
+    /** @internal */ _morphTargetGroups;
+    /** @internal */ _textureMap;
+    /** @internal */ _primitiveMap;
     /**
    * Creates an instance of SharedModel
-   * @param name - Name of the model
-   */ constructor(name){
+   */ constructor(){
         super();
-        this._name = name || '';
-        this._skeletons = [];
         this._nodes = [];
+        this._skeletons = [];
         this._scenes = [];
         this._animations = [];
+        this._imageList = [];
+        this._primitiveList = [];
+        this._materialList = {};
+        this._springBoneColliders = [];
+        this._springBoneColliderGroups = [];
+        this._springBones = [];
+        this._jointDynamicsColliders = [];
+        this._jointDynamicsSpringBones = [];
+        this._morphTargetGroups = [];
         this._activeScene = -1;
-    }
-    /** Name of the model */ get name() {
-        return this._name;
-    }
-    set name(val) {
-        this._name = val;
+        this._textureMap = new Map();
+        this._primitiveMap = new Map();
     }
     /** All scenes that the model contains */ get scenes() {
         return this._scenes;
     }
+    /** All Primitives that the model contains */ get primitives() {
+        return this._primitiveList;
+    }
+    /** All nodes that the model contains */ get nodes() {
+        return this._nodes;
+    }
     /** All animations that the model contains */ get animations() {
         return this._animations;
     }
     /** All skeletons that the model contains */ get skeletons() {
         return this._skeletons;
     }
-    /** All nodes that the model contains */ get nodes() {
-        return this._nodes;
+    /** All SpringBone colliders that the model contains */ get springBoneColliders() {
+        return this._springBoneColliders;
+    }
+    /** All SpringBone collider groups that the model contains */ get springBoneColliderGroups() {
+        return this._springBoneColliderGroups;
+    }
+    /** All SpringBone springs that the model contains */ get springBones() {
+        return this._springBones;
+    }
+    /** SpringBone colliders converted to Zephyr3D JointDynamics collider format */ get jointDynamicsColliders() {
+        return this._jointDynamicsColliders;
+    }
+    /** SpringBone springs converted to Zephyr3D JointDynamics system format */ get jointDynamicsSpringBones() {
+        return this._jointDynamicsSpringBones;
+    }
+    /** Model-level morph target groups, commonly facial expressions. */ get morphTargetGroups() {
+        return this._morphTargetGroups;
     }
     /** The active scene of the model */ get activeScene() {
         return this._activeScene;
@@ -263,16 +312,75 @@ import { MAX_MORPH_TARGETS } from '../values.js';
     set activeScene(val) {
         this._activeScene = val;
     }
+    getImage(index) {
+        return this._imageList[index];
+    }
+    setImage(index, img) {
+        this._imageList[index] = img;
+    }
+    getMaterial(hash) {
+        return this._materialList[hash];
+    }
+    setMaterial(hash, material) {
+        this._materialList[hash] = material;
+    }
+    addPrimitive(prim) {
+        this._primitiveList.push(prim);
+    }
     /**
-   * Adds a node to the scene
-   * @param parent - Under which node the node should be added
-   * @param index - Index of the node
-   * @param name - Name of the node
-   * @returns The added node
-   */ addNode(parent, index, name) {
-        const childNode = new AssetHierarchyNode(name, parent);
-        this._nodes[index] = childNode;
-        return childNode;
+   * Adds a model-level morph target group.
+   * @param group - Morph target group to add
+   */ addMorphTargetGroup(group) {
+        if (group?.name && group.bindings?.length > 0) {
+            this._morphTargetGroups.push(group);
+        }
+    }
+    /**
+   * Removes all model-level morph target groups.
+   */ clearMorphTargetGroups() {
+        this._morphTargetGroups = [];
+    }
+    /**
+   * Finds a model-level morph target group by name.
+   * @param name - Group name
+   * @returns The matching group, or null if not found
+   */ getMorphTargetGroup(name) {
+        return this._morphTargetGroups.find((group)=>group.name === name) ?? null;
+    }
+    /**
+   * Builds morph target groups by collecting morph target names from every mesh.
+   * @returns Generated morph target groups
+   */ buildMorphTargetGroupsByName() {
+        this.clearMorphTargetGroups();
+        const groups = new Map();
+        const meshes = new Set();
+        for (const node of this._nodes){
+            if (node.mesh) {
+                meshes.add(node.mesh);
+            }
+        }
+        for (const mesh of meshes){
+            const count = getAssetMeshMorphTargetCount(mesh);
+            for(let i = 0; i < count; i++){
+                const targetName = getAssetMeshMorphTargetName(mesh, i);
+                let group = groups.get(targetName);
+                if (!group) {
+                    group = {
+                        name: targetName,
+                        bindings: []
+                    };
+                    groups.set(targetName, group);
+                }
+                group.bindings.push({
+                    mesh,
+                    targetIndex: i,
+                    targetName,
+                    weight: 1
+                });
+            }
+        }
+        this._morphTargetGroups = Array.from(groups.values());
+        return this._morphTargetGroups;
     }
     /**
    * Adds a skeleton to the scene
@@ -286,67 +394,297 @@ import { MAX_MORPH_TARGETS } from '../values.js';
    */ addAnimation(animation) {
         this._animations.push(animation);
     }
-    createSceneNode(scene, instancing) {
+    static async writePrimitive(vfs, primitive, path) {
+        const data = {
+            vertices: {},
+            indices: primitive.indices ? uint8ArrayToBase64(new Uint8Array(primitive.indices.buffer, primitive.indices.byteOffset, primitive.indices.byteLength)) : null,
+            indexType: primitive.indices ? primitive.indices instanceof Uint16Array ? 'u16' : 'u32' : '',
+            indexCount: primitive.indexCount,
+            type: primitive.type,
+            boxMin: [
+                primitive.boxMin.x,
+                primitive.boxMin.y,
+                primitive.boxMin.z
+            ],
+            boxMax: [
+                primitive.boxMax.x,
+                primitive.boxMax.y,
+                primitive.boxMax.z
+            ]
+        };
+        for(const k in primitive.vertices){
+            const v = primitive.vertices[k];
+            data.vertices[k] = {
+                format: v.format,
+                data: uint8ArrayToBase64(new Uint8Array(v.data.buffer, v.data.byteOffset, v.data.byteLength))
+            };
+        }
+        const content = JSON.stringify({
+            type: 'Primitive',
+            data
+        }, null, 2);
+        await vfs.writeFile(path, content, {
+            encoding: 'utf8',
+            create: true
+        });
+    }
+    /** preprocess */ async preprocess(manager, name, destPath, srcVFS, dstVFS) {
+        const destName = name;
+        if (this._imageList.length > 0) {
+            console.info(`Importing ${this._imageList.length} textures`);
+            for(let i = 0; i < this._imageList.length; i++){
+                const img = this._imageList[i];
+                if (!img) {
+                    continue;
+                }
+                let ext = '';
+                const mimeType = img.uri ? srcVFS.guessMIMEType(img.uri) : img.data ? img.mimeType : '';
+                if (mimeType === 'image/jpeg') {
+                    ext = '.jpg';
+                } else if (mimeType === 'image/png') {
+                    ext = '.png';
+                } else if (mimeType === 'image/webp') {
+                    ext = '.webp';
+                } else if (mimeType === 'image/tga') {
+                    ext = '.tga';
+                } else if (mimeType === 'image/vnd.radiance') {
+                    ext = '.hdr';
+                } else if (mimeType === 'image/ktx') {
+                    ext = '.ktx';
+                } else if (mimeType === 'image/ktx2') {
+                    ext = '.ktx2';
+                } else {
+                    continue;
+                }
+                ASSERT(!!ext, `Unknown image mime type: ${mimeType}`);
+                const path = dstVFS.join(destPath, `${destName}_texture_${i}${ext}`);
+                if (img.uri) {
+                    img.data = new Uint8Array(await srcVFS.readFile(img.uri, {
+                        encoding: 'binary'
+                    }));
+                }
+                await dstVFS.writeFile(path, img.data.buffer.slice(img.data.byteOffset, img.data.byteOffset + img.data.byteLength), {
+                    encoding: 'binary',
+                    create: true
+                });
+                img.uri = path;
+                img.data = undefined;
+                img.mimeType = '';
+            }
+        }
+        const materialKeys = Object.keys(this._materialList);
+        if (materialKeys.length > 0) {
+            console.info(`Importing ${materialKeys.length} materials`);
+            for (const k of materialKeys){
+                const path = dstVFS.join(destPath, `${destName}_material_${k}.zmtl`);
+                const m = await this.createMaterial(manager, this._materialList[k], dstVFS);
+                const data = await manager.serializeObject(m);
+                const content = JSON.stringify({
+                    type: 'Default',
+                    data
+                }, null, 2);
+                await dstVFS.writeFile(path, content, {
+                    encoding: 'utf8',
+                    create: true
+                });
+                this._materialList[k].path = path;
+                m.dispose();
+            }
+        }
+        if (this._primitiveList.length > 0) {
+            console.info(`Importing ${this._primitiveList.length} meshes`);
+            for(let i = 0; i < this._primitiveList.length; i++){
+                const info = this._primitiveList[i];
+                if (!info) {
+                    continue;
+                }
+                const path = dstVFS.join(destPath, `${destName}_mesh_${i}.zmsh`);
+                await SharedModel.writePrimitive(dstVFS, info, path);
+                info.path = path;
+            }
+        }
+    }
+    createJointDynamics(rootNode, nodeMap) {
+        if (rootNode.animationSet.rigs.length === 0) {
+            return;
+        }
+        for (const jd of this._jointDynamicsSpringBones){
+            const chains = jd.chains.map((chain)=>{
+                const start = nodeMap.get(chain.start);
+                const end = nodeMap.get(chain.end);
+                return {
+                    start,
+                    end
+                };
+            }).filter((chain)=>{
+                if (!chain.start || !chain.end) {
+                    return false;
+                }
+                return true;
+            });
+            const rigs = rootNode.animationSet.rigs.filter((ref)=>{
+                const joints = ref.get().joints;
+                return chains.every((chain)=>joints.includes(chain.start));
+            });
+            if (rigs.length === 0) {
+                continue;
+            }
+            const colliders = jd.colliders.map((collider)=>{
+                const parent = nodeMap.get(collider.node);
+                if (!parent) {
+                    return null;
+                }
+                const node = new SceneNode(parent.scene);
+                node.name = collider.name ? `${collider.name}_JointDynamicsCollider` : 'JointDynamicsCollider';
+                node.parent = parent;
+                node.position.set(collider.localPosition);
+                node.rotation.set(collider.localRotation);
+                return {
+                    r: {
+                        ...collider.collider
+                    },
+                    transform: createTransformAccess(node)
+                };
+            }).filter((collider)=>{
+                return !!collider;
+            });
+            const flatPlanes = jd.flatPlanes.map((flatPlane)=>{
+                const node = nodeMap.get(flatPlane.node);
+                if (!node) {
+                    return null;
+                }
+                const up = node.worldMatrix.transformVectorAffine(flatPlane.up, new Vector3());
+                if (up.magnitudeSq === 0) {
+                    return null;
+                }
+                return {
+                    up: up.inplaceNormalize(),
+                    position: node.worldMatrix.transformPointAffine(flatPlane.position, new Vector3())
+                };
+            }).filter((flatPlane)=>{
+                return !!flatPlane;
+            });
+            for (const rig of rigs){
+                const system = new JointDynamicsSystem({
+                    chainConfig: {
+                        chains,
+                        systemRoot: rootNode
+                    },
+                    controllerConfig: jd.controllerConfig
+                }, colliders, [], flatPlanes);
+                const modifier = new JointDynamicsModifier(system);
+                rig.get().modifiers.push(modifier);
+            }
+        }
+    }
+    createMorphTargetGroups(rootNode, meshMap) {
+        const runtimeGroups = [];
+        for (const group of this._morphTargetGroups){
+            const bindings = [];
+            for (const binding of group.bindings){
+                const assetMesh = binding.node?.mesh ?? binding.mesh ?? null;
+                if (!assetMesh) {
+                    continue;
+                }
+                for (const subMesh of assetMesh.subMeshes){
+                    const mesh = meshMap.get(subMesh);
+                    if (mesh) {
+                        bindings.push({
+                            mesh,
+                            targetIndex: binding.targetIndex,
+                            targetName: binding.targetName,
+                            weight: binding.weight
+                        });
+                    }
+                }
+            }
+            if (bindings.length > 0) {
+                runtimeGroups.push({
+                    name: group.name,
+                    bindings,
+                    isBinary: group.isBinary,
+                    weight: this.getInitialMorphTargetGroupWeight(bindings, group.isBinary)
+                });
+            }
+        }
+        rootNode.morphTargetGroups = runtimeGroups;
+    }
+    getInitialMorphTargetGroupWeight(bindings, isBinary) {
+        let result = 0;
+        let found = false;
+        for (const binding of bindings){
+            if (!binding.weight) {
+                continue;
+            }
+            const targetWeight = this.getMorphTargetBindingWeight(binding);
+            if (targetWeight === null) {
+                continue;
+            }
+            const groupWeight = targetWeight / binding.weight;
+            if (!found || Math.abs(groupWeight) > Math.abs(result)) {
+                result = groupWeight;
+                found = true;
+            }
+        }
+        return isBinary ? result > 0.5 ? 1 : 0 : result;
+    }
+    getMorphTargetBindingWeight(binding) {
+        const targetIndex = binding.targetIndex;
+        if (typeof targetIndex === 'number' && targetIndex >= 0 && targetIndex < binding.mesh.getNumMorphTargets()) {
+            const targetName = binding.mesh.getMorphTargetName(targetIndex);
+            if (targetName) {
+                return binding.mesh.getMorphWeight(targetName);
+            }
+        }
+        if (binding.targetName) {
+            return binding.mesh.getMorphWeight(binding.targetName);
+        }
+        return null;
+    }
+    async createSceneNode(manager, scene, instancing, saveMeshes, saveSkeletons, saveAnimations, saveJointDynamics, srcVFS) {
         const group = new SceneNode(scene);
-        group.name = this.name;
-        const animationSet = group.animationSet;
+        const nodeMap = new Map();
+        const meshMap = new Map();
         for(let i = 0; i < this.scenes.length; i++){
             const assetScene = this.scenes[i];
             const skeletonMeshMap = new Map();
-            const nodeMap = new Map();
             for(let k = 0; k < assetScene.rootNodes.length; k++){
-                this.setAssetNodeToSceneNode(scene, group, assetScene.rootNodes[k], skeletonMeshMap, nodeMap, instancing);
-            }
-            for (const animationData of this.animations){
-                let name = animationData.name ?? `_embbeded_animation`;
-                if (animationSet.getAnimationClip(name)) {
-                    const baseName = name;
-                    for(let t = 1;; t++){
-                        name = `${baseName}_${t}`;
-                        if (!animationSet.getAnimationClip(name)) {
-                            break;
-                        }
+                await this.setAssetNodeToSceneNode(manager, scene, group, assetScene.rootNodes[k], skeletonMeshMap, nodeMap, meshMap, instancing, saveMeshes, saveSkeletons, saveAnimations, srcVFS);
+            }
+            if (saveSkeletons) {
+                for (const sk of this.skeletons){
+                    if (!skeletonMeshMap.has(sk)) {
+                        skeletonMeshMap.set(sk, {
+                            mesh: [],
+                            bounding: []
+                        });
                     }
                 }
-                const animation = animationSet.createAnimation(name, true);
-                for (const track of animationData.tracks){
-                    if (track.type === 'translation') {
-                        animation.addTrack(nodeMap.get(track.node), new NodeTranslationTrack(track.interpolator, true));
-                    } else if (track.type === 'scale') {
-                        animation.addTrack(nodeMap.get(track.node), new NodeScaleTrack(track.interpolator, true));
-                    } else if (track.type === 'rotation') {
-                        animation.addTrack(nodeMap.get(track.node), new NodeRotationTrack(track.interpolator, true));
-                    } else if (track.type === 'weights') {
-                        for (const m of track.node.mesh.subMeshes){
-                            if (track.interpolator.stride > MAX_MORPH_TARGETS) {
-                                console.error(`Morph target too large: ${track.interpolator.stride}, the maximum is ${MAX_MORPH_TARGETS}`);
-                            } else {
-                                const morphTrack = new MorphTargetTrack(track.interpolator, track.defaultMorphWeights, m.targetBox, m.mesh.getBoundingVolume().toAABB(), true);
-                                animation.addTrack(m.mesh, morphTrack);
-                            }
-                        }
-                    } else if (track.type === 'geometry-cache') {
-                        const subMesh = track.node.mesh?.subMeshes[track.subMeshIndex];
-                        if (!subMesh?.mesh) {
-                            console.error(`Invalid geometry cache sub mesh: ${track.subMeshIndex}`);
-                        } else {
-                            if (track.codec === 'pca') {
-                                const pcaData = this.remapPCAGeometryCacheData(subMesh, track);
-                                animation.addTrack(subMesh.mesh, new PCAGeometryCacheTrack(pcaData, true));
-                            } else {
-                                const frames = this.remapGeometryCacheFrames(subMesh, track.frames);
-                                animation.addTrack(subMesh.mesh, new FixedGeometryCacheTrack(track.times, frames, true));
-                            }
-                        }
-                    } else {
-                        console.error(`Invalid animation track type: ${track.type}`);
+                const rigMap = new Map();
+                for (const v of skeletonMeshMap){
+                    const sk = v[0];
+                    const joints = sk.joints.map((val)=>{
+                        const node = nodeMap.get(val);
+                        node.jointTypeT = 'static';
+                        node.jointTypeS = 'static';
+                        node.jointTypeR = 'static';
+                        return node;
+                    });
+                    const rootJoint = sk.root ? nodeMap.get(sk.root) ?? null : null;
+                    const rigKey = SkeletonRig.getRigKey(joints, rootJoint);
+                    let rig = rigMap.get(rigKey);
+                    if (!rig) {
+                        rig = new SkeletonRig(joints, sk.bindPose, {
+                            rootJoint
+                        });
+                        rigMap.set(rigKey, rig);
+                        group.animationSet.rigs.push(new DRef(rig));
                     }
-                }
-                for (const sk of animationData.skeletons){
+                    const binding = new SkinBinding(rig, sk.inverseBindMatrices, joints);
                     const nodes = skeletonMeshMap.get(sk);
                     if (nodes) {
-                        if (!nodes.skeleton) {
-                            nodes.skeleton = new Skeleton(sk.joints.map((val)=>nodeMap.get(val)), sk.inverseBindMatrices, sk.bindPose);
+                        if (!nodes.binding) {
+                            nodes.binding = binding;
                             for(let i = 0; i < nodes.mesh.length; i++){
                                 const mesh = nodes.mesh[i];
                                 const v = {
@@ -354,22 +692,82 @@ import { MAX_MORPH_TARGETS } from '../values.js';
                                     blendIndices: nodes.bounding[i].rawBlendIndices,
                                     weights: nodes.bounding[i].rawJointWeights
                                 };
-                                mesh.setSkinnedBoundingInfo(nodes.skeleton.getBoundingInfo(v));
-                                mesh.skeletonName = nodes.skeleton.persistentId;
+                                mesh.setSkinnedBoundingInfo(nodes.binding.getBoundingInfo(v));
+                                mesh.skeletonName = nodes.binding.persistentId;
                             }
-                            animationSet.skeletons.push(new DRef(nodes.skeleton));
                         }
-                        animation.addSkeleton(nodes.skeleton.persistentId);
                     }
+                    group.animationSet.skeletons.push(new DRef(nodes.binding));
                 }
             }
-        }
-        group.iterate((child)=>{
-            if (child !== group) {
-                child.sealed = true;
+            if (saveAnimations) {
+                for (const animationData of this.animations){
+                    if (animationData.skeletons.length > 0 && !saveSkeletons) {
+                        continue;
+                    }
+                    let name = animationData.name ?? `_embbeded_animation`;
+                    if (group.animationSet.getAnimationClip(name)) {
+                        const baseName = name;
+                        for(let t = 1;; t++){
+                            name = `${baseName}_${t}`;
+                            if (!group.animationSet.getAnimationClip(name)) {
+                                break;
+                            }
+                        }
+                    }
+                    const animation = group.animationSet.createAnimation(name, true);
+                    for (const sk of animationData.skeletons){
+                        const nodes = skeletonMeshMap.get(sk);
+                        if (nodes) {
+                            animation.addSkeleton(nodes.binding.rig.persistentId);
+                        }
+                    }
+                    for (const track of animationData.tracks){
+                        const target = nodeMap.get(track.node);
+                        if (track.type === 'translation') {
+                            animation.addTrack(target, new NodeTranslationTrack(track.interpolator, true));
+                            target.jointTypeT = 'animated';
+                        } else if (track.type === 'scale') {
+                            animation.addTrack(target, new NodeScaleTrack(track.interpolator, true));
+                            target.jointTypeS = 'animated';
+                        } else if (track.type === 'rotation') {
+                            animation.addTrack(target, new NodeRotationTrack(track.interpolator, true));
+                            target.jointTypeR = 'animated';
+                        } else if (track.type === 'weights') {
+                            for (const m of track.node.mesh.subMeshes){
+                                const mesh = meshMap.get(m);
+                                if (track.interpolator.stride > MAX_MORPH_TARGETS) {
+                                    console.error(`Morph target too large: ${track.interpolator.stride}, the maximum is ${MAX_MORPH_TARGETS}`);
+                                } else {
+                                    const morphTrack = new MorphTargetTrack(track.interpolator, track.defaultMorphWeights, m.targetBox, mesh.getBoundingVolume().toAABB(), true);
+                                    animation.addTrack(mesh, morphTrack);
+                                }
+                            }
+                        } else if (track.type === 'geometry-cache') {
+                            const subMesh = track.node.mesh?.subMeshes[track.subMeshIndex];
+                            const mesh = subMesh ? meshMap.get(subMesh) : null;
+                            if (!subMesh || !mesh) {
+                                console.error(`Invalid geometry cache sub mesh: ${track.subMeshIndex}`);
+                            } else {
+                                if (track.codec === 'pca') {
+                                    const pcaData = this.remapPCAGeometryCacheData(subMesh, track);
+                                    animation.addTrack(mesh, new PCAGeometryCacheTrack(pcaData, true));
+                                } else {
+                                    const frames = this.remapGeometryCacheFrames(subMesh, track.frames);
+                                    animation.addTrack(mesh, new FixedGeometryCacheTrack(track.times, frames, true));
+                                }
+                            }
+                        } else {
+                            console.error(`Invalid animation track type: ${track.type}`);
+                        }
+                    }
+                }
             }
-        });
-        group.sharedModel = this;
+        }
+        if (saveJointDynamics && saveSkeletons) {
+            this.createJointDynamics(group, nodeMap);
+        }
+        this.createMorphTargetGroups(group, meshMap);
         return group;
     }
     remapGeometryCacheFrames(subMesh, frames) {
@@ -547,51 +945,61 @@ import { MAX_MORPH_TARGETS } from '../values.js';
     }
     onDispose() {
         super.onDispose();
-        const nodes = [
-            ...this._nodes
-        ];
-        while(nodes.length > 0){
-            const node = nodes.shift();
-            nodes.push(...node.children);
-            const mesh = node.mesh;
-            if (mesh) {
-                for (const subMesh of mesh.subMeshes){
-                    subMesh.primitive?.dispose();
-                    subMesh.material?.dispose();
-                }
-            }
+        for (const prim of this._primitiveMap.values()){
+            prim.dispose();
+        }
+        for (const tex of this._textureMap.values()){
+            tex.dispose();
         }
-        this._nodes = [];
         this._skeletons = [];
         this._scenes = [];
         this._animations = [];
     }
-    setAssetNodeToSceneNode(scene, parent, assetNode, skeletonMeshMap, nodeMap, instancing) {
+    async setAssetNodeToSceneNode(manager, scene, parent, assetNode, skeletonMeshMap, nodeMap, meshMap, instancing, saveMeshes, saveSkeletons, saveAnimations, srcVFS) {
         const node = new SceneNode(scene);
         nodeMap.set(assetNode, node);
         node.name = assetNode.name ?? '';
         node.position.set(assetNode.position);
         node.rotation.set(assetNode.rotation);
         node.scale.set(assetNode.scaling);
-        if (assetNode.mesh) {
+        if (saveMeshes && assetNode.mesh) {
             const meshData = assetNode.mesh;
-            const skeleton = assetNode.skeleton;
+            const skeleton = saveSkeletons ? assetNode.skeleton : null;
             for (const subMesh of meshData.subMeshes){
+                if (assetNode.instances.length === 0) {
+                    assetNode.instances.push({
+                        t: Vector3.zero(),
+                        s: Vector3.one(),
+                        r: Quaternion.identity()
+                    });
+                }
                 for (const instance of assetNode.instances){
                     const meshNode = new Mesh(scene);
-                    const skinAnimation = !!skeleton;
-                    const morphAnimation = subMesh.numTargets > 0;
                     meshNode.position = instance.t;
                     meshNode.scale = instance.s;
                     meshNode.rotation = instance.r;
                     meshNode.name = subMesh.name;
                     meshNode.clipTestEnabled = true;
                     meshNode.showState = 'inherit';
-                    meshNode.primitive = subMesh.primitive.get();
-                    meshNode.material = instancing && !skinAnimation && !morphAnimation ? subMesh.material.get().createInstance() : subMesh.material.get().clone();
+                    if (!this._primitiveMap.get(subMesh.primitive)) {
+                        this._primitiveMap.set(subMesh.primitive, new DRef(await this.createPrimitive(manager, subMesh.primitive, srcVFS) ?? undefined));
+                    }
+                    meshNode.primitive = this._primitiveMap.get(subMesh.primitive).get();
+                    if (!subMesh.material.material) {
+                        subMesh.material.material = new DRef(await this.createMaterial(manager, subMesh.material, srcVFS) ?? undefined);
+                    }
+                    meshNode.material = subMesh.material.material?.get() ?? null;
+                    if (instancing) {
+                        meshNode.material = meshNode.material.createInstance();
+                    }
                     meshNode.parent = node;
-                    subMesh.mesh = meshNode;
-                    processMorphData(subMesh, meshData.morphWeights);
+                    meshMap.set(subMesh, meshNode);
+                    setSceneMeshAssetBinding(meshNode, {
+                        node: assetNode,
+                        mesh: meshData,
+                        subMesh
+                    });
+                    processMorphData(subMesh, meshNode, assetNode.weights ?? meshData.morphWeights, meshData.morphNames);
                     if (skeleton) {
                         if (!skeletonMeshMap.has(skeleton)) {
                             skeletonMeshMap.set(skeleton, {
@@ -612,9 +1020,470 @@ import { MAX_MORPH_TARGETS } from '../values.js';
         }
         node.parent = parent;
         for (const child of assetNode.children){
-            this.setAssetNodeToSceneNode(scene, node, child, skeletonMeshMap, nodeMap, instancing);
+            await this.setAssetNodeToSceneNode(manager, scene, node, child, skeletonMeshMap, nodeMap, meshMap, instancing, saveMeshes, saveSkeletons, saveAnimations, srcVFS);
+        }
+        return node;
+    }
+    async image2Texture(manager, info, srcVFS) {
+        if (info.image.uri) {
+            const texture = await manager.fetchTexture(info.image.uri, {
+                linearColorSpace: !info.sRGB,
+                overrideVFS: srcVFS
+            });
+            texture.name = info.image.uri;
+            return texture;
+        } else if (info.image.data && info.image.mimeType) {
+            const texture = await manager.loadTextureFromBuffer(info.image.data, info.image.mimeType, !!info.sRGB);
+            return texture;
+        }
+        return null;
+    }
+    async createTexture(manager, info, srcVFS) {
+        try {
+            let textureRef = this._textureMap.get(info);
+            if (!textureRef) {
+                textureRef = new DRef(await this.image2Texture(manager, info, srcVFS));
+                this._textureMap.set(info, textureRef);
+            }
+            const sampler = getDevice().createSampler({
+                addressU: info.sampler.wrapS,
+                addressV: info.sampler.wrapT,
+                magFilter: info.sampler.magFilter,
+                minFilter: info.sampler.minFilter,
+                mipFilter: info.sampler.mipFilter
+            });
+            const transform = info.transform;
+            const texCoord = info.texCoord;
+            return {
+                texture: textureRef.get(),
+                sampler,
+                texCoord,
+                transform
+            };
+        } catch (err) {
+            console.error(`Load asset texture failed: ${err}`);
+            return null;
+        }
+    }
+    async createPrimitive(manager, info, srcVFS) {
+        if (info.path) {
+            return manager.fetchPrimitive(info.path, {
+                overrideVFS: srcVFS
+            });
+        }
+        const primitive = new Primitive();
+        for(const k in info.vertices){
+            const v = info.vertices[k];
+            primitive.createAndSetVertexBuffer(v.format, v.data);
+        }
+        if (info.indices) {
+            primitive.createAndSetIndexBuffer(info.indices);
+        }
+        primitive.primitiveType = info.type;
+        primitive.indexCount = info.indexCount;
+        primitive.setBoundingVolume(new BoundingBox(info.boxMin, info.boxMax));
+        return primitive;
+    }
+    async createMaterial(manager, assetMaterial, srcVFS) {
+        if (assetMaterial.path) {
+            return manager.fetchMaterial(assetMaterial.path, {
+                overrideVFS: srcVFS
+            });
+        }
+        const infoMap = new Map();
+        const that = this;
+        async function getTextureInfo(info) {
+            let t = infoMap.get(info);
+            if (t === undefined) {
+                t = await that.createTexture(manager, info, srcVFS);
+                infoMap.set(info, t);
+            }
+            return t;
+        }
+        if (assetMaterial.type === 'unlit') {
+            const unlitAssetMaterial = assetMaterial;
+            const unlitMaterial = new UnlitMaterial();
+            unlitMaterial.albedoColor = unlitAssetMaterial.diffuse ?? Vector4.one();
+            if (unlitAssetMaterial.diffuseMap) {
+                const info = await getTextureInfo(unlitAssetMaterial.diffuseMap);
+                if (info) {
+                    unlitMaterial.albedoTexture = info.texture;
+                    unlitMaterial.albedoTextureSampler = info.sampler;
+                    unlitMaterial.albedoTexCoordIndex = info.texCoord;
+                    unlitMaterial.albedoTexCoordMatrix = info.transform;
+                }
+            }
+            unlitMaterial.vertexColor = unlitAssetMaterial.common.vertexColor;
+            if (assetMaterial.common.alphaMode === 'blend') {
+                unlitMaterial.blendMode = 'blend';
+            } else if (assetMaterial.common.alphaMode === 'mask') {
+                unlitMaterial.alphaCutoff = assetMaterial.common.alphaCutoff;
+            }
+            if (assetMaterial.common.doubleSided) {
+                unlitMaterial.cullMode = 'none';
+            }
+            return unlitMaterial;
+        } else if (assetMaterial.type === 'pbrSpecularGlossiness') {
+            const assetPBRMaterial = assetMaterial;
+            const pbrMaterial = new PBRSpecularGlossinessMaterial();
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.specularFactor = new Vector3(assetPBRMaterial.specular.x, assetPBRMaterial.specular.y, assetPBRMaterial.specular.z);
+            pbrMaterial.glossinessFactor = assetPBRMaterial.glossness;
+            if (assetPBRMaterial.diffuseMap) {
+                const info = await getTextureInfo(assetPBRMaterial.diffuseMap);
+                if (info) {
+                    pbrMaterial.albedoTexture = info.texture;
+                    pbrMaterial.albedoTextureSampler = info.sampler;
+                    pbrMaterial.albedoTexCoordIndex = info.texCoord;
+                    pbrMaterial.albedoTexCoordMatrix = info.transform;
+                }
+            }
+            if (assetPBRMaterial.common.normalMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.normalMap);
+                if (info) {
+                    pbrMaterial.normalTexture = info.texture;
+                    pbrMaterial.normalTextureSampler = info.sampler;
+                    pbrMaterial.normalTexCoordIndex = info.texCoord;
+                    pbrMaterial.normalTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
+            if (assetPBRMaterial.common.emissiveMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.emissiveMap);
+                if (info) {
+                    pbrMaterial.emissiveTexture = info.texture;
+                    pbrMaterial.emissiveTextureSampler = info.sampler;
+                    pbrMaterial.emissiveTexCoordIndex = info.texCoord;
+                    pbrMaterial.emissiveTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            if (assetPBRMaterial.common.occlusionMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.occlusionMap);
+                if (info) {
+                    pbrMaterial.occlusionTexture = info.texture;
+                    pbrMaterial.occlusionTextureSampler = info.sampler;
+                    pbrMaterial.occlusionTexCoordIndex = info.texCoord;
+                    pbrMaterial.occlusionTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
+            if (assetPBRMaterial.specularGlossnessMap) {
+                const info = await getTextureInfo(assetPBRMaterial.specularGlossnessMap);
+                if (info) {
+                    pbrMaterial.specularTexture = info.texture;
+                    pbrMaterial.specularTextureSampler = info.sampler;
+                    pbrMaterial.specularTexCoordIndex = info.texCoord;
+                    pbrMaterial.specularTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
+            pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
+            if (assetPBRMaterial.common.alphaMode === 'blend') {
+                pbrMaterial.blendMode = 'blend';
+            } else if (assetPBRMaterial.common.alphaMode === 'mask') {
+                pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
+            }
+            if (assetPBRMaterial.common.doubleSided) {
+                pbrMaterial.cullMode = 'none';
+            }
+            pbrMaterial.vertexNormal = !!assetMaterial.common.vertexNormal;
+            return pbrMaterial;
+        } else if (assetMaterial.type === 'pbrMetallicRoughness') {
+            const assetPBRMaterial = assetMaterial;
+            const pbrMaterial = new PBRMetallicRoughnessMaterial();
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.metallic = assetPBRMaterial.metallic;
+            pbrMaterial.roughness = assetPBRMaterial.roughness;
+            if (assetPBRMaterial.diffuseMap) {
+                const info = await getTextureInfo(assetPBRMaterial.diffuseMap);
+                if (info) {
+                    pbrMaterial.albedoTexture = info.texture;
+                    pbrMaterial.albedoTextureSampler = info.sampler;
+                    pbrMaterial.albedoTexCoordIndex = info.texCoord;
+                    pbrMaterial.albedoTexCoordMatrix = info.transform;
+                }
+            }
+            if (assetPBRMaterial.common.normalMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.normalMap);
+                if (info) {
+                    pbrMaterial.normalTexture = info.texture;
+                    pbrMaterial.normalTextureSampler = info.sampler;
+                    pbrMaterial.normalTexCoordIndex = info.texCoord;
+                    pbrMaterial.normalTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
+            if (assetPBRMaterial.common.emissiveMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.emissiveMap);
+                if (info) {
+                    pbrMaterial.emissiveTexture = info.texture;
+                    pbrMaterial.emissiveTextureSampler = info.sampler;
+                    pbrMaterial.emissiveTexCoordIndex = info.texCoord;
+                    pbrMaterial.emissiveTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            if (assetPBRMaterial.common.occlusionMap) {
+                const info = await getTextureInfo(assetPBRMaterial.common.occlusionMap);
+                if (info) {
+                    pbrMaterial.occlusionTexture = info.texture;
+                    pbrMaterial.occlusionTextureSampler = info.sampler;
+                    pbrMaterial.occlusionTexCoordIndex = info.texCoord;
+                    pbrMaterial.occlusionTexCoordMatrix = info.transform;
+                }
+                pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
+            }
+            if (assetPBRMaterial.metallicMap) {
+                const info = await getTextureInfo(assetPBRMaterial.metallicMap);
+                if (info) {
+                    pbrMaterial.metallicRoughnessTexture = info.texture;
+                    pbrMaterial.metallicRoughnessTextureSampler = info.sampler;
+                    pbrMaterial.metallicRoughnessTexCoordIndex = info.texCoord;
+                    pbrMaterial.metallicRoughnessTexCoordMatrix = info.transform;
+                }
+            }
+            pbrMaterial.specularFactor = assetPBRMaterial.specularFactor;
+            if (assetPBRMaterial.specularMap) {
+                const info = await getTextureInfo(assetPBRMaterial.specularMap);
+                if (info) {
+                    pbrMaterial.specularTexture = info.texture;
+                    pbrMaterial.specularTextureSampler = info.sampler;
+                    pbrMaterial.specularTexCoordIndex = info.texCoord;
+                    pbrMaterial.specularTexCoordMatrix = info.transform;
+                }
+            }
+            if (assetPBRMaterial.specularColorMap) {
+                const info = await getTextureInfo(assetPBRMaterial.specularColorMap);
+                if (info) {
+                    pbrMaterial.specularColorTexture = info.texture;
+                    pbrMaterial.specularColorTextureSampler = info.sampler;
+                    pbrMaterial.specularColorTexCoordIndex = info.texCoord;
+                    pbrMaterial.specularColorTexCoordMatrix = info.transform;
+                }
+            }
+            if (assetPBRMaterial.sheen) {
+                const sheen = assetPBRMaterial.sheen;
+                pbrMaterial.sheen = true;
+                pbrMaterial.sheenColorFactor = sheen.sheenColorFactor;
+                pbrMaterial.sheenRoughnessFactor = sheen.sheenRoughnessFactor;
+                if (sheen.sheenColorMap) {
+                    const info = await getTextureInfo(sheen.sheenColorMap);
+                    if (info) {
+                        pbrMaterial.sheenColorTexture = info.texture;
+                        pbrMaterial.sheenColorTextureSampler = info.sampler;
+                        pbrMaterial.sheenColorTexCoordIndex = info.texCoord;
+                        pbrMaterial.sheenColorTexCoordMatrix = info.transform;
+                    }
+                }
+                if (sheen.sheenRoughnessMap) {
+                    const info = await getTextureInfo(sheen.sheenRoughnessMap);
+                    if (info) {
+                        pbrMaterial.sheenRoughnessTexture = info.texture;
+                        pbrMaterial.sheenRoughnessTextureSampler = info.sampler;
+                        pbrMaterial.sheenRoughnessTexCoordIndex = info.texCoord;
+                        pbrMaterial.sheenRoughnessTexCoordMatrix = info.transform;
+                    }
+                }
+            }
+            if (assetPBRMaterial.iridescence) {
+                const iridescence = assetPBRMaterial.iridescence;
+                pbrMaterial.iridescence = true;
+                pbrMaterial.iridescenceFactor = iridescence.iridescenceFactor;
+                pbrMaterial.iridescenceIor = iridescence.iridescenceIor;
+                if (iridescence.iridescenceMap) {
+                    const info = await getTextureInfo(iridescence.iridescenceMap);
+                    if (info) {
+                        pbrMaterial.iridescenceTexture = info.texture;
+                        pbrMaterial.iridescenceTextureSampler = info.sampler;
+                        pbrMaterial.iridescenceTexCoordIndex = info.texCoord;
+                        pbrMaterial.iridescenceTexCoordMatrix = info.transform;
+                    }
+                }
+                pbrMaterial.iridescenceThicknessMin = iridescence.iridescenceThicknessMinimum;
+                pbrMaterial.iridescenceThicknessMax = iridescence.iridescenceThicknessMaximum;
+                if (iridescence.iridescenceThicknessMap) {
+                    const info = await getTextureInfo(iridescence.iridescenceThicknessMap);
+                    if (info) {
+                        pbrMaterial.iridescenceThicknessTexture = info.texture;
+                        pbrMaterial.iridescenceThicknessTextureSampler = info.sampler;
+                        pbrMaterial.iridescenceThicknessTexCoordIndex = info.texCoord;
+                        pbrMaterial.iridescenceThicknessTexCoordMatrix = info.transform;
+                    }
+                }
+            }
+            if (assetPBRMaterial.transmission) {
+                const transmission = assetPBRMaterial.transmission;
+                pbrMaterial.transmission = true;
+                pbrMaterial.transmissionFactor = transmission.transmissionFactor;
+                if (transmission.transmissionMap) {
+                    const info = await getTextureInfo(transmission.transmissionMap);
+                    if (info) {
+                        pbrMaterial.transmissionTexture = info.texture;
+                        pbrMaterial.transmissionTextureSampler = info.sampler;
+                        pbrMaterial.transmissionTexCoordIndex = info.texCoord;
+                        pbrMaterial.transmissionTexCoordMatrix = info.transform;
+                    }
+                }
+                pbrMaterial.thicknessFactor = transmission.thicknessFactor;
+                if (transmission.thicknessMap) {
+                    const info = await getTextureInfo(transmission.thicknessMap);
+                    if (info) {
+                        pbrMaterial.thicknessTexture = info.texture;
+                        pbrMaterial.thicknessTextureSampler = info.sampler;
+                        pbrMaterial.thicknessTexCoordIndex = info.texCoord;
+                        pbrMaterial.thicknessTexCoordMatrix = info.transform;
+                    }
+                }
+                pbrMaterial.attenuationDistance = transmission.attenuationDistance;
+                pbrMaterial.attenuationColor = transmission.attenuationColor;
+            }
+            if (assetPBRMaterial.clearcoat) {
+                const cc = assetPBRMaterial.clearcoat;
+                pbrMaterial.clearcoat = true;
+                pbrMaterial.clearcoatIntensity = cc.clearCoatFactor;
+                pbrMaterial.clearcoatRoughnessFactor = cc.clearCoatRoughnessFactor;
+                if (cc.clearCoatIntensityMap) {
+                    const info = await getTextureInfo(cc.clearCoatIntensityMap);
+                    if (info) {
+                        pbrMaterial.clearcoatIntensityTexture = info.texture;
+                        pbrMaterial.clearcoatIntensityTextureSampler = info.sampler;
+                        pbrMaterial.clearcoatIntensityTexCoordIndex = info.texCoord;
+                        pbrMaterial.clearcoatIntensityTexCoordMatrix = info.transform;
+                    }
+                }
+                if (cc.clearCoatRoughnessMap) {
+                    const info = await getTextureInfo(cc.clearCoatRoughnessMap);
+                    if (info) {
+                        pbrMaterial.clearcoatRoughnessTexture = info.texture;
+                        pbrMaterial.clearcoatRoughnessTextureSampler = info.sampler;
+                        pbrMaterial.clearcoatRoughnessTexCoordIndex = info.texCoord;
+                        pbrMaterial.clearcoatRoughnessTexCoordMatrix = info.transform;
+                    }
+                }
+                if (cc.clearCoatNormalMap) {
+                    const info = await getTextureInfo(cc.clearCoatNormalMap);
+                    if (info) {
+                        pbrMaterial.clearcoatNormalTexture = info.texture;
+                        pbrMaterial.clearcoatNormalTextureSampler = info.sampler;
+                        pbrMaterial.clearcoatNormalTexCoordIndex = info.texCoord;
+                        pbrMaterial.clearcoatNormalTexCoordMatrix = info.transform;
+                    }
+                }
+            }
+            pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
+            pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
+            if (assetPBRMaterial.common.alphaMode === 'blend') {
+                pbrMaterial.blendMode = 'blend';
+            } else if (assetPBRMaterial.common.alphaMode === 'mask') {
+                pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
+            }
+            if (assetPBRMaterial.common.doubleSided) {
+                pbrMaterial.cullMode = 'none';
+            }
+            pbrMaterial.vertexNormal = !!assetMaterial.common.vertexNormal;
+            return pbrMaterial;
+        }
+        return null;
+    }
+}
+/** @internal */ function processMorphData(subMesh, mesh, morphWeights, morphNames) {
+    const device = getDevice();
+    const numTargets = subMesh.numTargets;
+    if (numTargets === 0) {
+        return;
+    }
+    const attributes = Object.getOwnPropertyNames(subMesh.targets);
+    const positionInfo = subMesh.primitive.vertices['position'];
+    const numVertices = positionInfo ? positionInfo.data.length / getVertexFormatComponentCount(positionInfo.format) >> 0 : 0;
+    const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);
+    for(let i = 0; i < numTargets; i++){
+        weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;
+    }
+    const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));
+    if (textureSize > device.getDeviceCaps().textureCaps.maxTextureSize) {
+        // TODO: reduce morph attributes
+        throw new Error(`Morph target data too large`);
+    }
+    weightsAndOffsets[0] = textureSize;
+    weightsAndOffsets[1] = textureSize;
+    weightsAndOffsets[2] = numVertices;
+    weightsAndOffsets[3] = numTargets;
+    let offset = 0;
+    const textureData = new Float32Array(textureSize * textureSize * 4);
+    for(let attrib = 0; attrib < MAX_MORPH_ATTRIBUTES; attrib++){
+        const index = attributes.indexOf(String(attrib));
+        if (index < 0) {
+            weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = -1;
+            continue;
+        }
+        weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = offset >> 2;
+        const info = subMesh.targets[attrib];
+        if (info.data.length !== numTargets) {
+            console.error(`Invalid morph target data`);
+            return;
+        }
+        for(let t = 0; t < numTargets; t++){
+            const data = info.data[t];
+            for(let i = 0; i < numVertices; i++){
+                for(let j = 0; j < 4; j++){
+                    textureData[offset++] = j < info.numComponents ? data[i * info.numComponents + j] : 1;
+                }
+            }
         }
     }
+    const morphBoundingBox = new BoundingBox();
+    calculateMorphBoundingBox(morphBoundingBox, subMesh.targetBox, weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS), numTargets);
+    const meshAABB = mesh.getBoundingVolume().toAABB();
+    morphBoundingBox.minPoint.addBy(meshAABB.minPoint);
+    morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);
+    const names = {};
+    for(let i = 0; i < numTargets; i++){
+        const name = morphNames?.[i] ?? `Target${i}`;
+        names[name] = i;
+    }
+    mesh.setMorphData({
+        width: textureSize,
+        height: textureSize,
+        data: textureData
+    });
+    mesh.setMorphInfo({
+        data: weightsAndOffsets,
+        names
+    });
+    mesh.setMorphBoundingInfo({
+        targetBoxes: subMesh.targetBox,
+        originBox: new BoundingBox(meshAABB)
+    });
+    mesh.setAnimatedBoundingBox(morphBoundingBox);
+}
+/** @internal */ function getAssetMeshMorphTargetCount(mesh) {
+    let count = 0;
+    for (const subMesh of mesh.subMeshes){
+        count = Math.max(count, subMesh.numTargets);
+    }
+    return count;
+}
+/** @internal */ function getAssetMeshMorphTargetName(mesh, index) {
+    return mesh.morphNames?.[index] ?? `Target${index}`;
+}
+/** @internal */ function calculateMorphBoundingBox(morphBoundingBox, keyframeBoundingBox, weights, numTargets) {
+    morphBoundingBox.minPoint.setXYZ(0, 0, 0);
+    morphBoundingBox.maxPoint.setXYZ(0, 0, 0);
+    for(let i = 0; i < numTargets; i++){
+        const weight = weights[i];
+        const keyframeBox = keyframeBoundingBox[i];
+        morphBoundingBox.minPoint.x += keyframeBox.minPoint.x * weight;
+        morphBoundingBox.minPoint.y += keyframeBox.minPoint.y * weight;
+        morphBoundingBox.minPoint.z += keyframeBox.minPoint.z * weight;
+        morphBoundingBox.maxPoint.x += keyframeBox.maxPoint.x * weight;
+        morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.y * weight;
+        morphBoundingBox.maxPoint.z += keyframeBox.maxPoint.z * weight;
+    }
 }
 
 export { AssetHierarchyNode, AssetScene, AssetSkeleton, NamedObject, SharedModel };