@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/asset/loaders/ktx2/transcoder_pool.js

@@ -0,0 +1,259 @@
+import { defaultBasisTranscoderPath } from './basis_location.js';
+
+// Runs inside each worker, appended after basis_transcoder.js which defines the
+// BASIS module factory. Kept as plain source text so the bundler cannot rewrite
+// it into something that depends on helpers living in the main bundle.
+//
+// The transcode loop follows three.js KTX2Loader (r180): startTranscoding() once,
+// then getImageTranscodedSizeInBytes() + transcodeImage() per level/layer/face.
+const WORKER_SOURCE = `
+(function () {
+  var ready = null;
+  function transcode(module, buffer, targets) {
+    var file = new module.KTX2File(new Uint8Array(buffer));
+    try {
+      if (!file.isValid()) {
+        throw new Error('Invalid KTX2 file, or not Basis Universal encoded');
+      }
+      if (file.isHDR()) {
+        throw new Error('HDR KTX2 textures are not supported yet');
+      }
+      var width = file.getWidth();
+      var height = file.getHeight();
+      var levels = Math.max(1, file.getLevels());
+      var faces = file.getFaces();
+      var layers = file.getLayers();
+      var hasAlpha = !!file.getHasAlpha();
+      var group = file.isETC1S() ? targets.etc1s : targets.uastc;
+      var target = hasAlpha ? group.alpha : group.opaque;
+      if (target.compressed && (width % 4 !== 0 || height % 4 !== 0)) {
+        target = targets.fallback;
+      }
+      if (!file.startTranscoding()) {
+        throw new Error('startTranscoding() failed');
+      }
+      var images = [];
+      var levelWidths = [];
+      var levelHeights = [];
+      var slices = faces * Math.max(1, layers);
+      for (var slice = 0; slice < slices; slice++) {
+        var face = slice % faces;
+        var layer = Math.floor(slice / faces);
+        for (var level = 0; level < levels; level++) {
+          var info = file.getImageLevelInfo(level, layer, face);
+          var dst = new Uint8Array(file.getImageTranscodedSizeInBytes(level, layer, face, target.transcoderFormat));
+          if (!file.transcodeImage(dst, level, layer, face, target.transcoderFormat, 0, -1, -1)) {
+            throw new Error('transcodeImage() failed at level ' + level + ', layer ' + layer + ', face ' + face);
+          }
+          images.push(dst);
+          if (slice === 0) {
+            levelWidths.push(info.origWidth);
+            levelHeights.push(info.origHeight);
+          }
+        }
+      }
+      return {
+        width: width,
+        height: height,
+        levels: levels,
+        faces: faces,
+        layers: layers,
+        textureFormat: target.textureFormat,
+        compressed: target.compressed,
+        images: images,
+        levelWidths: levelWidths,
+        levelHeights: levelHeights
+      };
+    } finally {
+      file.close();
+      file.delete();
+    }
+  }
+  self.onmessage = function (e) {
+    var msg = e.data;
+    if (msg.type === 'init') {
+      ready = BASIS({ wasmBinary: msg.wasm }).then(function (module) {
+        module.initializeBasis();
+        return module;
+      });
+    } else if (msg.type === 'transcode') {
+      ready
+        .then(function (module) {
+          var result = transcode(module, msg.buffer, msg.targets);
+          self.postMessage(
+            { type: 'result', id: msg.id, result: result },
+            result.images.map(function (img) { return img.buffer; })
+          );
+        })
+        .catch(function (err) {
+          self.postMessage({ type: 'error', id: msg.id, message: String((err && err.message) || err) });
+        });
+    }
+  };
+})();
+`;
+function assertWasm(data, url) {
+    // A dev server or SPA host answering a missing file with index.html still
+    // returns 200; catch that here instead of as an opaque CompileError
+    const head = new Uint8Array(data, 0, Math.min(4, data.byteLength));
+    if (head.length < 4 || head[0] !== 0x00 || head[1] !== 0x61 || head[2] !== 0x73 || head[3] !== 0x6d) {
+        throw new Error(`${url} is not a WebAssembly file; is it deployed at that location?`);
+    }
+}
+/**
+ * Pool of web workers running the Basis Universal transcoder.
+ *
+ * Nothing is downloaded or spawned until the first transcode request, so pages
+ * that never load a KTX2 texture pay nothing for it.
+ *
+ * @internal
+ */ class BasisTranscoder {
+    static _instance = null;
+    static _path = null;
+    static _workerCount = 0;
+    _workers;
+    _requests;
+    _nextId;
+    constructor(){
+        this._workers = null;
+        this._requests = new Map();
+        this._nextId = 1;
+    }
+    /** Directory URL holding basis_transcoder.js and basis_transcoder.wasm, null for the bundled copy */ static get path() {
+        return this._path;
+    }
+    static set path(url) {
+        if (url !== this._path) {
+            this._path = url;
+            this.reset();
+        }
+    }
+    /** Number of workers, 0 picks one from the hardware concurrency */ static get workerCount() {
+        return this._workerCount;
+    }
+    static set workerCount(n) {
+        if (n !== this._workerCount) {
+            this._workerCount = Math.max(0, n >>> 0);
+            this.reset();
+        }
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new BasisTranscoder();
+        }
+        return this._instance;
+    }
+    /** Terminates the workers; they are recreated with the current settings on next use */ static reset() {
+        if (this._instance) {
+            this._instance.dispose();
+            this._instance = null;
+        }
+    }
+    transcode(data, targets) {
+        return this.getWorkers().then((workers)=>new Promise((resolve, reject)=>{
+                const entry = workers.reduce((a, b)=>b.pending < a.pending ? b : a);
+                const id = this._nextId++;
+                entry.pending++;
+                this._requests.set(id, {
+                    resolve: (result)=>{
+                        entry.pending--;
+                        resolve(result);
+                    },
+                    reject: (err)=>{
+                        entry.pending--;
+                        reject(err);
+                    }
+                });
+                // Copy so the caller keeps its data and a view into a larger buffer (a .glb
+                // chunk) does not ship the whole buffer to the worker
+                const buffer = data.slice().buffer;
+                entry.worker.postMessage({
+                    type: 'transcode',
+                    id,
+                    buffer,
+                    targets
+                }, [
+                    buffer
+                ]);
+            }));
+    }
+    dispose() {
+        const workers = this._workers;
+        this._workers = null;
+        workers?.then((list)=>{
+            list.forEach((w)=>w.worker.terminate());
+            if (list.length > 0) {
+                URL.revokeObjectURL(list[0].scriptUrl);
+            }
+        }, ()=>{});
+        for (const req of this._requests.values()){
+            req.reject(new Error('Basis transcoder was reset'));
+        }
+        this._requests.clear();
+    }
+    getWorkers() {
+        if (!this._workers) {
+            this._workers = this.createWorkers();
+            // Allow a retry after a failed download instead of caching the failure forever
+            this._workers.catch(()=>{
+                this._workers = null;
+            });
+        }
+        return this._workers;
+    }
+    async createWorkers() {
+        const base = BasisTranscoder._path ?? defaultBasisTranscoderPath();
+        const dir = base.endsWith('/') ? base : `${base}/`;
+        const [jsResponse, wasmResponse] = await Promise.all([
+            fetch(`${dir}basis_transcoder.js`),
+            fetch(`${dir}basis_transcoder.wasm`)
+        ]);
+        if (!jsResponse.ok || !wasmResponse.ok) {
+            throw new Error(`Failed to load the Basis transcoder from ${dir} (HTTP ${jsResponse.status}/${wasmResponse.status}). ` + 'Set KTX2Loader.transcoderPath to the directory that holds basis_transcoder.js and basis_transcoder.wasm.');
+        }
+        const [jsSource, wasm] = await Promise.all([
+            jsResponse.text(),
+            wasmResponse.arrayBuffer()
+        ]);
+        assertWasm(wasm, `${dir}basis_transcoder.wasm`);
+        const blobUrl = URL.createObjectURL(new Blob([
+            jsSource,
+            WORKER_SOURCE
+        ], {
+            type: 'application/javascript'
+        }));
+        const count = BasisTranscoder._workerCount || Math.max(1, Math.min(4, (globalThis.navigator?.hardwareConcurrency ?? 4) - 1));
+        const workers = [];
+        for(let i = 0; i < count; i++){
+            const worker = new Worker(blobUrl);
+            worker.onmessage = (e)=>this.onMessage(e.data);
+            worker.onerror = (e)=>console.error(`Basis transcoder worker error: ${e.message}`);
+            // Each worker gets its own copy, a transferred buffer could only go to one
+            worker.postMessage({
+                type: 'init',
+                wasm: wasm.slice(0)
+            });
+            workers.push({
+                worker,
+                pending: 0,
+                scriptUrl: blobUrl
+            });
+        }
+        return workers;
+    }
+    onMessage(msg) {
+        const req = this._requests.get(msg.id);
+        if (!req) {
+            return;
+        }
+        this._requests.delete(msg.id);
+        if (msg.type === 'result') {
+            req.resolve(msg.result);
+        } else {
+            req.reject(new Error(`KTX2 transcode failed: ${msg.message}`));
+        }
+    }
+}
+
+export { BasisTranscoder };
+//# sourceMappingURL=transcoder_pool.js.map

