@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/asset/model.js

@@ -2,6 +2,10 @@ import { Vector3, Quaternion, Matrix4x4, Disposable, PathUtils, uint8ArrayToBase
 import { getVertexFormatComponentCount } from '@zephyr3d/device';
 import { Mesh } from '../scene/mesh.js';
 import { BoundingBox } from '../utility/bounding_volume.js';
+import { defaultMeshImportSettings, writeMeshImportSettings } from './mesh_settings.js';
+import { buildLodChain } from './mesh_lod_builder.js';
+import { getMeshoptSimplifier } from './meshopt_simplifier.js';
+import { getAssetMetaPath, inferTextureUsageFromPath, writeTextureImportSettings, defaultTextureImportSettings, inferTextureUsageFromSlot, mergeTextureUsage } from './texture_settings.js';
 import { SceneNode, setSceneMeshAssetBinding } from '../scene/scene_node.js';
 import { SkeletonRig, SkinBinding } from '../animation/skeleton.js';
 import '../animation/animationset.js';
@@ -14,6 +18,7 @@ import { MorphTargetGroupTrack } from '../animation/morphtargetgrouptrack.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 '../animation/animation_bank.js';
 import '../animation/joint_dynamics/collision.js';
 import '../animation/joint_dynamics/solver.js';
 import { createTransformAccess, JointDynamicsSystem } from '../animation/joint_dynamics/joint_dynamics_system.js';
@@ -343,6 +348,9 @@ function getAssetNodePath(node) {
     set activeScene(val) {
         this._activeScene = val;
     }
+    /** Number of image slots the model references */ get imageCount() {
+        return this._imageList.length;
+    }
     getImage(index) {
         return this._imageList[index];
     }
@@ -358,6 +366,101 @@ function getAssetNodePath(node) {
     addPrimitive(prim) {
         this._primitiveList.push(prim);
     }
+    /**
+   * Generates levels of detail for the triangle meshes of the model, as the editor does for
+   * imported meshes: every level is simplified from the source to a fraction of its triangles,
+   * levels stop before one would have fewer than `lodMinTriangles`, and the switch sizes follow
+   * the simplification error. Levels only add indices: vertices, skins and morph targets are
+   * unchanged.
+   *
+   * Call it after importing and before creating scene nodes from the model; meshes that already
+   * have levels of detail are left as they are.
+   *
+   * @param settings - Generation settings, by default those of {@link defaultMeshImportSettings}
+   * @param simplifier - Simplifier to use, meshoptimizer's by default (see {@link getMeshoptSimplifier})
+   * @returns The number of meshes that got levels of detail
+   */ async generateLods(settings, simplifier) {
+        if (this._primitiveMap.size > 0) {
+            console.warn('SharedModel.generateLods(): scene nodes were already created from this model, skipped');
+            return 0;
+        }
+        const defaults = defaultMeshImportSettings();
+        const lodSettings = {
+            lodMinTriangles: settings?.lodMinTriangles ?? defaults.lodMinTriangles,
+            lodReduction: settings?.lodReduction ?? defaults.lodReduction,
+            lodPixelError: settings?.lodPixelError ?? defaults.lodPixelError
+        };
+        simplifier ??= await getMeshoptSimplifier();
+        let count = 0;
+        for (const info of this._primitiveList){
+            if (SharedModel.generatePrimitiveLods(info, simplifier, lodSettings)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /** Gives one primitive its levels of detail, false if it gets none */ static generatePrimitiveLods(info, simplifier, settings) {
+        if (info.type !== 'triangle-list' || (info.lods?.length ?? 0) > 0) {
+            return false;
+        }
+        const positions = SharedModel.readVec3(info, 'position');
+        if (!positions) {
+            return false;
+        }
+        const vertexCount = positions.length / 3;
+        const indexCount = info.indexCount;
+        let indices;
+        if (info.indices) {
+            indices = Uint32Array.from(info.indices.subarray(0, indexCount));
+        } else {
+            // Not indexed: the vertices in order
+            indices = new Uint32Array(indexCount);
+            for(let i = 0; i < indexCount; i++){
+                indices[i] = i;
+            }
+        }
+        if (indices.length < 3 || indices.length % 3 !== 0) {
+            return false;
+        }
+        // The sphere the runtime measures the projected size with, around the bounds box
+        const dx = (info.boxMax.x - info.boxMin.x) * 0.5;
+        const dy = (info.boxMax.y - info.boxMin.y) * 0.5;
+        const dz = (info.boxMax.z - info.boxMin.z) * 0.5;
+        const chain = buildLodChain(simplifier, indices, positions, SharedModel.readVec3(info, 'normal'), Math.sqrt(dx * dx + dy * dy + dz * dz), settings);
+        if (chain.levels.length <= 1) {
+            return false;
+        }
+        info.indices = vertexCount <= 0x10000 ? Uint16Array.from(chain.indices) : chain.indices;
+        info.indexCount = chain.levels[0].indexCount;
+        info.lods = chain.levels.slice(1).map(({ indexStart, indexCount, screenSize, hysteresis })=>({
+                indexStart,
+                indexCount,
+                screenSize,
+                hysteresis
+            }));
+        return true;
+    }
+    /** A float vertex attribute as 3 floats per vertex, null if missing or not float */ static readVec3(info, semantic) {
+        const attrib = info.vertices[semantic];
+        if (!attrib || !(attrib.data instanceof Float32Array)) {
+            return null;
+        }
+        const components = getVertexFormatComponentCount(attrib.format);
+        if (components < 3) {
+            return null;
+        }
+        const vertexCount = Math.floor(attrib.data.length / components);
+        if (components === 3) {
+            return attrib.data.slice(0, vertexCount * 3);
+        }
+        const out = new Float32Array(vertexCount * 3);
+        for(let i = 0; i < vertexCount; i++){
+            out[i * 3] = attrib.data[i * components];
+            out[i * 3 + 1] = attrib.data[i * components + 1];
+            out[i * 3 + 2] = attrib.data[i * components + 2];
+        }
+        return out;
+    }
     sanitizeResourceName(name, fallback) {
         let normalized = (name ?? '').trim();
         if (!normalized) {
@@ -621,10 +724,55 @@ function getAssetNodePath(node) {
    */ addAnimation(animation) {
         this._animations.push(animation);
     }
+    /**
+   * Gives every imported image a `.zmeta` describing what it is, taken from the
+   * material slots that reference it. That is better information than the file
+   * name inference used for textures added any other way, so it is recorded even
+   * when the import does not ask for compression: turning compression on later
+   * then starts from the right usage. An existing `.zmeta` is left alone, so
+   * re-importing keeps settings tuned in the editor.
+   */ async writeImportedTextureSettings(vfs, compress) {
+        const usages = new Map();
+        const visit = (value, key, depth)=>{
+            if (!value || typeof value !== 'object' || depth > 4) {
+                return;
+            }
+            const info = value;
+            if (info.image && 'texCoord' in info) {
+                const usage = inferTextureUsageFromSlot(key, !!info.sRGB);
+                const current = usages.get(info.image);
+                usages.set(info.image, current ? mergeTextureUsage(current, usage) : usage);
+                return;
+            }
+            for (const [k, v] of Object.entries(value)){
+                visit(v, k, depth + 1);
+            }
+        };
+        for (const material of Object.values(this._materialList)){
+            visit(material, '', 0);
+        }
+        for (const img of this._imageList){
+            if (!img?.uri) {
+                continue;
+            }
+            try {
+                if (await vfs.exists(getAssetMetaPath(img.uri))) {
+                    continue;
+                }
+                const usage = usages.get(img) ?? inferTextureUsageFromPath(img.uri);
+                await writeTextureImportSettings(vfs, img.uri, defaultTextureImportSettings(usage, compress ? 'auto' : 'none'));
+            } catch (err) {
+                console.warn(`Failed to write texture settings for ${img.uri}: ${err}`);
+            }
+        }
+    }
     static async writePrimitive(vfs, primitive, path) {
+        // Only the first level: in the editor, levels of detail come from the mesh settings and are
+        // derived from the source, which stays as imported
+        const indices = primitive.indices && (primitive.lods?.length ?? 0) > 0 ? primitive.indices.subarray(0, primitive.indexCount) : primitive.indices;
         const data = {
             vertices: {},
-            indices: primitive.indices ? uint8ArrayToBase64(new Uint8Array(primitive.indices.buffer, primitive.indices.byteOffset, primitive.indices.byteLength)) : null,
+            indices: indices ? uint8ArrayToBase64(new Uint8Array(indices.buffer, indices.byteOffset, indices.byteLength)) : null,
             indexType: primitive.indices ? primitive.indices instanceof Uint16Array ? 'u16' : 'u32' : '',
             indexCount: primitive.indexCount,
             type: primitive.type,
@@ -711,6 +859,7 @@ function getAssetNodePath(node) {
                     img.mimeType = '';
                 }
             }
+            await this.writeImportedTextureSettings(dstVFS, !!this._preprocessOptions?.compressTextures);
         }
         const materialKeys = Object.keys(this._materialList);
         if (materialKeys.length > 0) {
@@ -748,6 +897,24 @@ function getAssetNodePath(node) {
                 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);
+                const options = this._preprocessOptions;
+                if ((options?.compressVertices || options?.generateLods) && !await dstVFS.exists(getAssetMetaPath(path))) {
+                    // Without a .zmeta a mesh ships as it is, so only an opt-in needs one
+                    const settings = defaultMeshImportSettings(options.compressVertices ? 'meshopt' : 'none');
+                    if (options.generateLods) {
+                        settings.lodEnabled = true;
+                        if (Number.isInteger(options.lodMinTriangles) && options.lodMinTriangles >= 1) {
+                            settings.lodMinTriangles = options.lodMinTriangles;
+                        }
+                        if (typeof options.lodReduction === 'number' && options.lodReduction > 0 && options.lodReduction < 1) {
+                            settings.lodReduction = options.lodReduction;
+                        }
+                        if (typeof options.lodPixelError === 'number' && options.lodPixelError > 0) {
+                            settings.lodPixelError = options.lodPixelError;
+                        }
+                    }
+                    await writeMeshImportSettings(dstVFS, path, settings);
+                }
                 info.path = path;
             }
         }
@@ -1389,6 +1556,9 @@ function getAssetNodePath(node) {
         }
         primitive.primitiveType = info.type;
         primitive.indexCount = info.indexCount;
+        if (info.lods) {
+            primitive.lods = info.lods;
+        }
         primitive.setBoundingVolume(new BoundingBox(info.boxMin, info.boxMax));
         return primitive;
     }