@woosh/meep-engine 3.0.2 → 3.2.0

package/src/shade/renderer/loader/gltf/ext/GltfBufferViewExtension.js

@@ -1,54 +1,54 @@
-/**
- * One glTF extension that produces a bufferView's bytes.
- *
- * A bufferView extension says "these bytes are not in the buffer I point at; run this to get them".
- * `EXT_meshopt_compression` is one, `KHR_meshopt_compression` is another, and a future codec would be
- * a third; none of them is the parser's business beyond "does anything claim this view, and what
- * came out".
- *
- * A subclass answers two questions and nothing else. It never walks the document, never touches
- * `json.bufferViews`, and never decides what happens to what it produced - that belongs to
- * {@link gltf_apply_buffer_view_extensions}, which does it the same way for every extension.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class GltfBufferViewExtension {
-    /**
-     * The key this extension appears under in a bufferView's `extensions` object.
-     * @type {string}
-     */
-    name = "";
-
-    /**
-     * Produce the bytes the parent bufferView describes.
-     *
-     * Anything wrong with the extension object is wrong with the *file*, so it throws rather than
-     * asserts: `assert` is compiled out of production builds, and a mis-declared view that decodes
-     * to plausible rubbish is worse than one that does not load.
-     *
-     * @param {object} extension this extension's object, taken off the view for you
-     * @param {object} buffer_view the parent, for the layout it declares
-     * @param {Uint8Array[]} buffers the document's resolved buffers, to read the source range from
-     * @param {number} index which bufferView this is, so a message can name it
-     * @returns {Uint8Array} exactly `buffer_view.byteLength` bytes
-     * @throws {Error} if the extension object does not satisfy its specification
-     */
-    decode(extension, buffer_view, buffers, index) {
-        throw new Error(`${this.name} claims bufferViews but has no decoder`);
-    }
-
-    /**
-     * Whether this extension marks a buffer as one the file never wrote - a placeholder that exists
-     * only so the views over it have somewhere to point.
-     *
-     * Asking is how a loader avoids requesting a file that was never written. Most extensions have
-     * no opinion, which is why this answers `false` by default.
-     *
-     * @param {object} buffer an entry of `json.buffers`
-     * @returns {boolean}
-     */
-    is_placeholder_buffer(buffer) {
-        return false;
-    }
-}
+/**
+ * One glTF extension that produces a bufferView's bytes.
+ *
+ * A bufferView extension says "these bytes are not in the buffer I point at; run this to get them".
+ * `EXT_meshopt_compression` is one, `KHR_meshopt_compression` is another, and a future codec would be
+ * a third; none of them is the parser's business beyond "does anything claim this view, and what
+ * came out".
+ *
+ * A subclass answers two questions and nothing else. It never walks the document, never touches
+ * `json.bufferViews`, and never decides what happens to what it produced - that belongs to
+ * {@link gltf_apply_buffer_view_extensions}, which does it the same way for every extension.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GltfBufferViewExtension {
+    /**
+     * The key this extension appears under in a bufferView's `extensions` object.
+     * @type {string}
+     */
+    name = "";
+
+    /**
+     * Produce the bytes the parent bufferView describes.
+     *
+     * Anything wrong with the extension object is wrong with the *file*, so it throws rather than
+     * asserts: `assert` is compiled out of production builds, and a mis-declared view that decodes
+     * to plausible rubbish is worse than one that does not load.
+     *
+     * @param {object} extension this extension's object, taken off the view for you
+     * @param {object} buffer_view the parent, for the layout it declares
+     * @param {Uint8Array[]} buffers the document's resolved buffers, to read the source range from
+     * @param {number} index which bufferView this is, so a message can name it
+     * @returns {Uint8Array} exactly `buffer_view.byteLength` bytes
+     * @throws {Error} if the extension object does not satisfy its specification
+     */
+    decode(extension, buffer_view, buffers, index) {
+        throw new Error(`${this.name} claims bufferViews but has no decoder`);
+    }
+
+    /**
+     * Whether this extension marks a buffer as one the file never wrote - a placeholder that exists
+     * only so the views over it have somewhere to point.
+     *
+     * Asking is how a loader avoids requesting a file that was never written. Most extensions have
+     * no opinion, which is why this answers `false` by default.
+     *
+     * @param {object} buffer an entry of `json.buffers`
+     * @returns {boolean}
+     */
+    is_placeholder_buffer(buffer) {
+        return false;
+    }
+}