package/dist/asset/loaders/ktx2/transcoder_pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcoder_pool.js","sources":["../../../../src/asset/loaders/ktx2/transcoder_pool.ts"],"sourcesContent":["import type { TextureFormat } from '@zephyr3d/device';\r\nimport type { KTX2TranscodeTargets } from './ktx2_targets';\r\nimport { defaultBasisTranscoderPath } from './basis_location';\r\n\r\n/**\r\n * Result of transcoding one KTX2 file. `images` is ordered slice-major: every\r\n * mip level of face/layer 0, then every level of face/layer 1, and so on.\r\n * @internal\r\n */\r\nexport interface KTX2TranscodeResult {\r\n  width: number;\r\n  height: number;\r\n  levels: number;\r\n  faces: number;\r\n  /** Raw KTX2 layer count, 0 when the texture is not an array */\r\n  layers: number;\r\n  textureFormat: TextureFormat;\r\n  compressed: boolean;\r\n  images: Uint8Array<ArrayBuffer>[];\r\n  levelWidths: number[];\r\n  levelHeights: number[];\r\n}\r\n\r\n// Runs inside each worker, appended after basis_transcoder.js which defines the\r\n// BASIS module factory. Kept as plain source text so the bundler cannot rewrite\r\n// it into something that depends on helpers living in the main bundle.\r\n//\r\n// The transcode loop follows three.js KTX2Loader (r180): startTranscoding() once,\r\n// then getImageTranscodedSizeInBytes() + transcodeImage() per level/layer/face.\r\nconst WORKER_SOURCE = `\r\n(function () {\r\n  var ready = null;\r\n  function transcode(module, buffer, targets) {\r\n    var file = new module.KTX2File(new Uint8Array(buffer));\r\n    try {\r\n      if (!file.isValid()) {\r\n        throw new Error('Invalid KTX2 file, or not Basis Universal encoded');\r\n      }\r\n      if (file.isHDR()) {\r\n        throw new Error('HDR KTX2 textures are not supported yet');\r\n      }\r\n      var width = file.getWidth();\r\n      var height = file.getHeight();\r\n      var levels = Math.max(1, file.getLevels());\r\n      var faces = file.getFaces();\r\n      var layers = file.getLayers();\r\n      var hasAlpha = !!file.getHasAlpha();\r\n      var group = file.isETC1S() ? targets.etc1s : targets.uastc;\r\n      var target = hasAlpha ? group.alpha : group.opaque;\r\n      if (target.compressed && (width % 4 !== 0 || height % 4 !== 0)) {\r\n        target = targets.fallback;\r\n      }\r\n      if (!file.startTranscoding()) {\r\n        throw new Error('startTranscoding() failed');\r\n      }\r\n      var images = [];\r\n      var levelWidths = [];\r\n      var levelHeights = [];\r\n      var slices = faces * Math.max(1, layers);\r\n      for (var slice = 0; slice < slices; slice++) {\r\n        var face = slice % faces;\r\n        var layer = Math.floor(slice / faces);\r\n        for (var level = 0; level < levels; level++) {\r\n          var info = file.getImageLevelInfo(level, layer, face);\r\n          var dst = new Uint8Array(file.getImageTranscodedSizeInBytes(level, layer, face, target.transcoderFormat));\r\n          if (!file.transcodeImage(dst, level, layer, face, target.transcoderFormat, 0, -1, -1)) {\r\n            throw new Error('transcodeImage() failed at level ' + level + ', layer ' + layer + ', face ' + face);\r\n          }\r\n          images.push(dst);\r\n          if (slice === 0) {\r\n            levelWidths.push(info.origWidth);\r\n            levelHeights.push(info.origHeight);\r\n          }\r\n        }\r\n      }\r\n      return {\r\n        width: width,\r\n        height: height,\r\n        levels: levels,\r\n        faces: faces,\r\n        layers: layers,\r\n        textureFormat: target.textureFormat,\r\n        compressed: target.compressed,\r\n        images: images,\r\n        levelWidths: levelWidths,\r\n        levelHeights: levelHeights\r\n      };\r\n    } finally {\r\n      file.close();\r\n      file.delete();\r\n    }\r\n  }\r\n  self.onmessage = function (e) {\r\n    var msg = e.data;\r\n    if (msg.type === 'init') {\r\n      ready = BASIS({ wasmBinary: msg.wasm }).then(function (module) {\r\n        module.initializeBasis();\r\n        return module;\r\n      });\r\n    } else if (msg.type === 'transcode') {\r\n      ready\r\n        .then(function (module) {\r\n          var result = transcode(module, msg.buffer, msg.targets);\r\n          self.postMessage(\r\n            { type: 'result', id: msg.id, result: result },\r\n            result.images.map(function (img) { return img.buffer; })\r\n          );\r\n        })\r\n        .catch(function (err) {\r\n          self.postMessage({ type: 'error', id: msg.id, message: String((err && err.message) || err) });\r\n        });\r\n    }\r\n  };\r\n})();\r\n`;\r\n\r\ninterface PendingRequest {\r\n  resolve: (result: KTX2TranscodeResult) => void;\r\n  reject: (err: Error) => void;\r\n}\r\n\r\ninterface TranscoderWorker {\r\n  worker: Worker;\r\n  pending: number;\r\n  /** Blob URL of the worker script, shared by the pool and revoked with it */\r\n  scriptUrl: string;\r\n}\r\n\r\nfunction assertWasm(data: ArrayBuffer, url: string) {\r\n  // A dev server or SPA host answering a missing file with index.html still\r\n  // returns 200; catch that here instead of as an opaque CompileError\r\n  const head = new Uint8Array(data, 0, Math.min(4, data.byteLength));\r\n  if (head.length < 4 || head[0] !== 0x00 || head[1] !== 0x61 || head[2] !== 0x73 || head[3] !== 0x6d) {\r\n    throw new Error(`${url} is not a WebAssembly file; is it deployed at that location?`);\r\n  }\r\n}\r\n\r\n/**\r\n * Pool of web workers running the Basis Universal transcoder.\r\n *\r\n * Nothing is downloaded or spawned until the first transcode request, so pages\r\n * that never load a KTX2 texture pay nothing for it.\r\n *\r\n * @internal\r\n */\r\nexport class BasisTranscoder {\r\n  private static _instance: BasisTranscoder | null = null;\r\n  private static _path: string | null = null;\r\n  private static _workerCount = 0;\r\n  private _workers: Promise<TranscoderWorker[]> | null;\r\n  private readonly _requests: Map<number, PendingRequest>;\r\n  private _nextId: number;\r\n  private constructor() {\r\n    this._workers = null;\r\n    this._requests = new Map();\r\n    this._nextId = 1;\r\n  }\r\n  /** Directory URL holding basis_transcoder.js and basis_transcoder.wasm, null for the bundled copy */\r\n  static get path() {\r\n    return this._path;\r\n  }\r\n  static set path(url: string | null) {\r\n    if (url !== this._path) {\r\n      this._path = url;\r\n      this.reset();\r\n    }\r\n  }\r\n  /** Number of workers, 0 picks one from the hardware concurrency */\r\n  static get workerCount() {\r\n    return this._workerCount;\r\n  }\r\n  static set workerCount(n: number) {\r\n    if (n !== this._workerCount) {\r\n      this._workerCount = Math.max(0, n >>> 0);\r\n      this.reset();\r\n    }\r\n  }\r\n  static get instance() {\r\n    if (!this._instance) {\r\n      this._instance = new BasisTranscoder();\r\n    }\r\n    return this._instance;\r\n  }\r\n  /** Terminates the workers; they are recreated with the current settings on next use */\r\n  static reset() {\r\n    if (this._instance) {\r\n      this._instance.dispose();\r\n      this._instance = null;\r\n    }\r\n  }\r\n  transcode(data: Uint8Array<ArrayBuffer>, targets: KTX2TranscodeTargets): Promise<KTX2TranscodeResult> {\r\n    return this.getWorkers().then(\r\n      (workers) =>\r\n        new Promise<KTX2TranscodeResult>((resolve, reject) => {\r\n          const entry = workers.reduce((a, b) => (b.pending < a.pending ? b : a));\r\n          const id = this._nextId++;\r\n          entry.pending++;\r\n          this._requests.set(id, {\r\n            resolve: (result) => {\r\n              entry.pending--;\r\n              resolve(result);\r\n            },\r\n            reject: (err) => {\r\n              entry.pending--;\r\n              reject(err);\r\n            }\r\n          });\r\n          // Copy so the caller keeps its data and a view into a larger buffer (a .glb\r\n          // chunk) does not ship the whole buffer to the worker\r\n          const buffer = data.slice().buffer;\r\n          entry.worker.postMessage({ type: 'transcode', id, buffer, targets }, [buffer]);\r\n        })\r\n    );\r\n  }\r\n  private dispose() {\r\n    const workers = this._workers;\r\n    this._workers = null;\r\n    workers?.then(\r\n      (list) => {\r\n        list.forEach((w) => w.worker.terminate());\r\n        if (list.length > 0) {\r\n          URL.revokeObjectURL(list[0].scriptUrl);\r\n        }\r\n      },\r\n      () => {}\r\n    );\r\n    for (const req of this._requests.values()) {\r\n      req.reject(new Error('Basis transcoder was reset'));\r\n    }\r\n    this._requests.clear();\r\n  }\r\n  private getWorkers() {\r\n    if (!this._workers) {\r\n      this._workers = this.createWorkers();\r\n      // Allow a retry after a failed download instead of caching the failure forever\r\n      this._workers.catch(() => {\r\n        this._workers = null;\r\n      });\r\n    }\r\n    return this._workers;\r\n  }\r\n  private async createWorkers(): Promise<TranscoderWorker[]> {\r\n    const base = BasisTranscoder._path ?? defaultBasisTranscoderPath();\r\n    const dir = base.endsWith('/') ? base : `${base}/`;\r\n    const [jsResponse, wasmResponse] = await Promise.all([\r\n      fetch(`${dir}basis_transcoder.js`),\r\n      fetch(`${dir}basis_transcoder.wasm`)\r\n    ]);\r\n    if (!jsResponse.ok || !wasmResponse.ok) {\r\n      throw new Error(\r\n        `Failed to load the Basis transcoder from ${dir} (HTTP ${jsResponse.status}/${wasmResponse.status}). ` +\r\n          'Set KTX2Loader.transcoderPath to the directory that holds basis_transcoder.js and basis_transcoder.wasm.'\r\n      );\r\n    }\r\n    const [jsSource, wasm] = await Promise.all([jsResponse.text(), wasmResponse.arrayBuffer()]);\r\n    assertWasm(wasm, `${dir}basis_transcoder.wasm`);\r\n    const blobUrl = URL.createObjectURL(\r\n      new Blob([jsSource, WORKER_SOURCE], { type: 'application/javascript' })\r\n    );\r\n    const count =\r\n      BasisTranscoder._workerCount ||\r\n      Math.max(1, Math.min(4, (globalThis.navigator?.hardwareConcurrency ?? 4) - 1));\r\n    const workers: TranscoderWorker[] = [];\r\n    for (let i = 0; i < count; i++) {\r\n      const worker = new Worker(blobUrl);\r\n      worker.onmessage = (e: MessageEvent) => this.onMessage(e.data);\r\n      worker.onerror = (e: ErrorEvent) => console.error(`Basis transcoder worker error: ${e.message}`);\r\n      // Each worker gets its own copy, a transferred buffer could only go to one\r\n      worker.postMessage({ type: 'init', wasm: wasm.slice(0) });\r\n      workers.push({ worker, pending: 0, scriptUrl: blobUrl });\r\n    }\r\n    return workers;\r\n  }\r\n  private onMessage(msg: { type: string; id: number; result?: KTX2TranscodeResult; message?: string }) {\r\n    const req = this._requests.get(msg.id);\r\n    if (!req) {\r\n      return;\r\n    }\r\n    this._requests.delete(msg.id);\r\n    if (msg.type === 'result') {\r\n      req.resolve(msg.result!);\r\n    } else {\r\n      req.reject(new Error(`KTX2 transcode failed: ${msg.message}`));\r\n    }\r\n  }\r\n}\r\n"],"names":["WORKER_SOURCE","assertWasm","data","url","head","Uint8Array","Math","min","byteLength","length","Error","BasisTranscoder","_instance","_path","_workerCount","_workers","_requests","_nextId","Map","path","reset","workerCount","n","max","instance","dispose","transcode","targets","getWorkers","then","workers","Promise","resolve","reject","entry","reduce","a","b","pending","id","set","result","err","buffer","slice","worker","postMessage","type","list","forEach","w","terminate","URL","revokeObjectURL","scriptUrl","req","values","clear","createWorkers","catch","base","defaultBasisTranscoderPath","dir","endsWith","jsResponse","wasmResponse","all","fetch","ok","status","jsSource","wasm","text","arrayBuffer","blobUrl","createObjectURL","Blob","count","globalThis","navigator","hardwareConcurrency","i","Worker","onmessage","e","onMessage","onerror","console","error","message","push","msg","get","delete"],"mappings":"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"}

