@zephyr3d/scene 0.9.5 → 0.9.7

package/dist/asset/model.js

@@ -1,4 +1,4 @@
-import { Vector3, Quaternion, Matrix4x4, Disposable, uint8ArrayToBase64, ASSERT, DRef, Vector4 } from '@zephyr3d/base';
+import { Vector3, Quaternion, Matrix4x4, Disposable, PathUtils, uint8ArrayToBase64, ASSERT, DRef, Vector4 } from '@zephyr3d/base';
 import { getVertexFormatComponentCount } from '@zephyr3d/device';
 import { Mesh } from '../scene/mesh.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
@@ -21,6 +21,7 @@ import { Primitive } from '../render/primitive.js';
 import { UnlitMaterial } from '../material/unlit.js';
 import { PBRSpecularGlossinessMaterial } from '../material/pbrsg.js';
 import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
+import { MToonMaterial } from '../material/mtoon.js';
 
 /**
  * Named object interface for model loading
@@ -181,6 +182,7 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
     /** Joints of the skeleton */ joints;
     /** Inverse of the binding matrices of the joints */ inverseBindMatrices;
     /** Binding pose matrices of the joints */ bindPose;
+    /** Explicit humanoid joint mapping, when supplied by the source asset. */ humanoidJointMapping;
     /**
    * Creates an instance of AssetSkeleton
    * @param name - Name of the skeleton
@@ -191,6 +193,7 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
         this.joints = [];
         this.inverseBindMatrices = [];
         this.bindPose = [];
+        this.humanoidJointMapping = null;
     }
     /**
    * Adds a joint to the skeleton
@@ -327,6 +330,202 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
     addPrimitive(prim) {
         this._primitiveList.push(prim);
     }
+    sanitizeResourceName(name, fallback) {
+        let normalized = (name ?? '').trim();
+        if (!normalized) {
+            normalized = fallback;
+        }
+        normalized = normalized.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_');
+        normalized = normalized.replace(/\s+/g, ' ').trim();
+        normalized = normalized.replace(/[. ]+$/g, '');
+        return normalized || fallback;
+    }
+    getReimportPoolKey(baseName, ext) {
+        return `${ext.toLowerCase()}|${baseName}`;
+    }
+    getResourceBasename(path, ext) {
+        return path ? PathUtils.basename(path, ext || PathUtils.extname(path)) : '';
+    }
+    getResourceNumericSuffix(baseName, candidateBaseName) {
+        if (candidateBaseName === baseName) {
+            return 0;
+        }
+        const match = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}_([0-9]+)$`).exec(candidateBaseName);
+        return match ? Number.parseInt(match[1], 10) : Number.MAX_SAFE_INTEGER;
+    }
+    registerReusableResourcePath(pools, path) {
+        const ext = PathUtils.extname(path).toLowerCase();
+        const baseName = this.getResourceBasename(path, ext);
+        const register = (keyBaseName)=>{
+            const key = this.getReimportPoolKey(keyBaseName, ext);
+            let candidates = pools.get(key);
+            if (!candidates) {
+                candidates = new Set();
+                pools.set(key, candidates);
+            }
+            candidates.add(path);
+        };
+        register(baseName);
+        const strippedBaseName = baseName.replace(/_[0-9]+$/u, '');
+        if (strippedBaseName && strippedBaseName !== baseName) {
+            register(strippedBaseName);
+        }
+    }
+    collectReferencedAssetPaths(value, destPath, extensions, out) {
+        if (typeof value === 'string') {
+            const normalizedPath = PathUtils.normalize(value);
+            const ext = PathUtils.extname(normalizedPath).toLowerCase();
+            const normalizedDestPath = PathUtils.normalize(destPath);
+            if (extensions.has(ext) && (normalizedPath === normalizedDestPath || normalizedPath.startsWith(normalizedDestPath.endsWith('/') ? normalizedDestPath : `${normalizedDestPath}/`))) {
+                out.add(normalizedPath);
+            }
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value){
+                this.collectReferencedAssetPaths(item, destPath, extensions, out);
+            }
+            return;
+        }
+        if (value && typeof value === 'object') {
+            for (const item of Object.values(value)){
+                this.collectReferencedAssetPaths(item, destPath, extensions, out);
+            }
+        }
+    }
+    async collectReferencedAssetPathsFromJsonFile(destVFS, jsonPath, destPath, extensions) {
+        if (!await destVFS.exists(jsonPath)) {
+            return new Set();
+        }
+        try {
+            const content = await destVFS.readFile(jsonPath, {
+                encoding: 'utf8'
+            });
+            const json = JSON.parse(content);
+            const out = new Set();
+            this.collectReferencedAssetPaths(json, destPath, extensions, out);
+            return out;
+        } catch (err) {
+            console.warn(`Read existing import manifest failed: ${jsonPath}: ${err}`);
+            return new Set();
+        }
+    }
+    async createReimportResourcePools(destVFS, destPath, prefabPath) {
+        const pools = new Map();
+        if (!await destVFS.exists(prefabPath)) {
+            return pools;
+        }
+        const materialAndMeshPaths = await this.collectReferencedAssetPathsFromJsonFile(destVFS, prefabPath, destPath, new Set([
+            '.zmtl',
+            '.zmsh'
+        ]));
+        for (const path of materialAndMeshPaths){
+            this.registerReusableResourcePath(pools, path);
+        }
+        const materialPaths = Array.from(materialAndMeshPaths).filter((path)=>PathUtils.extname(path).toLowerCase() === '.zmtl');
+        const imageExtensions = new Set([
+            '.jpg',
+            '.jpeg',
+            '.png',
+            '.webp',
+            '.tga',
+            '.hdr',
+            '.ktx',
+            '.ktx2'
+        ]);
+        for (const materialPath of materialPaths){
+            const texturePaths = await this.collectReferencedAssetPathsFromJsonFile(destVFS, materialPath, destPath, imageExtensions);
+            for (const texturePath of texturePaths){
+                this.registerReusableResourcePath(pools, texturePath);
+            }
+        }
+        return pools;
+    }
+    consumeReusableResourcePath(pools, baseName, ext, usedPaths) {
+        const candidates = pools.get(this.getReimportPoolKey(baseName, ext));
+        if (!candidates || candidates.size === 0) {
+            return null;
+        }
+        const sorted = Array.from(candidates).filter((path)=>!usedPaths.has(path)).sort((a, b)=>{
+            const aSuffix = this.getResourceNumericSuffix(baseName, this.getResourceBasename(a, ext));
+            const bSuffix = this.getResourceNumericSuffix(baseName, this.getResourceBasename(b, ext));
+            if (aSuffix !== bSuffix) {
+                return aSuffix - bSuffix;
+            }
+            return a.localeCompare(b);
+        });
+        const selected = sorted[0] ?? null;
+        if (selected) {
+            usedPaths.add(selected);
+        }
+        return selected;
+    }
+    async createUniqueResourcePath(destVFS, destPath, baseName, ext, usedPaths, fallback) {
+        const sanitizedBase = this.sanitizeResourceName(baseName, fallback);
+        for(let suffix = 0;; suffix++){
+            const candidateName = suffix > 0 ? `${sanitizedBase}_${suffix}` : sanitizedBase;
+            const candidatePath = destVFS.join(destPath, `${candidateName}${ext}`);
+            if (!usedPaths.has(candidatePath) && !await destVFS.exists(candidatePath)) {
+                usedPaths.add(candidatePath);
+                return candidatePath;
+            }
+        }
+    }
+    async tryReuseExactResourcePath(destVFS, destPath, baseName, ext, usedPaths, fallback) {
+        const sanitizedBase = this.sanitizeResourceName(baseName, fallback);
+        const candidatePath = destVFS.join(destPath, `${sanitizedBase}${ext}`);
+        if (!usedPaths.has(candidatePath) && await destVFS.exists(candidatePath)) {
+            usedPaths.add(candidatePath);
+            return candidatePath;
+        }
+        return null;
+    }
+    collapseCompositeTextureName(name) {
+        const normalized = (name ?? '').trim();
+        if (!normalized) {
+            return normalized;
+        }
+        const separatorIndex = normalized.indexOf('-');
+        if (separatorIndex <= 0 || separatorIndex >= normalized.length - 1) {
+            return normalized;
+        }
+        const left = normalized.slice(0, separatorIndex).trim();
+        const right = normalized.slice(separatorIndex + 1).trim();
+        if (!left || !right) {
+            return normalized;
+        }
+        const leftParts = left.split('_');
+        const rightParts = right.split('_');
+        let prefixLength = 0;
+        while(prefixLength < leftParts.length - 1 && prefixLength < rightParts.length - 1 && leftParts[prefixLength] === rightParts[prefixLength]){
+            prefixLength++;
+        }
+        if (prefixLength <= 0) {
+            return normalized;
+        }
+        const prefix = leftParts.slice(0, prefixLength).join('_');
+        const leftSuffix = leftParts.slice(prefixLength).join('_');
+        const rightSuffix = rightParts.slice(prefixLength).join('_');
+        if (!leftSuffix || !rightSuffix) {
+            return normalized;
+        }
+        return `${prefix}_${leftSuffix}-${rightSuffix}`;
+    }
+    getImageBaseName(img, index, fallback) {
+        if (img?.name?.trim()) {
+            return this.collapseCompositeTextureName(img.name);
+        }
+        if (img?.uri) {
+            return this.collapseCompositeTextureName(PathUtils.basename(img.uri, PathUtils.extname(img.uri)));
+        }
+        return `${fallback}_texture_${index}`;
+    }
+    getMaterialBaseName(material, key, fallback) {
+        return material?.name?.trim() || `${fallback}_material_${key}`;
+    }
+    getPrimitiveBaseName(info, index, fallback) {
+        return info?.name?.trim() || `${fallback}_mesh_${index}`;
+    }
     /**
    * Adds a model-level morph target group.
    * @param group - Morph target group to add
@@ -430,6 +629,11 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
     }
     /** preprocess */ async preprocess(manager, name, destPath, srcVFS, dstVFS) {
         const destName = name;
+        const usedPaths = new Set();
+        const rebuildMaterial = this._preprocessOptions?.rebuildMaterial ?? true;
+        const prefabName = name.endsWith('.zprefab') ? name : `${name}.zprefab`;
+        const prefabPath = dstVFS.join(destPath, prefabName);
+        const reusableResourcePools = await this.createReimportResourcePools(dstVFS, destPath, prefabPath);
         if (this._imageList.length > 0) {
             console.info(`Importing ${this._imageList.length} textures`);
             for(let i = 0; i < this._imageList.length; i++){
@@ -457,7 +661,8 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
                     continue;
                 }
                 ASSERT(!!ext, `Unknown image mime type: ${mimeType}`);
-                const path = dstVFS.join(destPath, `${destName}_texture_${i}${ext}`);
+                const baseName = this.sanitizeResourceName(this.getImageBaseName(img, i, destName), `${destName}_texture_${i}`);
+                const path = await this.tryReuseExactResourcePath(dstVFS, destPath, baseName, ext, usedPaths, `${destName}_texture_${i}`) ?? this.consumeReusableResourcePath(reusableResourcePools, baseName, ext, usedPaths) ?? await this.createUniqueResourcePath(dstVFS, destPath, baseName, ext, usedPaths, `${destName}_texture_${i}`);
                 if (img.uri) {
                     img.data = new Uint8Array(await srcVFS.readFile(img.uri, {
                         encoding: 'binary'
@@ -476,8 +681,16 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
         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 material = this._materialList[k];
+                const baseName = this.sanitizeResourceName(this.getMaterialBaseName(material, k, destName), `${destName}_material_${k}`);
+                const path = await this.tryReuseExactResourcePath(dstVFS, destPath, baseName, '.zmtl', usedPaths, `${destName}_material_${k}`) ?? this.consumeReusableResourcePath(reusableResourcePools, baseName, '.zmtl', usedPaths) ?? await this.createUniqueResourcePath(dstVFS, destPath, baseName, '.zmtl', usedPaths, `${destName}_material_${k}`);
+                if (!rebuildMaterial && await dstVFS.exists(path)) {
+                    material.path = path;
+                    continue;
+                }
+                material.path = '';
+                const m = await this.createMaterial(manager, material, dstVFS);
+                material.path = path;
                 const data = await manager.serializeObject(m);
                 const content = JSON.stringify({
                     type: 'Default',
@@ -487,7 +700,6 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
                     encoding: 'utf8',
                     create: true
                 });
-                this._materialList[k].path = path;
                 m.dispose();
             }
         }
@@ -498,7 +710,8 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
                 if (!info) {
                     continue;
                 }
-                const path = dstVFS.join(destPath, `${destName}_mesh_${i}.zmsh`);
+                const baseName = this.sanitizeResourceName(this.getPrimitiveBaseName(info, i, destName), `${destName}_mesh_${i}`);
+                const path = await this.tryReuseExactResourcePath(dstVFS, destPath, baseName, '.zmsh', usedPaths, `${destName}_mesh_${i}`) ?? this.consumeReusableResourcePath(reusableResourcePools, baseName, '.zmsh', usedPaths) ?? await this.createUniqueResourcePath(dstVFS, destPath, baseName, '.zmsh', usedPaths, `${destName}_mesh_${i}`);
                 await SharedModel.writePrimitive(dstVFS, info, path);
                 info.path = path;
             }
@@ -641,6 +854,30 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
         }
         return null;
     }
+    remapHumanoidJointMapping(mapping, nodeMap) {
+        if (!mapping) {
+            return null;
+        }
+        const remap = (source)=>{
+            if (!source) {
+                return undefined;
+            }
+            const result = {};
+            for (const key of Object.keys(source)){
+                const node = nodeMap.get(source[key]);
+                if (node) {
+                    result[key] = node;
+                }
+            }
+            return Object.keys(result).length > 0 ? result : undefined;
+        };
+        const body = remap(mapping.body);
+        return body ? {
+            body,
+            leftHand: remap(mapping.leftHand),
+            rightHand: remap(mapping.rightHand)
+        } : null;
+    }
     async createSceneNode(manager, scene, instancing, saveMeshes, saveSkeletons, saveAnimations, saveJointDynamics, srcVFS) {
         const group = new SceneNode(scene);
         const nodeMap = new Map();
@@ -674,7 +911,11 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
                     const rigKey = SkeletonRig.getRigKey(joints, rootJoint);
                     let rig = rigMap.get(rigKey);
                     if (!rig) {
-                        rig = new SkeletonRig(joints, sk.bindPose, {
+                        const humanoidJointMapping = this.remapHumanoidJointMapping(sk.humanoidJointMapping, nodeMap);
+                        rig = new SkeletonRig(joints, sk.bindPose, humanoidJointMapping ? {
+                            rootJoint,
+                            humanoidJointMapping
+                        } : {
                             rootJoint
                         });
                         rigMap.set(rigKey, rig);
@@ -1100,6 +1341,18 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
             }
             return t;
         }
+        async function setMaterialTexture(material, propertyPrefix, textureInfo) {
+            if (!textureInfo) {
+                return;
+            }
+            const info = await getTextureInfo(textureInfo);
+            if (info) {
+                material[`${propertyPrefix}Texture`] = info.texture;
+                material[`${propertyPrefix}TextureSampler`] = info.sampler;
+                material[`${propertyPrefix}TexCoordIndex`] = info.texCoord;
+                material[`${propertyPrefix}TexCoordMatrix`] = info.transform;
+            }
+        }
         if (assetMaterial.type === 'unlit') {
             const unlitAssetMaterial = assetMaterial;
             const unlitMaterial = new UnlitMaterial();
@@ -1123,6 +1376,92 @@ import { PBRMetallicRoughnessMaterial } from '../material/pbrmr.js';
                 unlitMaterial.cullMode = 'none';
             }
             return unlitMaterial;
+        } else if (assetMaterial.type === 'mtoon') {
+            const mtoonAssetMaterial = assetMaterial;
+            const mtoonMaterial = new MToonMaterial();
+            const mtoonTextureTarget = mtoonMaterial;
+            mtoonMaterial.albedoColor = mtoonAssetMaterial.diffuse ?? Vector4.one();
+            await setMaterialTexture(mtoonTextureTarget, 'albedo', mtoonAssetMaterial.diffuseMap);
+            await setMaterialTexture(mtoonTextureTarget, 'normal', mtoonAssetMaterial.common.normalMap);
+            mtoonMaterial.normalScale = mtoonAssetMaterial.common.bumpScale ?? 1;
+            await setMaterialTexture(mtoonTextureTarget, 'emissive', mtoonAssetMaterial.common.emissiveMap);
+            mtoonMaterial.emissiveColor = mtoonAssetMaterial.common.emissiveColor ?? Vector3.zero();
+            mtoonMaterial.emissiveStrength = mtoonAssetMaterial.common.emissiveStrength ?? 1;
+            if (mtoonAssetMaterial.shadeColorFactor) {
+                mtoonMaterial.shadeColorFactor = mtoonAssetMaterial.shadeColorFactor;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'shadeMultiply', mtoonAssetMaterial.shadeMultiplyMap);
+            if (mtoonAssetMaterial.shadingShiftFactor !== undefined) {
+                mtoonMaterial.shadingShiftFactor = mtoonAssetMaterial.shadingShiftFactor;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'shadingShift', mtoonAssetMaterial.shadingShiftMap);
+            if (mtoonAssetMaterial.shadingShiftTextureScale !== undefined) {
+                mtoonMaterial.shadingShiftTextureScale = mtoonAssetMaterial.shadingShiftTextureScale;
+            }
+            if (mtoonAssetMaterial.shadingToonyFactor !== undefined) {
+                mtoonMaterial.shadingToonyFactor = mtoonAssetMaterial.shadingToonyFactor;
+            }
+            if (mtoonAssetMaterial.giEqualizationFactor !== undefined) {
+                mtoonMaterial.giEqualizationFactor = mtoonAssetMaterial.giEqualizationFactor;
+            }
+            if (mtoonAssetMaterial.matcapFactor) {
+                mtoonMaterial.matcapFactor = mtoonAssetMaterial.matcapFactor;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'matcap', mtoonAssetMaterial.matcapMap);
+            if (mtoonAssetMaterial.parametricRimColorFactor) {
+                mtoonMaterial.parametricRimColorFactor = mtoonAssetMaterial.parametricRimColorFactor;
+            }
+            if (mtoonAssetMaterial.parametricRimFresnelPowerFactor !== undefined) {
+                mtoonMaterial.parametricRimFresnelPowerFactor = mtoonAssetMaterial.parametricRimFresnelPowerFactor;
+            }
+            if (mtoonAssetMaterial.parametricRimLiftFactor !== undefined) {
+                mtoonMaterial.parametricRimLiftFactor = mtoonAssetMaterial.parametricRimLiftFactor;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'rimMultiply', mtoonAssetMaterial.rimMultiplyMap);
+            if (mtoonAssetMaterial.rimLightingMixFactor !== undefined) {
+                mtoonMaterial.rimLightingMixFactor = mtoonAssetMaterial.rimLightingMixFactor;
+            }
+            if (mtoonAssetMaterial.outlineWidthMode !== undefined) {
+                mtoonMaterial.outlineWidthMode = mtoonAssetMaterial.outlineWidthMode;
+            }
+            if (mtoonAssetMaterial.outlineWidthFactor !== undefined) {
+                mtoonMaterial.outlineWidthFactor = mtoonAssetMaterial.outlineWidthFactor;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'outlineWidthMultiply', mtoonAssetMaterial.outlineWidthMultiplyMap);
+            if (mtoonAssetMaterial.outlineColorFactor) {
+                mtoonMaterial.outlineColorFactor = mtoonAssetMaterial.outlineColorFactor;
+            }
+            if (mtoonAssetMaterial.outlineLightingMixFactor !== undefined) {
+                mtoonMaterial.outlineLightingMixFactor = mtoonAssetMaterial.outlineLightingMixFactor;
+            }
+            if (mtoonAssetMaterial.outlineUsesTangentNormals !== undefined) {
+                mtoonMaterial.outlineUsesTangentNormals = mtoonAssetMaterial.outlineUsesTangentNormals;
+            }
+            await setMaterialTexture(mtoonTextureTarget, 'uvAnimationMask', mtoonAssetMaterial.uvAnimationMaskMap);
+            if (mtoonAssetMaterial.uvAnimationScrollXSpeedFactor !== undefined) {
+                mtoonMaterial.uvAnimationScrollXSpeedFactor = mtoonAssetMaterial.uvAnimationScrollXSpeedFactor;
+            }
+            if (mtoonAssetMaterial.uvAnimationScrollYSpeedFactor !== undefined) {
+                mtoonMaterial.uvAnimationScrollYSpeedFactor = mtoonAssetMaterial.uvAnimationScrollYSpeedFactor;
+            }
+            if (mtoonAssetMaterial.uvAnimationRotationSpeedFactor !== undefined) {
+                mtoonMaterial.uvAnimationRotationSpeedFactor = mtoonAssetMaterial.uvAnimationRotationSpeedFactor;
+            }
+            if (mtoonAssetMaterial.transparentWithZWrite !== undefined) {
+                mtoonMaterial.transparentWithZWrite = mtoonAssetMaterial.transparentWithZWrite;
+            }
+            if (mtoonAssetMaterial.renderQueueOffsetNumber !== undefined) {
+                mtoonMaterial.renderQueueOffsetNumber = mtoonAssetMaterial.renderQueueOffsetNumber;
+            }
+            if (mtoonAssetMaterial.common.alphaMode === 'blend') {
+                mtoonMaterial.blendMode = 'blend';
+            } else if (mtoonAssetMaterial.common.alphaMode === 'mask') {
+                mtoonMaterial.alphaCutoff = mtoonAssetMaterial.common.alphaCutoff;
+            }
+            if (mtoonAssetMaterial.common.doubleSided) {
+                mtoonMaterial.cullMode = 'none';
+            }
+            return mtoonMaterial;
         } else if (assetMaterial.type === 'pbrSpecularGlossiness') {
             const assetPBRMaterial = assetMaterial;
             const pbrMaterial = new PBRSpecularGlossinessMaterial();