package/src/shade/renderer/loader/gltf/ext/GltfBufferViewExtensionSet.js

@@ -1,109 +1,109 @@
-import { assert } from "../../../../../core/assert.js";
-import { GltfBufferViewExtension } from "./GltfBufferViewExtension.js";
-
-/**
- * The bufferView extensions a parser knows how to honour.
- *
- * A glTF names its extensions by string, so this is keyed by string - it is modelling the format,
- * not saving boilerplate. What it holds are typed {@link GltfBufferViewExtension} objects, and the
- * only thing it does with them is answer "which of you claims this?".
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class GltfBufferViewExtensionSet {
-    /**
-     * @type {Map<string, GltfBufferViewExtension>}
-     */
-    #by_name = new Map();
-
-    /**
-     * @param {GltfBufferViewExtension[]} [extensions]
-     */
-    constructor(extensions = []) {
-        for (const extension of extensions) {
-            this.add(extension);
-        }
-    }
-
-    /**
-     * @param {GltfBufferViewExtension} extension
-     */
-    add(extension) {
-        assert.isInstanceOf(extension, GltfBufferViewExtension, 'extension');
-        assert.notEqual(extension.name, "", 'extension.name');
-        assert.notOk(this.#by_name.has(extension.name), `'${extension.name}' is already registered`);
-
-        this.#by_name.set(extension.name, extension);
-    }
-
-    /**
-     * @returns {string[]} every name this set answers to
-     */
-    get names() {
-        return Array.from(this.#by_name.keys());
-    }
-
-    /**
-     * Which extension produces this bufferView's bytes, if any.
-     *
-     * Two of them claiming the same view is a file that cannot be read whichever way you look at it:
-     * both would have to produce the same bytes, and nothing says which wins. That is a property of
-     * the collision rather than of either extension, so it is refused here.
-     *
-     * @param {{extensions?:Object}} buffer_view
-     * @param {number} [index] for the message
-     * @returns {GltfBufferViewExtension|null} `null` for a view nothing claims, which is nearly all
-     *   of them - a file that has never heard of any of these costs one lookup per registered name
-     * @throws {Error} if more than one registered extension claims it
-     */
-    claim(buffer_view, index = -1) {
-        const extensions = buffer_view.extensions;
-
-        if (extensions === undefined) {
-            return null;
-        }
-
-        /**
-         * @type {GltfBufferViewExtension|null}
-         */
-        let claimed = null;
-
-        for (const [name, extension] of this.#by_name) {
-            if (extensions[name] === undefined) {
-                continue;
-            }
-
-            if (claimed !== null) {
-                throw new Error(
-                    `bufferViews[${index}] is claimed by both '${claimed.name}' and '${name}',`
-                    + ` and they cannot both describe the same bytes`
-                );
-            }
-
-            claimed = extension;
-        }
-
-        return claimed;
-    }
-
-    /**
-     * Whether any registered extension marks this buffer as one the file never wrote.
-     *
-     * @param {object} buffer an entry of `json.buffers`
-     * @returns {boolean}
-     */
-    is_placeholder_buffer(buffer) {
-        if (buffer.extensions === undefined) {
-            return false;
-        }
-
-        for (const extension of this.#by_name.values()) {
-            if (extension.is_placeholder_buffer(buffer)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}
+import { assert } from "../../../../../core/assert.js";
+import { GltfBufferViewExtension } from "./GltfBufferViewExtension.js";
+
+/**
+ * The bufferView extensions a parser knows how to honour.
+ *
+ * A glTF names its extensions by string, so this is keyed by string - it is modelling the format,
+ * not saving boilerplate. What it holds are typed {@link GltfBufferViewExtension} objects, and the
+ * only thing it does with them is answer "which of you claims this?".
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GltfBufferViewExtensionSet {
+    /**
+     * @type {Map<string, GltfBufferViewExtension>}
+     */
+    #by_name = new Map();
+
+    /**
+     * @param {GltfBufferViewExtension[]} [extensions]
+     */
+    constructor(extensions = []) {
+        for (const extension of extensions) {
+            this.add(extension);
+        }
+    }
+
+    /**
+     * @param {GltfBufferViewExtension} extension
+     */
+    add(extension) {
+        assert.isInstanceOf(extension, GltfBufferViewExtension, 'extension');
+        assert.notEqual(extension.name, "", 'extension.name');
+        assert.notOk(this.#by_name.has(extension.name), `'${extension.name}' is already registered`);
+
+        this.#by_name.set(extension.name, extension);
+    }
+
+    /**
+     * @returns {string[]} every name this set answers to
+     */
+    get names() {
+        return Array.from(this.#by_name.keys());
+    }
+
+    /**
+     * Which extension produces this bufferView's bytes, if any.
+     *
+     * Two of them claiming the same view is a file that cannot be read whichever way you look at it:
+     * both would have to produce the same bytes, and nothing says which wins. That is a property of
+     * the collision rather than of either extension, so it is refused here.
+     *
+     * @param {{extensions?:Object}} buffer_view
+     * @param {number} [index] for the message
+     * @returns {GltfBufferViewExtension|null} `null` for a view nothing claims, which is nearly all
+     *   of them - a file that has never heard of any of these costs one lookup per registered name
+     * @throws {Error} if more than one registered extension claims it
+     */
+    claim(buffer_view, index = -1) {
+        const extensions = buffer_view.extensions;
+
+        if (extensions === undefined) {
+            return null;
+        }
+
+        /**
+         * @type {GltfBufferViewExtension|null}
+         */
+        let claimed = null;
+
+        for (const [name, extension] of this.#by_name) {
+            if (extensions[name] === undefined) {
+                continue;
+            }
+
+            if (claimed !== null) {
+                throw new Error(
+                    `bufferViews[${index}] is claimed by both '${claimed.name}' and '${name}',`
+                    + ` and they cannot both describe the same bytes`
+                );
+            }
+
+            claimed = extension;
+        }
+
+        return claimed;
+    }
+
+    /**
+     * Whether any registered extension marks this buffer as one the file never wrote.
+     *
+     * @param {object} buffer an entry of `json.buffers`
+     * @returns {boolean}
+     */
+    is_placeholder_buffer(buffer) {
+        if (buffer.extensions === undefined) {
+            return false;
+        }
+
+        for (const extension of this.#by_name.values()) {
+            if (extension.is_placeholder_buffer(buffer)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

package/src/shade/renderer/loader/gltf/ext/gltf_apply_buffer_view_extensions.js

@@ -1,69 +1,69 @@
-import { GltfBufferViewExtensionSet } from "./GltfBufferViewExtensionSet.js";
-
-/**
- * Turn every bufferView some extension produces the bytes for into an ordinary one.
- *
- * The extension decodes; this decides what becomes of the result, the same way for all of them: the
- * bytes get a buffer of their own appended to the document's, and the view is replaced by a
- * descriptor reading the whole of it. Accessors, sparse accessors and the mesh reader then work as
- * they do for a file that never used the extension - which is the point of doing this at the
- * bufferView layer rather than in the mesh reader.
- *
- * A view nothing claims comes back **as the same object**, and no buffer is appended. Nearly every
- * file is that case and pays one lookup per registered extension.
- *
- * Descriptors are replaced rather than rewritten. `TinyGltf` builds its image promises before its
- * buffers resolve, and each one closes over a bufferView object whose offsets it reads inside a
- * callback that runs after this does; leaving the originals alone is what keeps that read seeing
- * what it saw when it was scheduled, whatever order the promises settle in.
- *
- * @param {object[]} buffer_views `json.bufferViews`
- * @param {Uint8Array[]} buffers resolved; decoded buffers are APPENDED to it
- * @param {GltfBufferViewExtensionSet} extensions
- * @returns {object[]} a new array of buffer views
- * @throws {Error} on a view whose extension does not satisfy its specification
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function gltf_apply_buffer_view_extensions(buffer_views, buffers, extensions) {
-    const result = new Array(buffer_views.length);
-
-    for (let i = 0; i < buffer_views.length; i++) {
-        const view = buffer_views[i];
-
-        const claimed = extensions.claim(view, i);
-
-        if (claimed === null) {
-            result[i] = view;
-
-            continue;
-        }
-
-        const decoded = claimed.decode(view.extensions[claimed.name], view, buffers, i);
-
-        /*
-         The parent view is the contract for what the extension owed, and it is stated twice over -
-         once by the extension's own JSON and once by the view. An extension that satisfied its own
-         arithmetic and still produced the wrong number of bytes would otherwise hand a short buffer
-         to an accessor, which reads as a truncated mesh rather than as a bad file.
-        */
-        if (decoded.byteLength !== view.byteLength) {
-            throw new Error(
-                `'${claimed.name}' decoded bufferViews[${i}] to ${decoded.byteLength} bytes,`
-                + ` but the view declares ${view.byteLength}`
-            );
-        }
-
-        buffers.push(decoded);
-
-        result[i] = {
-            ...view,
-            buffer: buffers.length - 1,
-            byteOffset: 0,
-            byteLength: decoded.byteLength
-        };
-    }
-
-    return result;
-}
+import { GltfBufferViewExtensionSet } from "./GltfBufferViewExtensionSet.js";
+
+/**
+ * Turn every bufferView some extension produces the bytes for into an ordinary one.
+ *
+ * The extension decodes; this decides what becomes of the result, the same way for all of them: the
+ * bytes get a buffer of their own appended to the document's, and the view is replaced by a
+ * descriptor reading the whole of it. Accessors, sparse accessors and the mesh reader then work as
+ * they do for a file that never used the extension - which is the point of doing this at the
+ * bufferView layer rather than in the mesh reader.
+ *
+ * A view nothing claims comes back **as the same object**, and no buffer is appended. Nearly every
+ * file is that case and pays one lookup per registered extension.
+ *
+ * Descriptors are replaced rather than rewritten. `TinyGltf` builds its image promises before its
+ * buffers resolve, and each one closes over a bufferView object whose offsets it reads inside a
+ * callback that runs after this does; leaving the originals alone is what keeps that read seeing
+ * what it saw when it was scheduled, whatever order the promises settle in.
+ *
+ * @param {object[]} buffer_views `json.bufferViews`
+ * @param {Uint8Array[]} buffers resolved; decoded buffers are APPENDED to it
+ * @param {GltfBufferViewExtensionSet} extensions
+ * @returns {object[]} a new array of buffer views
+ * @throws {Error} on a view whose extension does not satisfy its specification
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function gltf_apply_buffer_view_extensions(buffer_views, buffers, extensions) {
+    const result = new Array(buffer_views.length);
+
+    for (let i = 0; i < buffer_views.length; i++) {
+        const view = buffer_views[i];
+
+        const claimed = extensions.claim(view, i);
+
+        if (claimed === null) {
+            result[i] = view;
+
+            continue;
+        }
+
+        const decoded = claimed.decode(view.extensions[claimed.name], view, buffers, i);
+
+        /*
+         The parent view is the contract for what the extension owed, and it is stated twice over -
+         once by the extension's own JSON and once by the view. An extension that satisfied its own
+         arithmetic and still produced the wrong number of bytes would otherwise hand a short buffer
+         to an accessor, which reads as a truncated mesh rather than as a bad file.
+        */
+        if (decoded.byteLength !== view.byteLength) {
+            throw new Error(
+                `'${claimed.name}' decoded bufferViews[${i}] to ${decoded.byteLength} bytes,`
+                + ` but the view declares ${view.byteLength}`
+            );
+        }
+
+        buffers.push(decoded);
+
+        result[i] = {
+            ...view,
+            buffer: buffers.length - 1,
+            byteOffset: 0,
+            byteLength: decoded.byteLength
+        };
+    }
+
+    return result;
+}

package/src/shade/renderer/loader/gltf/ext/gltf_buffer_view_extensions.js

@@ -1,22 +1,22 @@
-import { GltfBufferViewExtensionSet } from "./GltfBufferViewExtensionSet.js";
-import { EXT_MESHOPT_COMPRESSION, KHR_MESHOPT_COMPRESSION } from "./meshopt/MeshoptBufferViewExtension.js";
-
-/**
- * The bufferView extensions this parser honours out of the box.
- *
- * Held here rather than reached for inside the parser so that the parser names no extension: it asks
- * the set what claims a view, and the set is the one place that knows what is implemented. A caller
- * wanting a different answer sets {@link TinyGltf#bufferViewExtensions} rather than editing a
- * loader.
- *
- * Shared: adding to this changes every load in the process.
- *
- * @type {GltfBufferViewExtensionSet}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export const GLTF_BUFFER_VIEW_EXTENSIONS = new GltfBufferViewExtensionSet([
-    EXT_MESHOPT_COMPRESSION,
-    KHR_MESHOPT_COMPRESSION
-]);
+import { GltfBufferViewExtensionSet } from "./GltfBufferViewExtensionSet.js";
+import { EXT_MESHOPT_COMPRESSION, KHR_MESHOPT_COMPRESSION } from "./meshopt/MeshoptBufferViewExtension.js";
+
+/**
+ * The bufferView extensions this parser honours out of the box.
+ *
+ * Held here rather than reached for inside the parser so that the parser names no extension: it asks
+ * the set what claims a view, and the set is the one place that knows what is implemented. A caller
+ * wanting a different answer sets {@link TinyGltf#bufferViewExtensions} rather than editing a
+ * loader.
+ *
+ * Shared: adding to this changes every load in the process.
+ *
+ * @type {GltfBufferViewExtensionSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const GLTF_BUFFER_VIEW_EXTENSIONS = new GltfBufferViewExtensionSet([
+    EXT_MESHOPT_COMPRESSION,
+    KHR_MESHOPT_COMPRESSION
+]);

package/src/shade/renderer/loader/gltf/ext/gltf_geometry_extensions.js

@@ -1,39 +1,39 @@
-/**
- * The extensions that re-encode geometry, rather than change how it is shaded.
- *
- * These are the ones a reader cannot ignore: the bytes underneath are not the values the accessors
- * describe, so a reader without the decoder does not get slightly wrong geometry, it gets rubbish.
- * Everything else glTF defines — materials, textures, lighting, variants — leaves the vertex data
- * alone, and a reader that only wants geometry is right to ignore all of it.
- *
- * Naming them in one place is what lets a reader say which of them it can actually decode, rather
- * than carrying its own copy of the list and drifting from what its decoders support.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * @readonly
- * @type {string[]}
- */
-export const GLTF_GEOMETRY_EXTENSIONS = [
-    'EXT_meshopt_compression',
-    'KHR_meshopt_compression',
-    'KHR_draco_mesh_compression',
-];
-
-/**
- * Which of them a given set of bufferView extensions leaves undecodable.
- *
- * `KHR_draco_mesh_compression` is always among them: it re-encodes a *primitive* rather than a
- * bufferView, so no bufferView extension can answer for it.
- *
- * @param {GltfBufferViewExtensionSet} extensions
- * @returns {string[]}
- */
-export function gltf_undecodable_geometry_extensions(extensions) {
-    const supported = extensions.names;
-
-    return GLTF_GEOMETRY_EXTENSIONS.filter((name) => !supported.includes(name));
-}
+/**
+ * The extensions that re-encode geometry, rather than change how it is shaded.
+ *
+ * These are the ones a reader cannot ignore: the bytes underneath are not the values the accessors
+ * describe, so a reader without the decoder does not get slightly wrong geometry, it gets rubbish.
+ * Everything else glTF defines — materials, textures, lighting, variants — leaves the vertex data
+ * alone, and a reader that only wants geometry is right to ignore all of it.
+ *
+ * Naming them in one place is what lets a reader say which of them it can actually decode, rather
+ * than carrying its own copy of the list and drifting from what its decoders support.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @readonly
+ * @type {string[]}
+ */
+export const GLTF_GEOMETRY_EXTENSIONS = [
+    'EXT_meshopt_compression',
+    'KHR_meshopt_compression',
+    'KHR_draco_mesh_compression',
+];
+
+/**
+ * Which of them a given set of bufferView extensions leaves undecodable.
+ *
+ * `KHR_draco_mesh_compression` is always among them: it re-encodes a *primitive* rather than a
+ * bufferView, so no bufferView extension can answer for it.
+ *
+ * @param {GltfBufferViewExtensionSet} extensions
+ * @returns {string[]}
+ */
+export function gltf_undecodable_geometry_extensions(extensions) {
+    const supported = extensions.names;
+
+    return GLTF_GEOMETRY_EXTENSIONS.filter((name) => !supported.includes(name));
+}