package/dist/asset/mesh_lod_builder.js

@@ -0,0 +1,104 @@
+// Builds the level of detail chain of a mesh, for the editor's derived mesh cache and
+// for SharedModel.generateLods at runtime. Pure data work with the simplifier passed in,
+// no other engine module imported, so it also runs in the editor's encoding worker.
+/**
+ * The subset of meshoptimizer's MeshoptSimplifier the level of detail generation uses. The engine
+ * does not ship the simplifier: pass meshoptimizer's, which `loadMeshoptSimplifier()` of the
+ * loaders package returns.
+ * @public
+ */ const MAX_LEVELS = 8;
+const LOD0_SCREEN_SIZE = 2;
+const AUTO_LOD_POWER_BASE = 0.75;
+const LOD_HYSTERESIS = 0.02;
+/**
+ * Weight of the vertex normals in the simplification error. The meshoptimizer README advises
+ * "around 1.0" for normalized attributes; texture seams are kept from the index topology alone.
+ */ const NORMAL_WEIGHT = 1;
+/** An error bound the simplifier never reaches, within float range */ const NO_ERROR_LIMIT = 1e30;
+function calculateViewDistance(maxDeviation, pixelError) {
+    return maxDeviation * 960 / Math.max(pixelError, Number.EPSILON);
+}
+function autoScreenSize(sphereRadius, viewDistance) {
+    const screenMultiple = Math.max(0.5, 0.5 * 1920 / 1080);
+    const screenRadius = screenMultiple * sphereRadius / Math.max(0.01, viewDistance);
+    return screenRadius * 2;
+}
+/**
+ * Simplifies a triangle list into a level of detail chain. Returns the indices of every level
+ * back to back, the source first, and the level table. Levels are added while the next target
+ * keeps at least `lodMinTriangles` triangles, as getMeshLodTargets in the engine predicts; the
+ * chain ends early when simplification stops removing triangles or falls below that minimum.
+ *
+ * @param simplifier - meshoptimizer's simplifier, ready
+ * @param indices - Source triangle list
+ * @param positions - 3 floats per vertex
+ * @param normals - 3 floats per vertex, or null
+ * @param sphereRadius - Radius of the sphere around the mesh bounds, as the runtime measures it
+ * @param settings - Level settings
+ * @public
+ */ function buildLodChain(simplifier, indices, positions, normals, sphereRadius, settings) {
+    const chains = [
+        indices
+    ];
+    const levels = [
+        {
+            indexStart: 0,
+            indexCount: indices.length,
+            screenSize: LOD0_SCREEN_SIZE,
+            hysteresis: 0,
+            error: 0
+        }
+    ];
+    let indexStart = indices.length;
+    const minIndices = Math.max(settings.lodMinTriangles, 1) * 3;
+    for(let i = 1; i < MAX_LEVELS; i++){
+        const target = Math.floor(indices.length * settings.lodReduction ** i / 3) * 3;
+        if (target < minIndices) {
+            break;
+        }
+        const flags = [
+            'ErrorAbsolute',
+            'Prune'
+        ];
+        const [lod, error] = normals ? simplifier.simplifyWithAttributes(indices, positions, 3, normals, 3, [
+            NORMAL_WEIGHT,
+            NORMAL_WEIGHT,
+            NORMAL_WEIGHT
+        ], null, target, NO_ERROR_LIMIT, flags) : simplifier.simplify(indices, positions, 3, target, NO_ERROR_LIMIT, flags);
+        // No progress over the previous level: nothing coarser can follow either
+        if (lod.length === 0 || lod.length >= chains[chains.length - 1].length) {
+            break;
+        }
+        // Pruning disconnected parts can overshoot the target; every later target is smaller still
+        if (lod.length < minIndices) {
+            break;
+        }
+        const previous = levels[levels.length - 1];
+        let screenSize = error > 0 ? autoScreenSize(sphereRadius, calculateViewDistance(error, settings.lodPixelError) + sphereRadius) : AUTO_LOD_POWER_BASE ** i;
+        if (screenSize > previous.screenSize) {
+            screenSize = previous.screenSize / 2;
+        }
+        chains.push(lod);
+        levels.push({
+            indexStart,
+            indexCount: lod.length,
+            screenSize,
+            hysteresis: LOD_HYSTERESIS,
+            error
+        });
+        indexStart += lod.length;
+    }
+    const all = new Uint32Array(indexStart);
+    let offset = 0;
+    for (const chain of chains){
+        all.set(chain, offset);
+        offset += chain.length;
+    }
+    return {
+        indices: all,
+        levels
+    };
+}
+
+export { buildLodChain };
+//# sourceMappingURL=mesh_lod_builder.js.map

