@needle-tools/gltf-build-pipeline 1.4.1-beta.1 → 1.4.1-beta.4

package/CHANGELOG.md

@@ -4,10 +4,20 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [1.4.1-beta] - 2023-03-13
+## [1.4.1-beta.4] - 2023-03-15
+- add: auto LODs now calculate mesh density
+- change: generate 6 LOD level with roughly 0.6 ratio of the previous level
+- change: bump gltf-transform to 3.10.1 to fix simplifier
+
+## [1.4.1-beta.3] - 2023-03-14
+- fix: wait for mesh simplifier to be ready
+
+## [1.4.1-beta.2] - 2023-03-13
 - change: update gltf-transform to `^3.10.0`
 - change: progressive mesh transform does now set ratio for LODs (see [simplifier issue 661 on github](https://github.com/zeux/meshoptimizer/issues/661))
 - fix: issue where progressive meshes were not generated if a mesh was multiple times in the glTF
+- change: simplify to use ratio, fix issue where not all meshes were processed
+- change: auto LOD max error set to 0.1
 
 ## [1.4.0-beta] - 2023-03-12
 - add: progressive mesh transform to automatically generate mesh LOD levels (currently we only generate one low poly version)

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.d.ts

@@ -1,15 +1,18 @@
 import { Extension, ExtensionProperty, Graph, IProperty, Property, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
-export declare interface IProgressiveTextureInfo {
+export declare interface IProgressiveLoadingInfo {
+    /** guid of the asset the LODs belong to */
     guid: string;
+    /** paths to the LOD level files */
     uri?: string | Array<string>;
+    density?: number;
 }
 export declare function generateGuid(): string;
 export declare class NEEDLE_progressive extends Extension {
     static EXTENSION_NAME: string;
     extensionName: string;
-    static create(graph: Graph<Property<IProperty>>, data: IProgressiveTextureInfo): NEEDLE_progressive_texture_property;
-    create(data: IProgressiveTextureInfo): NEEDLE_progressive_texture_property;
+    static create(graph: Graph<Property<IProperty>>, data: IProgressiveLoadingInfo): NEEDLE_progressive_texture_property;
+    create(data: IProgressiveLoadingInfo): NEEDLE_progressive_texture_property;
     read(_context: ReaderContext): this;
     write(context: WriterContext): this;
 }
@@ -19,5 +22,5 @@ export declare class NEEDLE_progressive_texture_property extends ExtensionProper
     parentTypes: PropertyType[];
     propertyType: string;
     init(): void;
-    model: IProgressiveTextureInfo;
+    model: IProgressiveLoadingInfo;
 }

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,4 +1,4 @@
 import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
 import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
 export declare const needle_mesh_transform: (_options: SimplifyOptions) => Transform;
-export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): void;
+export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<void>;

package/dist/transforms/needle_mesh_transform.js

@@ -88,10 +88,24 @@ async function simplifierTransform(document, _context, _options) {
     }
     return true;
 }
-export function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
+export async function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
     const logger = document.getLogger();
     logger.debug(`[${NAME}]: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
     weldPrimitive(document, prim, weldOptions);
+    // make sure we wait for the mesh simplifier to be ready
+    if (meshOptions.simplifier && meshOptions.simplifier?.ready instanceof Promise) {
+        const res = await meshOptions.simplifier?.ready
+            .then(() => {
+            // ready!
+            return true;
+        })
+            .catch((err) => {
+            console.error(`[${NAME}]: Simplifier failed to load...\n${err}`);
+            return false;
+        });
+        if (!res)
+            return;
+    }
     logger.debug(`[${NAME}]: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
     simplifyPrimitive(document, prim, meshOptions);
 }

package/dist/transforms/needle_progressive.js

@@ -3,7 +3,7 @@ import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureSlots } from '@gltf-transf
 import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive, generateGuid } from "../extensions/NEEDLE_progressive/index.js";
 import { createOpaqueExtension, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
 import path from 'path';
-import { existsSync } from 'fs';
+import { existsSync, rmSync, statSync } from 'fs';
 import { addToCache, getKey, tryGetFromCache } from '../cache/index.js';
 import sharp from "sharp";
 import { foreachGLTF } from '../utils/index.js';
@@ -303,14 +303,30 @@ export function make_progressive_meshes(filePath, _options, opts) {
         console.log("> Progressive Mesh Transform: " + filename);
         let index = 0;
         // the lowest LOD (last entry) will be saved in the original file
+        const MAX_LODS = 6;
         const LODS = [
-            { error: 0 },
-            { ratio: 0.5, error: 1 },
-            { ratio: 0.25, error: 1 },
+            {
+                ratio: 1,
+                error: 0,
+                lockBorder: true
+            },
         ];
+        for (let l = 0; l < MAX_LODS; l++) {
+            const t = l / MAX_LODS;
+            const latest = LODS[LODS.length - 1];
+            const ratio = latest.ratio * .6;
+            const error = .1 + t * 0.4;
+            LODS.push({
+                ratio: ratio,
+                error,
+                lockBorder: true,
+                // toleranceNormal: 0.1 + t * 0.1,
+            });
+        }
         /** Map of visited GUID -> extension */
         const visited = new Map();
         const meshes = doc.getRoot().listMeshes();
+        await MeshoptSimplifier.ready;
         for (const mesh of meshes) {
             // TODO: skip meshes that are already below a certain threshold (E.g. just 4 vertices)
             const settings = mesh.getExtension(NEEDLE_progressive_mesh_settings.EXTENSION_NAME);
@@ -333,24 +349,65 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 const existingPaths = visited.get(settings.guid).paths;
                 generatedLODs.push(...existingPaths);
             }
+            /** async simplification tasks... */
+            const tasks = new Array();
             if (needsToGenerateLODs) {
                 // produce LODS, skip the last level because it will be saved in the original file
                 for (let level = 0; level < LODS.length - 1; level++) {
                     const lod = LODS[level];
-                    console.log(`${NAME}: Generate LOD ${level}`);
                     const guid = settings.guid;
-                    const lodPath = createMeshLod(doc, outputDirectory, level, mesh, guid, lod);
-                    generatedLODs.push(lodPath);
+                    // TODO: check if the LOD level did actually change the mesh - otherwise we can just skip generating lower resolutions
+                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, guid, lod);
+                    lodTask.then(res => {
+                        console.log(`${NAME}: ${mesh.getName()} Register LOD ${level}`);
+                        if (res.success) {
+                            generatedLODs[level] = res.path;
+                        }
+                    });
+                    tasks.push(lodTask);
                 }
+                // wait for all LODs to be generated
+                await Promise.all(tasks);
+                tasks.length = 0;
             }
+            // compare LOD results and ignore if the mesh did not change
+            let prevSize = -1;
+            for (let i = 1; i < generatedLODs.length; i++) {
+                const path = generatedLODs[i];
+                if (!path) {
+                    console.log(`${NAME}: LOD ${i} was not generated for ${mesh.getName()}`);
+                    continue;
+                }
+                const fullPath = outputDirectory + path;
+                if (existsSync(fullPath)) {
+                    const lastSize = prevSize;
+                    const sizeOnDisc = statSync(fullPath).size;
+                    prevSize = sizeOnDisc;
+                    const diff = lastSize - sizeOnDisc;
+                    if (diff < 100) {
+                        console.log(`${NAME}: LOD ${i} did not change for ${mesh.getName()} - ignore it`);
+                        generatedLODs.splice(i, 1);
+                        rmSync(fullPath);
+                        i--;
+                    }
+                }
+            }
+            let maxDensity = 0;
             for (const prim of mesh.listPrimitives()) {
-                const lastLod = LODS[LODS.length - 1];
-                console.log(`${NAME}: ${filename} LOD ${LODS.length - 1}`);
-                simplifyMesh(doc, mesh, prim, lastLod);
+                const lodsCount = generatedLODs.length;
+                const lastLod = LODS[lodsCount];
+                console.log(`${NAME}: ${mesh.getName()} LOD ${LODS.length - 1}`);
+                const density = calculateMeshDensity(prim);
+                maxDensity = Math.max(maxDensity, density);
+                const task = simplifyMesh(doc, mesh, prim, lastLod);
+                tasks.push(task);
             }
+            await Promise.all(tasks);
+            tasks.length = 0;
             const model = progressiveExt.create({
                 guid: settings.guid,
                 uri: generatedLODs.map(l => l),
+                density: maxDensity,
             });
             mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
             index++;
@@ -371,17 +428,20 @@ export function make_progressive_meshes(filePath, _options, opts) {
  * @param guid a unique identifier for the mesh
  * @param error the error to use for simplification. Higher means more simplification
  */
-function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
+async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
     const newDoc = new Document();
     const newScene = newDoc.createScene();
     newDoc.createBuffer();
     const newNode = newDoc.createNode();
     newScene.addChild(newNode);
-    newNode.setName("node_" + level + "_" + guid);
+    newNode.setName("LOD " + level + "_" + guid);
     newNode.setTranslation([0, 0, 0]);
     const newMesh = newDoc.createMesh();
+    newMesh.setName(mesh.getName() + " LOD " + level);
     newNode.setMesh(newMesh);
     const primitives = mesh.listPrimitives();
+    const tasks = new Array();
+    // let didRunSimplification = false;
     for (const prim of primitives) {
         const newMat = newDoc.createMaterial();
         const newPrim = newDoc.createPrimitive();
@@ -415,12 +475,23 @@ function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
             console.log(`${NAME}: Copy primitive ${name} extension`);
             newPrim.setExtension(name, copy);
         }
-    }
-    if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
-        for (const prim of newMesh.listPrimitives()) {
-            simplifyMesh(newDoc, newMesh, prim, lodLevel);
+        if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
+            if (lodLevel.error > 0 || lodLevel.ratio < 1) {
+                // didRunSimplification = true;
+                const task = simplifyMesh(newDoc, newMesh, newPrim, lodLevel);
+                tasks.push(task);
+            }
         }
     }