package/dist/asset/mesh_lod_builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_lod_builder.js","sources":["../../src/asset/mesh_lod_builder.ts"],"sourcesContent":["// Builds the level of detail chain of a mesh, for the editor's derived mesh cache and\r\n// for SharedModel.generateLods at runtime. Pure data work with the simplifier passed in,\r\n// no other engine module imported, so it also runs in the editor's encoding worker.\r\n\r\n/**\r\n * The subset of meshoptimizer's MeshoptSimplifier the level of detail generation uses. The engine\r\n * does not ship the simplifier: pass meshoptimizer's, which `loadMeshoptSimplifier()` of the\r\n * loaders package returns.\r\n * @public\r\n */\r\nexport interface MeshSimplifier {\r\n  simplify(\r\n    indices: Uint32Array,\r\n    positions: Float32Array,\r\n    positionsStride: number,\r\n    targetIndexCount: number,\r\n    targetError: number,\r\n    flags?: string[]\r\n  ): [Uint32Array, number];\r\n  simplifyWithAttributes(\r\n    indices: Uint32Array,\r\n    positions: Float32Array,\r\n    positionsStride: number,\r\n    attributes: Float32Array,\r\n    attributesStride: number,\r\n    attributeWeights: number[],\r\n    vertexLock: Uint8Array | null,\r\n    targetIndexCount: number,\r\n    targetError: number,\r\n    flags?: string[]\r\n  ): [Uint32Array, number];\r\n}\r\n\r\n/**\r\n * How levels of detail are generated, see {@link MeshImportSettings} for the same settings of the\r\n * editor.\r\n * @public\r\n */\r\nexport interface MeshLodSettings {\r\n  /** Fewest triangles a generated level may have; the level count follows from it */\r\n  lodMinTriangles: number;\r\n  /** Fraction of the source triangles kept per level step */\r\n  lodReduction: number;\r\n  /** Pixel error the automatic switch distances allow */\r\n  lodPixelError: number;\r\n}\r\n\r\n/**\r\n * A generated level of detail.\r\n * @public\r\n */\r\nexport interface MeshLodLevel {\r\n  indexStart: number;\r\n  indexCount: number;\r\n  screenSize: number;\r\n  hysteresis: number;\r\n  /** Largest distance between the level and the source surface, in mesh units */\r\n  error: number;\r\n}\r\n\r\nconst MAX_LEVELS = 8;\r\nconst LOD0_SCREEN_SIZE = 2;\r\nconst AUTO_LOD_POWER_BASE = 0.75;\r\nconst LOD_HYSTERESIS = 0.02;\r\n/**\r\n * Weight of the vertex normals in the simplification error. The meshoptimizer README advises\r\n * \"around 1.0\" for normalized attributes; texture seams are kept from the index topology alone.\r\n */\r\nconst NORMAL_WEIGHT = 1;\r\n/** An error bound the simplifier never reaches, within float range */\r\nconst NO_ERROR_LIMIT = 1e30;\r\n\r\nfunction calculateViewDistance(maxDeviation: number, pixelError: number) {\r\n  return (maxDeviation * 960) / Math.max(pixelError, Number.EPSILON);\r\n}\r\n\r\nfunction autoScreenSize(sphereRadius: number, viewDistance: number) {\r\n  const screenMultiple = Math.max(0.5, (0.5 * 1920) / 1080);\r\n  const screenRadius = (screenMultiple * sphereRadius) / Math.max(0.01, viewDistance);\r\n  return screenRadius * 2;\r\n}\r\n\r\n/**\r\n * Simplifies a triangle list into a level of detail chain. Returns the indices of every level\r\n * back to back, the source first, and the level table. Levels are added while the next target\r\n * keeps at least `lodMinTriangles` triangles, as getMeshLodTargets in the engine predicts; the\r\n * chain ends early when simplification stops removing triangles or falls below that minimum.\r\n *\r\n * @param simplifier - meshoptimizer's simplifier, ready\r\n * @param indices - Source triangle list\r\n * @param positions - 3 floats per vertex\r\n * @param normals - 3 floats per vertex, or null\r\n * @param sphereRadius - Radius of the sphere around the mesh bounds, as the runtime measures it\r\n * @param settings - Level settings\r\n * @public\r\n */\r\nexport function buildLodChain(\r\n  simplifier: MeshSimplifier,\r\n  indices: Uint32Array,\r\n  positions: Float32Array,\r\n  normals: Float32Array | null,\r\n  sphereRadius: number,\r\n  settings: MeshLodSettings\r\n) {\r\n  const chains: Uint32Array[] = [indices];\r\n  const levels: MeshLodLevel[] = [\r\n    { indexStart: 0, indexCount: indices.length, screenSize: LOD0_SCREEN_SIZE, hysteresis: 0, error: 0 }\r\n  ];\r\n  let indexStart = indices.length;\r\n  const minIndices = Math.max(settings.lodMinTriangles, 1) * 3;\r\n  for (let i = 1; i < MAX_LEVELS; i++) {\r\n    const target = Math.floor((indices.length * settings.lodReduction ** i) / 3) * 3;\r\n    if (target < minIndices) {\r\n      break;\r\n    }\r\n    const flags = ['ErrorAbsolute', 'Prune'];\r\n    const [lod, error] = normals\r\n      ? simplifier.simplifyWithAttributes(\r\n          indices,\r\n          positions,\r\n          3,\r\n          normals,\r\n          3,\r\n          [NORMAL_WEIGHT, NORMAL_WEIGHT, NORMAL_WEIGHT],\r\n          null,\r\n          target,\r\n          NO_ERROR_LIMIT,\r\n          flags\r\n        )\r\n      : simplifier.simplify(indices, positions, 3, target, NO_ERROR_LIMIT, flags);\r\n    // No progress over the previous level: nothing coarser can follow either\r\n    if (lod.length === 0 || lod.length >= chains[chains.length - 1].length) {\r\n      break;\r\n    }\r\n    // Pruning disconnected parts can overshoot the target; every later target is smaller still\r\n    if (lod.length < minIndices) {\r\n      break;\r\n    }\r\n    const previous = levels[levels.length - 1];\r\n    let screenSize =\r\n      error > 0\r\n        ? autoScreenSize(sphereRadius, calculateViewDistance(error, settings.lodPixelError) + sphereRadius)\r\n        : AUTO_LOD_POWER_BASE ** i;\r\n    if (screenSize > previous.screenSize) {\r\n      screenSize = previous.screenSize / 2;\r\n    }\r\n    chains.push(lod);\r\n    levels.push({ indexStart, indexCount: lod.length, screenSize, hysteresis: LOD_HYSTERESIS, error });\r\n    indexStart += lod.length;\r\n  }\r\n  const all = new Uint32Array(indexStart);\r\n  let offset = 0;\r\n  for (const chain of chains) {\r\n    all.set(chain, offset);\r\n    offset += chain.length;\r\n  }\r\n  return { indices: all, levels };\r\n}\r\n"],"names":["MAX_LEVELS","LOD0_SCREEN_SIZE","AUTO_LOD_POWER_BASE","LOD_HYSTERESIS","NORMAL_WEIGHT","NO_ERROR_LIMIT","calculateViewDistance","maxDeviation","pixelError","Math","max","Number","EPSILON","autoScreenSize","sphereRadius","viewDistance","screenMultiple","screenRadius","buildLodChain","simplifier","indices","positions","normals","settings","chains","levels","indexStart","indexCount","length","screenSize","hysteresis","error","minIndices","lodMinTriangles","i","target","floor","lodReduction","flags","lod","simplifyWithAttributes","simplify","previous","lodPixelError","push","all","Uint32Array","offset","chain","set"],"mappings":"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"}

package/dist/asset/mesh_settings.js

@@ -0,0 +1,111 @@
+import { ASSET_META_VERSION, getAssetMetaPath } from './texture_settings.js';
+
+/** Most levels of detail a mesh can have */ const MAX_MESH_LODS = 8;
+const COMPRESSIONS = [
+    'none',
+    'meshopt'
+];
+const NORMAL_BITS = [
+    0,
+    8,
+    12,
+    16
+];
+/**
+ * Default mesh settings. Like textures, compression is opt-in. Normals default
+ * to 12 bits: 8-bit error shows on smooth surfaces near the light terminator.
+ * @public
+ */ function defaultMeshImportSettings(compression = 'none') {
+    return {
+        compression,
+        normalBits: 12,
+        lodEnabled: false,
+        lodMinTriangles: 100,
+        lodReduction: 0.5,
+        lodPixelError: 8,
+        sdfResolutionScale: 1,
+        sdfUnitScale: 1,
+        sdfTwoSided: false
+    };
+}
+/**
+ * Triangle count each level of detail aims for, the source first: level i keeps
+ * `lodReduction^i` of the source triangles, and levels stop before one would fall below
+ * `lodMinTriangles` or at {@link MAX_MESH_LODS}. Simplification may end the chain earlier when it
+ * cannot reach a target, so this is the most levels the settings can give.
+ * @public
+ */ function getMeshLodTargets(triangles, settings) {
+    const targets = [
+        triangles
+    ];
+    if (settings.lodEnabled) {
+        for(let i = 1; i < MAX_MESH_LODS; i++){
+            const target = Math.floor(triangles * settings.lodReduction ** i);
+            if (target < settings.lodMinTriangles || target < 1) {
+                break;
+            }
+            targets.push(target);
+        }
+    }
+    return targets;
+}
+/**
+ * Whether a mesh with these settings ships a derived copy instead of its source: when compressed
+ * or when its source has enough triangles for a level of detail.
+ * @param settings - Mesh settings
+ * @param sourceTriangles - Triangles of the source mesh
+ * @public
+ */ function meshNeedsDerivedCopy(settings, sourceTriangles) {
+    return settings.compression !== 'none' || getMeshLodTargets(sourceTriangles, settings).length > 1;
+}
+/**
+ * Validates parsed settings; anything missing or invalid falls back to the defaults.
+ * @public
+ */ function normalizeMeshImportSettings(value) {
+    const v = value && typeof value === 'object' ? value : {};
+    const defaults = defaultMeshImportSettings();
+    return {
+        compression: COMPRESSIONS.includes(v.compression) ? v.compression : defaults.compression,
+        normalBits: NORMAL_BITS.includes(v.normalBits) ? v.normalBits : defaults.normalBits,
+        lodEnabled: typeof v.lodEnabled === 'boolean' ? v.lodEnabled : defaults.lodEnabled,
+        lodMinTriangles: Number.isInteger(v.lodMinTriangles) && v.lodMinTriangles >= 1 ? v.lodMinTriangles : defaults.lodMinTriangles,
+        lodReduction: typeof v.lodReduction === 'number' && v.lodReduction > 0 && v.lodReduction < 1 ? v.lodReduction : defaults.lodReduction,
+        lodPixelError: typeof v.lodPixelError === 'number' && v.lodPixelError > 0 ? v.lodPixelError : defaults.lodPixelError,
+        sdfResolutionScale: typeof v.sdfResolutionScale === 'number' && v.sdfResolutionScale > 0 ? v.sdfResolutionScale : defaults.sdfResolutionScale,
+        sdfUnitScale: typeof v.sdfUnitScale === 'number' && v.sdfUnitScale > 0 ? v.sdfUnitScale : defaults.sdfUnitScale,
+        sdfTwoSided: typeof v.sdfTwoSided === 'boolean' ? v.sdfTwoSided : defaults.sdfTwoSided
+    };
+}
+/**
+ * Reads the import settings of a mesh; without a `.zmeta` the mesh is not compressed.
+ * @public
+ */ async function readMeshImportSettings(vfs, path) {
+    const metaPath = getAssetMetaPath(path);
+    try {
+        if (await vfs.exists(metaPath)) {
+            const meta = JSON.parse(await vfs.readFile(metaPath, {
+                encoding: 'utf8'
+            }));
+            return normalizeMeshImportSettings(meta?.mesh);
+        }
+    } catch (err) {
+        console.warn(`Ignoring unreadable asset meta ${metaPath}: ${err}`);
+    }
+    return defaultMeshImportSettings();
+}
+/**
+ * Writes the import settings of a mesh to its `.zmeta` file.
+ * @public
+ */ async function writeMeshImportSettings(vfs, path, settings) {
+    const content = JSON.stringify({
+        version: ASSET_META_VERSION,
+        mesh: settings
+    }, null, 2);
+    await vfs.writeFile(getAssetMetaPath(path), content, {
+        encoding: 'utf8',
+        create: true
+    });
+}
+
+export { MAX_MESH_LODS, defaultMeshImportSettings, getMeshLodTargets, meshNeedsDerivedCopy, normalizeMeshImportSettings, readMeshImportSettings, writeMeshImportSettings };
+//# sourceMappingURL=mesh_settings.js.map