+    await Promise.all(tasks);
+    // if we run simplify but the mesh didnt change
+    // if (didRunSimplification) {
+    // 	let anyPrimitiveDidChange = false;
+    // 	for (const res of results) {
+    // 		if (res) anyPrimitiveDidChange = true;
+    // 	}
+    // 	if (!anyPrimitiveDidChange) return false;
+    // }
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
     if (!progressiveExt || !progressiveExt.create) {
         console.error("Failed to create progressive extension");
@@ -445,22 +516,101 @@ function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
     const filename = name + ext;
     const outName = basePath + filename;
     console.log(`${NAME}: Write mesh LOD ${level} to \"${filename}\" with: ${JSON.stringify(lodLevel)}`);
-    newIo.write(outName, newDoc);
-    return filename;
+    await newIo.write(outName, newDoc);
+    return { path: filename, success: true };
+}
+function calculateMeshDensity(prim) {
+    const bounds = {
+        min: [Infinity, Infinity, Infinity],
+        max: [-Infinity, -Infinity, -Infinity],
+    };
+    const position = prim.getAttribute('POSITION');
+    if (!position)
+        return -1;
+    let tempVec3 = [0, 0, 0];
+    for (let i = 0; i < position.getCount(); i++) {
+        tempVec3 = position.getElement(i, tempVec3);
+        expandBounds(tempVec3, bounds);
+    }
+    const indices = prim.getIndices();
+    let area = 0;
+    if (indices) {
+        // calculate surface area
+        const numIndices = indices.getCount();
+        const indexArray = indices.getArray();
+        const v0 = [0, 0, 0];
+        const v1 = [0, 0, 0];
+        const v2 = [0, 0, 0];
+        const e1 = [0, 0, 0];
+        const e2 = [0, 0, 0];
+        const boundSizeX = bounds.max[0] - bounds.min[0];
+        const boundSizeY = bounds.max[1] - bounds.min[1];
+        const boundSizeZ = bounds.max[2] - bounds.min[2];
+        const maxBounds = Math.max(boundSizeX, boundSizeY, boundSizeZ);
+        for (let i = 0; i < numIndices; i += 3) {
+            const i0 = indexArray[i + 0];
+            const i1 = indexArray[i + 1];
+            const i2 = indexArray[i + 2];
+            position.getElement(i0, v0);
+            position.getElement(i1, v1);
+            position.getElement(i2, v2);
+            e1[0] = v1[0] - v0[0];
+            e1[1] = v1[1] - v0[1];
+            e1[2] = v1[2] - v0[2];
+            e2[0] = v2[0] - v0[0];
+            e2[1] = v2[1] - v0[1];
+            e2[2] = v2[2] - v0[2];
+            // Normalize vertex distance in mesh bounds
+            e1[0] /= maxBounds;
+            e1[1] /= maxBounds;
+            e1[2] /= maxBounds;
+            e2[0] /= maxBounds;
+            e2[1] /= maxBounds;
+            e2[2] /= maxBounds;
+            // Cross product to get the area of the triangle
+            const cross = [
+                e1[1] * e2[2] - e1[2] * e2[1],
+                e1[2] * e2[0] - e1[0] * e2[2],
+                e1[0] * e2[1] - e1[1] * e2[0]
+            ];
+            // Add the area (half the magnitude of the cross product) to the total
+            area += Math.sqrt(cross[0] * cross[0] + cross[1] * cross[1] + cross[2] * cross[2]) / 2;
+        }
+    }
+    const count = indices.getCount() / 3;
+    const density = count / area;
+    // const size = [0, 0, 0] as vec3;
+    // size[0] = bounds.max[0] - bounds.min[0];
+    // size[1] = bounds.max[1] - bounds.min[1];
+    // size[2] = bounds.max[2] - bounds.min[2];
+    // const volume = size[0] * size[1] * size[2];
+    // const density = count / volume;
+    return density;
+    function expandBounds(point, target) {
+        for (let i = 0; i < 3; i++) {
+            target.min[i] = Math.min(point[i], target.min[i]);
+            target.max[i] = Math.max(point[i], target.max[i]);
+        }
+    }
 }