package/dist/asset/mesh_settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_settings.js","sources":["../../src/asset/mesh_settings.ts"],"sourcesContent":["import type { VFS } from '@zephyr3d/base';\r\nimport { ASSET_META_VERSION, getAssetMetaPath } from './texture_settings';\r\n\r\n/**\r\n * Vertex data encoding of a mesh: `none` ships the vertex buffers as they are,\r\n * `meshopt` stores them meshoptimizer-compressed with quantized attributes.\r\n * @public\r\n */\r\nexport type MeshCompression = 'none' | 'meshopt';\r\n\r\n/**\r\n * Per-mesh import settings, stored in the `.zmeta` file beside a `.zmsh`.\r\n * @public\r\n */\r\nexport interface MeshImportSettings {\r\n  compression: MeshCompression;\r\n  /**\r\n   * Precision of normals and tangents when compressed, or 0 to keep them as floats.\r\n   * 8 bits ships them as snorm8 (4 bytes, up to 0.8 degrees off, visible as a\r\n   * ragged terminator on smooth surfaces); 12 and 16 ship as snorm16 (8 bytes,\r\n   * 0.05 and 0.004 degrees), 12 encoding notably smaller than 16.\r\n   */\r\n  normalBits: 0 | 8 | 12 | 16;\r\n  /**\r\n   * Generate levels of detail: coarser levels simplified from the source, stored as extra index\r\n   * ranges over the same vertices. How many follows from {@link MeshImportSettings.lodMinTriangles}.\r\n   */\r\n  lodEnabled: boolean;\r\n  /**\r\n   * Fewest triangles a generated level may have. Levels are added while the next one keeps at\r\n   * least this many, up to {@link MAX_MESH_LODS} levels including the source.\r\n   */\r\n  lodMinTriangles: number;\r\n  /** Fraction of the source triangles each level keeps over the previous one */\r\n  lodReduction: number;\r\n  /**\r\n   * Pixel error the automatic switch distances allow: a level is used once its\r\n   * simplification error projects to fewer pixels on a 1920 wide, 90 degree view\r\n   */\r\n  lodPixelError: number;\r\n  /**\r\n   * Scale on the density of the baked signed distance field: 1 gives 20 voxels\r\n   * per world unit (at most 128 per axis; 256 above 1), see SDF_VOXELS_PER_UNIT.\r\n   */\r\n  sdfResolutionScale: number;\r\n  /**\r\n   * World units one local unit of the mesh spans where it is used, so the\r\n   * density of the baked field is per world unit: a model authored in\r\n   * centimetres and scaled down by its nodes would otherwise get a hundred\r\n   * times the voxels it needs. Set when the model is imported, from the\r\n   * largest scale of the nodes using the mesh, and when the meshes of a scene\r\n   * are baked, from the largest scale of their instances.\r\n   */\r\n  sdfUnitScale: number;\r\n  /** Bake the field as a thin open surface, unsigned, rather than a closed solid. */\r\n  sdfTwoSided: boolean;\r\n}\r\n\r\n/** Most levels of detail a mesh can have */\r\nexport const MAX_MESH_LODS = 8;\r\n\r\nconst COMPRESSIONS: readonly MeshCompression[] = ['none', 'meshopt'];\r\nconst NORMAL_BITS: readonly MeshImportSettings['normalBits'][] = [0, 8, 12, 16];\r\n\r\n/**\r\n * Default mesh settings. Like textures, compression is opt-in. Normals default\r\n * to 12 bits: 8-bit error shows on smooth surfaces near the light terminator.\r\n * @public\r\n */\r\nexport function defaultMeshImportSettings(compression: MeshCompression = 'none'): MeshImportSettings {\r\n  return {\r\n    compression,\r\n    normalBits: 12,\r\n    lodEnabled: false,\r\n    lodMinTriangles: 100,\r\n    lodReduction: 0.5,\r\n    lodPixelError: 8,\r\n    sdfResolutionScale: 1,\r\n    sdfUnitScale: 1,\r\n    sdfTwoSided: false\r\n  };\r\n}\r\n\r\n/**\r\n * Triangle count each level of detail aims for, the source first: level i keeps\r\n * `lodReduction^i` of the source triangles, and levels stop before one would fall below\r\n * `lodMinTriangles` or at {@link MAX_MESH_LODS}. Simplification may end the chain earlier when it\r\n * cannot reach a target, so this is the most levels the settings can give.\r\n * @public\r\n */\r\nexport function getMeshLodTargets(\r\n  triangles: number,\r\n  settings: Pick<MeshImportSettings, 'lodEnabled' | 'lodMinTriangles' | 'lodReduction'>\r\n) {\r\n  const targets = [triangles];\r\n  if (settings.lodEnabled) {\r\n    for (let i = 1; i < MAX_MESH_LODS; i++) {\r\n      const target = Math.floor(triangles * settings.lodReduction ** i);\r\n      if (target < settings.lodMinTriangles || target < 1) {\r\n        break;\r\n      }\r\n      targets.push(target);\r\n    }\r\n  }\r\n  return targets;\r\n}\r\n\r\n/**\r\n * Whether a mesh with these settings ships a derived copy instead of its source: when compressed\r\n * or when its source has enough triangles for a level of detail.\r\n * @param settings - Mesh settings\r\n * @param sourceTriangles - Triangles of the source mesh\r\n * @public\r\n */\r\nexport function meshNeedsDerivedCopy(settings: MeshImportSettings, sourceTriangles: number) {\r\n  return settings.compression !== 'none' || getMeshLodTargets(sourceTriangles, settings).length > 1;\r\n}\r\n\r\n/**\r\n * Validates parsed settings; anything missing or invalid falls back to the defaults.\r\n * @public\r\n */\r\nexport function normalizeMeshImportSettings(value: unknown): MeshImportSettings {\r\n  const v = (value && typeof value === 'object' ? value : {}) as Record<string, unknown>;\r\n  const defaults = defaultMeshImportSettings();\r\n  return {\r\n    compression: COMPRESSIONS.includes(v.compression as MeshCompression)\r\n      ? (v.compression as MeshCompression)\r\n      : defaults.compression,\r\n    normalBits: NORMAL_BITS.includes(v.normalBits as MeshImportSettings['normalBits'])\r\n      ? (v.normalBits as MeshImportSettings['normalBits'])\r\n      : defaults.normalBits,\r\n    lodEnabled: typeof v.lodEnabled === 'boolean' ? v.lodEnabled : defaults.lodEnabled,\r\n    lodMinTriangles:\r\n      Number.isInteger(v.lodMinTriangles) && (v.lodMinTriangles as number) >= 1\r\n        ? (v.lodMinTriangles as number)\r\n        : defaults.lodMinTriangles,\r\n    lodReduction:\r\n      typeof v.lodReduction === 'number' && v.lodReduction > 0 && v.lodReduction < 1\r\n        ? v.lodReduction\r\n        : defaults.lodReduction,\r\n    lodPixelError:\r\n      typeof v.lodPixelError === 'number' && v.lodPixelError > 0 ? v.lodPixelError : defaults.lodPixelError,\r\n    sdfResolutionScale:\r\n      typeof v.sdfResolutionScale === 'number' && v.sdfResolutionScale > 0\r\n        ? v.sdfResolutionScale\r\n        : defaults.sdfResolutionScale,\r\n    sdfUnitScale:\r\n      typeof v.sdfUnitScale === 'number' && v.sdfUnitScale > 0 ? v.sdfUnitScale : defaults.sdfUnitScale,\r\n    sdfTwoSided: typeof v.sdfTwoSided === 'boolean' ? v.sdfTwoSided : defaults.sdfTwoSided\r\n  };\r\n}\r\n\r\n/**\r\n * Reads the import settings of a mesh; without a `.zmeta` the mesh is not compressed.\r\n * @public\r\n */\r\nexport async function readMeshImportSettings(vfs: VFS, path: string): Promise<MeshImportSettings> {\r\n  const metaPath = getAssetMetaPath(path);\r\n  try {\r\n    if (await vfs.exists(metaPath)) {\r\n      const meta = JSON.parse((await vfs.readFile(metaPath, { encoding: 'utf8' })) as string);\r\n      return normalizeMeshImportSettings(meta?.mesh);\r\n    }\r\n  } catch (err) {\r\n    console.warn(`Ignoring unreadable asset meta ${metaPath}: ${err}`);\r\n  }\r\n  return defaultMeshImportSettings();\r\n}\r\n\r\n/**\r\n * Writes the import settings of a mesh to its `.zmeta` file.\r\n * @public\r\n */\r\nexport async function writeMeshImportSettings(vfs: VFS, path: string, settings: MeshImportSettings) {\r\n  const content = JSON.stringify({ version: ASSET_META_VERSION, mesh: settings }, null, 2);\r\n  await vfs.writeFile(getAssetMetaPath(path), content, { encoding: 'utf8', create: true });\r\n}\r\n"],"names":["MAX_MESH_LODS","COMPRESSIONS","NORMAL_BITS","defaultMeshImportSettings","compression","normalBits","lodEnabled","lodMinTriangles","lodReduction","lodPixelError","sdfResolutionScale","sdfUnitScale","sdfTwoSided","getMeshLodTargets","triangles","settings","targets","i","target","Math","floor","push","meshNeedsDerivedCopy","sourceTriangles","length","normalizeMeshImportSettings","value","v","defaults","includes","Number","isInteger","readMeshImportSettings","vfs","path","metaPath","getAssetMetaPath","exists","meta","JSON","parse","readFile","encoding","mesh","err","console","warn","writeMeshImportSettings","content","stringify","version","ASSET_META_VERSION","writeFile","create"],"mappings":"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"}

package/dist/asset/meshopt_decoder.js

@@ -0,0 +1,18 @@
+import { MeshoptDecoder } from '../node_modules/meshoptimizer/meshopt_decoder.js';
+
+/**
+ * meshoptimizer's decoder once its WebAssembly module is ready. Shared by the
+ * engine's binary .zmsh reader and the glTF meshopt extensions in the loaders
+ * package, so one copy serves both.
+ *
+ * Imported statically: the decoder is about 8 KB gzipped with the WebAssembly
+ * embedded, and a lazy import() would force every downstream single-file Rollup
+ * build to change its output options.
+ * @public
+ */ async function getMeshoptDecoder() {
+    await MeshoptDecoder.ready;
+    return MeshoptDecoder;
+}
+
+export { getMeshoptDecoder };
+//# sourceMappingURL=meshopt_decoder.js.map

package/dist/asset/meshopt_decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_decoder.js","sources":["../../src/asset/meshopt_decoder.ts"],"sourcesContent":["import { MeshoptDecoder } from 'meshoptimizer/decoder';\r\nimport type { MeshoptDecoderModule } from './zmsh_binary';\r\n\r\n/**\r\n * meshoptimizer's decoder once its WebAssembly module is ready. Shared by the\r\n * engine's binary .zmsh reader and the glTF meshopt extensions in the loaders\r\n * package, so one copy serves both.\r\n *\r\n * Imported statically: the decoder is about 8 KB gzipped with the WebAssembly\r\n * embedded, and a lazy import() would force every downstream single-file Rollup\r\n * build to change its output options.\r\n * @public\r\n */\r\nexport async function getMeshoptDecoder(): Promise<MeshoptDecoderModule> {\r\n  await MeshoptDecoder.ready;\r\n  return MeshoptDecoder;\r\n}\r\n"],"names":["getMeshoptDecoder","MeshoptDecoder","ready"],"mappings":";;AAGA;;;;;;;;;AASC,IACM,eAAeA,iBAAAA,GAAAA;AACpB,IAAA,MAAMC,eAAeC,KAAK;IAC1B,OAAOD,cAAAA;AACT;;;;"}