-function simplifyMesh(doc, mesh, prim, lodinfo) {
+async function simplifyMesh(doc, mesh, prim, lodinfo) {
     const weldOptions = {
         ...WELD_DEFAULTS,
         overwrite: true,
+        ...lodinfo,
     };
     const simplifyOptions = {
-        ...SIMPLIFY_DEFAULTS, simplifier: MeshoptSimplifier,
+        ...SIMPLIFY_DEFAULTS,
+        ...lodinfo,
+        simplifier: MeshoptSimplifier,
     };
-    if (lodinfo.error != undefined)
-        simplifyOptions.error = lodinfo.error;
-    if (lodinfo.ratio != undefined)
-        simplifyOptions.ratio = lodinfo.ratio;
-    compressPrimitive(doc, mesh, prim, weldOptions, simplifyOptions);
+    // if (lodinfo.error != undefined)
+    // 	simplifyOptions.error = lodinfo.error;
+    // if (lodinfo.ratio != undefined)
+    // 	simplifyOptions.ratio = lodinfo.ratio;
+    // if (lodinfo.lockBorder != undefined)
+    // 	simplifyOptions.lockBorder = lodinfo.lockBorder;
+    return compressPrimitive(doc, mesh, prim, weldOptions, simplifyOptions);
 }
 function isMeshLOD(filepath) {
     return filepath.includes("mesh_lod_");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.4.1-beta.1",
+  "version": "1.4.1-beta.4",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
@@ -16,9 +16,9 @@
     "compile": "tsc || exit 1"
   },
   "dependencies": {
-    "@gltf-transform/core": "^3.10.0",
-    "@gltf-transform/extensions": "^3.10.0",
-    "@gltf-transform/functions": "^3.10.0",
+    "@gltf-transform/core": "^3.10.1",
+    "@gltf-transform/extensions": "^3.10.1",
+    "@gltf-transform/functions": "^3.10.1",
     "command-exists": "^1.2.9",
     "command-line-args": "^5.2.1",
     "draco3dgltf": "^1.5.3",