package/dist/asset/meshopt_simplifier.js

@@ -0,0 +1,26 @@
+import { MeshoptSimplifier } from '../node_modules/meshoptimizer/meshopt_simplifier.js';
+
+let ready = false;
+/**
+ * meshoptimizer's simplifier once its WebAssembly module is ready, for generating levels of
+ * detail (SharedModel.generateLods, shapes with LOD settings).
+ *
+ * Imported statically like the decoder (see getMeshoptDecoder): a lazy import() would force every
+ * downstream single-file Rollup build to change its output options.
+ * @public
+ */ async function getMeshoptSimplifier() {
+    await MeshoptSimplifier.ready;
+    ready = true;
+    return MeshoptSimplifier;
+}
+/**
+ * meshoptimizer's simplifier if its WebAssembly module is ready, null otherwise; for code that
+ * must generate levels of detail synchronously and can wait for {@link getMeshoptSimplifier}
+ * the first time.
+ * @public
+ */ function getMeshoptSimplifierIfReady() {
+    return ready ? MeshoptSimplifier : null;
+}
+
+export { getMeshoptSimplifier, getMeshoptSimplifierIfReady };
+//# sourceMappingURL=meshopt_simplifier.js.map

package/dist/asset/meshopt_simplifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_simplifier.js","sources":["../../src/asset/meshopt_simplifier.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { MeshoptSimplifier } from 'meshoptimizer/simplifier';\r\nimport type { MeshSimplifier } from './mesh_lod_builder';\r\n\r\nlet ready = false;\r\n\r\n/**\r\n * meshoptimizer's simplifier once its WebAssembly module is ready, for generating levels of\r\n * detail (SharedModel.generateLods, shapes with LOD settings).\r\n *\r\n * Imported statically like the decoder (see getMeshoptDecoder): a lazy import() would force every\r\n * downstream single-file Rollup build to change its output options.\r\n * @public\r\n */\r\nexport async function getMeshoptSimplifier(): Promise<MeshSimplifier> {\r\n  await MeshoptSimplifier.ready;\r\n  ready = true;\r\n  return MeshoptSimplifier as unknown as MeshSimplifier;\r\n}\r\n\r\n/**\r\n * meshoptimizer's simplifier if its WebAssembly module is ready, null otherwise; for code that\r\n * must generate levels of detail synchronously and can wait for {@link getMeshoptSimplifier}\r\n * the first time.\r\n * @public\r\n */\r\nexport function getMeshoptSimplifierIfReady(): Nullable<MeshSimplifier> {\r\n  return ready ? (MeshoptSimplifier as unknown as MeshSimplifier) : null;\r\n}\r\n"],"names":["ready","getMeshoptSimplifier","MeshoptSimplifier","getMeshoptSimplifierIfReady"],"mappings":";;AAIA,IAAIA,KAAQ,GAAA,KAAA;AAEZ;;;;;;;AAOC,IACM,eAAeC,oBAAAA,GAAAA;AACpB,IAAA,MAAMC,kBAAkBF,KAAK;IAC7BA,KAAQ,GAAA,IAAA;IACR,OAAOE,iBAAAA;AACT;AAEA;;;;;AAKC,IACM,SAASC,2BAAAA,GAAAA;AACd,IAAA,OAAOH,QAASE,iBAAkD,GAAA,IAAA;AACpE;;;;"}