@woosh/meep-engine 3.0.2 → 3.2.0

package/src/core/binary/meshopt/meshopt_decode_byte_group.js

@@ -1,67 +1,67 @@
-import { assert } from "../../assert.js";
-import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
-
-/**
- * Decode one group of sixteen byte deltas.
- *
- * `bits` is the width the group was coded at, and comes from the data block's header bits through
- * whichever table the control mode selected:
- *
- * - `0` — every delta is zero and nothing is stored,
- * - `1`, `2`, `4` — sentinel coding: the deltas are packed at that width, and any that came out
- *   all-ones is taken instead from the run of whole bytes that follows the packed ones,
- * - `8` — sixteen bytes, verbatim.
- *
- * The 2-bit and 4-bit packings run from the most significant bit of each byte down; the 1-bit
- * packing runs the other way. That asymmetry is the specification's, and is there so that an
- * implementation with lookup tables can share them across widths.
- *
- * PRECONDITION: at least 24 bytes (`MESHOPT_GROUP_DECODE_LIMIT`) are readable at `source_offset` —
- * the caller checks this once per group, which is what a well-formed stream's tail padding
- * guarantees.
- *
- * @param {Uint8Array} destination
- * @param {number} destination_offset sixteen bytes are written here
- * @param {Uint8Array} source
- * @param {number} source_offset
- * @param {number} bits 0, 1, 2, 4 or 8
- * @returns {number} the offset just past the group
- */
-export function meshopt_decode_byte_group(destination, destination_offset, source, source_offset, bits) {
-    assert.isOneOf(bits, [0, 1, 2, 4, 8], 'bits');
-
-    if (bits === 0) {
-        destination.fill(0, destination_offset, destination_offset + MESHOPT_GROUP_SIZE);
-
-        return source_offset;
-    }
-
-    if (bits === 8) {
-        for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
-            destination[destination_offset + i] = source[source_offset + i];
-        }
-
-        return source_offset + MESHOPT_GROUP_SIZE;
-    }
-
-    const per_byte = 8 / bits;
-    const packed_bytes = MESHOPT_GROUP_SIZE / per_byte;
-    const sentinel = (1 << bits) - 1;
-
-    // 1-bit codes are stored least significant first, the wider ones most significant first
-    const ascending = bits === 1;
-
-    let sentinel_offset = source_offset + packed_bytes;
-
-    for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
-        const packed = source[source_offset + ((i / per_byte) | 0)];
-        const lane = i % per_byte;
-        const shift = ascending ? (lane * bits) : (8 - bits - lane * bits);
-
-        const code = (packed >> shift) & sentinel;
-
-        destination[destination_offset + i] = (code === sentinel) ? source[sentinel_offset++] : code;
-    }
-
-    return sentinel_offset;
-}
+import { assert } from "../../assert.js";
+import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+
+/**
+ * Decode one group of sixteen byte deltas.
+ *
+ * `bits` is the width the group was coded at, and comes from the data block's header bits through
+ * whichever table the control mode selected:
+ *
+ * - `0` — every delta is zero and nothing is stored,
+ * - `1`, `2`, `4` — sentinel coding: the deltas are packed at that width, and any that came out
+ *   all-ones is taken instead from the run of whole bytes that follows the packed ones,
+ * - `8` — sixteen bytes, verbatim.
+ *
+ * The 2-bit and 4-bit packings run from the most significant bit of each byte down; the 1-bit
+ * packing runs the other way. That asymmetry is the specification's, and is there so that an
+ * implementation with lookup tables can share them across widths.
+ *
+ * PRECONDITION: at least 24 bytes (`MESHOPT_GROUP_DECODE_LIMIT`) are readable at `source_offset` —
+ * the caller checks this once per group, which is what a well-formed stream's tail padding
+ * guarantees.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset sixteen bytes are written here
+ * @param {Uint8Array} source
+ * @param {number} source_offset
+ * @param {number} bits 0, 1, 2, 4 or 8
+ * @returns {number} the offset just past the group
+ */
+export function meshopt_decode_byte_group(destination, destination_offset, source, source_offset, bits) {
+    assert.isOneOf(bits, [0, 1, 2, 4, 8], 'bits');
+
+    if (bits === 0) {
+        destination.fill(0, destination_offset, destination_offset + MESHOPT_GROUP_SIZE);
+
+        return source_offset;
+    }
+
+    if (bits === 8) {
+        for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+            destination[destination_offset + i] = source[source_offset + i];
+        }
+
+        return source_offset + MESHOPT_GROUP_SIZE;
+    }
+
+    const per_byte = 8 / bits;
+    const packed_bytes = MESHOPT_GROUP_SIZE / per_byte;
+    const sentinel = (1 << bits) - 1;
+
+    // 1-bit codes are stored least significant first, the wider ones most significant first
+    const ascending = bits === 1;
+
+    let sentinel_offset = source_offset + packed_bytes;
+
+    for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+        const packed = source[source_offset + ((i / per_byte) | 0)];
+        const lane = i % per_byte;
+        const shift = ascending ? (lane * bits) : (8 - bits - lane * bits);
+
+        const code = (packed >> shift) & sentinel;
+
+        destination[destination_offset + i] = (code === sentinel) ? source[sentinel_offset++] : code;
+    }
+
+    return sentinel_offset;
+}

package/src/core/binary/meshopt/meshopt_decode_data_block.js

@@ -1,59 +1,59 @@
-import { MESHOPT_GROUP_DECODE_LIMIT, MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
-import { meshopt_decode_byte_group } from "./meshopt_decode_byte_group.js";
-
-/**
- * Decode one "data block" — the delta bytes stored for a single byte position of the element,
- * across one attribute block's worth of groups.
- *
- * The block is `ceil(group_count / 4)` header bytes, two bits per group packed least significant
- * first, followed by the groups themselves. The two bits index `bit_table`, which is what the
- * control mode (version 1) or the format itself (version 0) decided the four header values mean.
- *
- * @param {Uint8Array} destination `group_count * 16` delta bytes are written here
- * @param {number} destination_offset
- * @param {number} group_count
- * @param {Uint8Array} source
- * @param {number} source_offset
- * @param {number} source_end exclusive; the whole stream, tail included — the tail padding is the
- *   slack the per-group check spends
- * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8
- * @returns {number} the offset just past the data block
- * @throws {Error} if the block runs past `source_end`
- */
-export function meshopt_decode_data_block(
-    destination, destination_offset,
-    group_count,
-    source, source_offset, source_end,
-    bit_table
-) {
-    const header_bytes = (group_count + 3) >> 2;
-
-    if (source_offset + header_bytes > source_end) {
-        throw new Error(
-            `meshopt data block header at ${source_offset} runs past the end of the stream (${source_end})`
-        );
-    }
-
-    const header_offset = source_offset;
-
-    let offset = source_offset + header_bytes;
-    let written = destination_offset;
-
-    for (let g = 0; g < group_count; g++) {
-        if (source_end - offset < MESHOPT_GROUP_DECODE_LIMIT) {
-            throw new Error(
-                `meshopt delta group ${g} at ${offset} has fewer than ${MESHOPT_GROUP_DECODE_LIMIT}` +
-                ` bytes behind it (stream ends at ${source_end})`
-            );
-        }
-
-        const header = source[header_offset + (g >> 2)];
-        const bits = bit_table[(header >> ((g & 3) * 2)) & 3];
-
-        offset = meshopt_decode_byte_group(destination, written, source, offset, bits);
-
-        written += MESHOPT_GROUP_SIZE;
-    }
-
-    return offset;
-}
+import { MESHOPT_GROUP_DECODE_LIMIT, MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+import { meshopt_decode_byte_group } from "./meshopt_decode_byte_group.js";
+
+/**
+ * Decode one "data block" — the delta bytes stored for a single byte position of the element,
+ * across one attribute block's worth of groups.
+ *
+ * The block is `ceil(group_count / 4)` header bytes, two bits per group packed least significant
+ * first, followed by the groups themselves. The two bits index `bit_table`, which is what the
+ * control mode (version 1) or the format itself (version 0) decided the four header values mean.
+ *
+ * @param {Uint8Array} destination `group_count * 16` delta bytes are written here
+ * @param {number} destination_offset
+ * @param {number} group_count
+ * @param {Uint8Array} source
+ * @param {number} source_offset
+ * @param {number} source_end exclusive; the whole stream, tail included — the tail padding is the
+ *   slack the per-group check spends
+ * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8
+ * @returns {number} the offset just past the data block
+ * @throws {Error} if the block runs past `source_end`
+ */
+export function meshopt_decode_data_block(
+    destination, destination_offset,
+    group_count,
+    source, source_offset, source_end,
+    bit_table
+) {
+    const header_bytes = (group_count + 3) >> 2;
+
+    if (source_offset + header_bytes > source_end) {
+        throw new Error(
+            `meshopt data block header at ${source_offset} runs past the end of the stream (${source_end})`
+        );
+    }
+
+    const header_offset = source_offset;
+
+    let offset = source_offset + header_bytes;
+    let written = destination_offset;
+
+    for (let g = 0; g < group_count; g++) {
+        if (source_end - offset < MESHOPT_GROUP_DECODE_LIMIT) {
+            throw new Error(
+                `meshopt delta group ${g} at ${offset} has fewer than ${MESHOPT_GROUP_DECODE_LIMIT}` +
+                ` bytes behind it (stream ends at ${source_end})`
+            );
+        }
+
+        const header = source[header_offset + (g >> 2)];
+        const bits = bit_table[(header >> ((g & 3) * 2)) & 3];
+
+        offset = meshopt_decode_byte_group(destination, written, source, offset, bits);
+
+        written += MESHOPT_GROUP_SIZE;
+    }
+
+    return offset;
+}

package/src/core/binary/meshopt/meshopt_decode_filter_color.js

@@ -1,69 +1,69 @@
-import { assert } from "../../assert.js";
-import { msb_32 } from "../msb_32.js";
-import { round_half_away_from_zero } from "../../math/round_half_away_from_zero.js";
-
-/**
- * Turn YCoCg colour back into RGBA, in place.
- *
- * Each element is a luma, two chroma differences, and an alpha whose most significant set bit says
- * what precision the whole element was stored at. Luma and alpha are unsigned; the two chroma
- * components are signed, in the same element - which is the detail that makes a single typed view
- * over the element wrong.
- *
- * Alpha carries its marker bit in the position the precision defines, so it has one bit less than
- * the others; it is widened back by replicating its least significant bit, and the whole element is
- * then scaled to the full range of its component type.
- *
- * This filter exists only in `KHR_meshopt_compression`.
- *
- * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
- *
- * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for its component type
- * @param {number} count elements
- * @param {number} byte_stride 4 for 8-bit components, 8 for 16-bit
- */
-export function meshopt_decode_filter_color(destination, count, byte_stride) {
-    assert.isNonNegativeInteger(count, 'count');
-    assert.isOneOf(byte_stride, [4, 8], 'byte_stride');
-    assert.equal(
-        destination.length, count * byte_stride,
-        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
-    );
-    assert.equal(
-        destination.byteOffset % (byte_stride / 4), 0,
-        `destination must start on a ${byte_stride / 4} byte boundary to be read as components`
-    );
-
-    const components = byte_stride === 4
-        ? new Uint8Array(destination.buffer, destination.byteOffset, count * 4)
-        : new Uint16Array(destination.buffer, destination.byteOffset, count * 4);
-
-    const component_bits = byte_stride === 4 ? 8 : 16;
-    const max = byte_stride === 4 ? 255 : 65535;
-
-    const sign_shift = 32 - component_bits;
-
-    for (let i = 0; i < count; i++) {
-        const o = i * 4;
-
-        const luma = components[o];
-
-        // the two chroma components are signed at the element's own width, inside an unsigned one
-        const co = (components[o + 1] << sign_shift) >> sign_shift;
-        const cg = (components[o + 2] << sign_shift) >> sign_shift;
-
-        const encoded_alpha = components[o + 3];
-
-        // the marker bit is the most significant set bit, and it is what names the precision
-        const range = (1 << (msb_32(encoded_alpha) + 1)) - 1;
-
-        const alpha = encoded_alpha & (range >> 1);
-
-        const scale = max / range;
-
-        components[o] = round_half_away_from_zero((luma + co - cg) * scale);
-        components[o + 1] = round_half_away_from_zero((luma + cg) * scale);
-        components[o + 2] = round_half_away_from_zero((luma - co - cg) * scale);
-        components[o + 3] = round_half_away_from_zero(((alpha << 1) | (alpha & 1)) * scale);
-    }
-}
+import { assert } from "../../assert.js";
+import { msb_32 } from "../msb_32.js";
+import { round_half_away_from_zero } from "../../math/round_half_away_from_zero.js";
+
+/**
+ * Turn YCoCg colour back into RGBA, in place.
+ *
+ * Each element is a luma, two chroma differences, and an alpha whose most significant set bit says
+ * what precision the whole element was stored at. Luma and alpha are unsigned; the two chroma
+ * components are signed, in the same element - which is the detail that makes a single typed view
+ * over the element wrong.
+ *
+ * Alpha carries its marker bit in the position the precision defines, so it has one bit less than
+ * the others; it is widened back by replicating its least significant bit, and the whole element is
+ * then scaled to the full range of its component type.
+ *
+ * This filter exists only in `KHR_meshopt_compression`.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ *
+ * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for its component type
+ * @param {number} count elements
+ * @param {number} byte_stride 4 for 8-bit components, 8 for 16-bit
+ */
+export function meshopt_decode_filter_color(destination, count, byte_stride) {
+    assert.isNonNegativeInteger(count, 'count');
+    assert.isOneOf(byte_stride, [4, 8], 'byte_stride');
+    assert.equal(
+        destination.length, count * byte_stride,
+        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
+    );
+    assert.equal(
+        destination.byteOffset % (byte_stride / 4), 0,
+        `destination must start on a ${byte_stride / 4} byte boundary to be read as components`
+    );
+
+    const components = byte_stride === 4
+        ? new Uint8Array(destination.buffer, destination.byteOffset, count * 4)
+        : new Uint16Array(destination.buffer, destination.byteOffset, count * 4);
+
+    const component_bits = byte_stride === 4 ? 8 : 16;
+    const max = byte_stride === 4 ? 255 : 65535;
+
+    const sign_shift = 32 - component_bits;
+
+    for (let i = 0; i < count; i++) {
+        const o = i * 4;
+
+        const luma = components[o];
+
+        // the two chroma components are signed at the element's own width, inside an unsigned one
+        const co = (components[o + 1] << sign_shift) >> sign_shift;
+        const cg = (components[o + 2] << sign_shift) >> sign_shift;
+
+        const encoded_alpha = components[o + 3];
+
+        // the marker bit is the most significant set bit, and it is what names the precision
+        const range = (1 << (msb_32(encoded_alpha) + 1)) - 1;
+
+        const alpha = encoded_alpha & (range >> 1);
+
+        const scale = max / range;
+
+        components[o] = round_half_away_from_zero((luma + co - cg) * scale);
+        components[o + 1] = round_half_away_from_zero((luma + cg) * scale);
+        components[o + 2] = round_half_away_from_zero((luma - co - cg) * scale);
+        components[o + 3] = round_half_away_from_zero(((alpha << 1) | (alpha & 1)) * scale);
+    }
+}

package/src/core/binary/meshopt/meshopt_decode_filter_exponential.js

@@ -1,43 +1,43 @@
-import { assert } from "../../assert.js";
-import { exp2 } from "../../math/exp2.js";
-
-/**
- * Turn exponent-and-mantissa words into single-precision floats, in place.
- *
- * Each 4-byte word is a signed 8-bit exponent over a signed 24-bit mantissa, and decodes to
- * `2^e * m`. Splitting the two lets an encoder spend exactly as many mantissa bits as a track needs
- * while keeping the field byte-aligned, which is what a general purpose compressor running over the
- * container afterwards wants.
- *
- * The specification bounds `e` to [-100, 100] and the mantissa to 24 bits, so the product is exact
- * in single precision: computing it in JavaScript's doubles and storing through a `Float32Array`
- * rounds once, and lands on the same bits as building the exponent and multiplying would.
- *
- * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
- *
- * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for 32-bit words
- * @param {number} count elements
- * @param {number} byte_stride divisible by 4
- */
-export function meshopt_decode_filter_exponential(destination, count, byte_stride) {
-    assert.isNonNegativeInteger(count, 'count');
-    assert.isPositiveInteger(byte_stride, 'byte_stride');
-    assert.equal(byte_stride % 4, 0, `byte_stride(=${byte_stride}) must be divisible by 4`);
-    assert.equal(
-        destination.length, count * byte_stride,
-        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
-    );
-    assert.equal(destination.byteOffset % 4, 0, 'destination must start on a 4 byte boundary');
-
-    const word_count = count * (byte_stride / 4);
-
-    const words = new Int32Array(destination.buffer, destination.byteOffset, word_count);
-    const floats = new Float32Array(destination.buffer, destination.byteOffset, word_count);
-
-    for (let i = 0; i < word_count; i++) {
-        const word = words[i];
-
-        // both halves are signed, and the mantissa is sign-extended out of the low 24 bits
-        floats[i] = exp2(word >> 24) * ((word << 8) >> 8);
-    }
-}
+import { assert } from "../../assert.js";
+import { exp2 } from "../../math/exp2.js";
+
+/**
+ * Turn exponent-and-mantissa words into single-precision floats, in place.
+ *
+ * Each 4-byte word is a signed 8-bit exponent over a signed 24-bit mantissa, and decodes to
+ * `2^e * m`. Splitting the two lets an encoder spend exactly as many mantissa bits as a track needs
+ * while keeping the field byte-aligned, which is what a general purpose compressor running over the
+ * container afterwards wants.
+ *
+ * The specification bounds `e` to [-100, 100] and the mantissa to 24 bits, so the product is exact
+ * in single precision: computing it in JavaScript's doubles and storing through a `Float32Array`
+ * rounds once, and lands on the same bits as building the exponent and multiplying would.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ *
+ * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for 32-bit words
+ * @param {number} count elements
+ * @param {number} byte_stride divisible by 4
+ */
+export function meshopt_decode_filter_exponential(destination, count, byte_stride) {
+    assert.isNonNegativeInteger(count, 'count');
+    assert.isPositiveInteger(byte_stride, 'byte_stride');
+    assert.equal(byte_stride % 4, 0, `byte_stride(=${byte_stride}) must be divisible by 4`);
+    assert.equal(
+        destination.length, count * byte_stride,
+        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
+    );
+    assert.equal(destination.byteOffset % 4, 0, 'destination must start on a 4 byte boundary');
+
+    const word_count = count * (byte_stride / 4);
+
+    const words = new Int32Array(destination.buffer, destination.byteOffset, word_count);
+    const floats = new Float32Array(destination.buffer, destination.byteOffset, word_count);
+
+    for (let i = 0; i < word_count; i++) {
+        const word = words[i];
+
+        // both halves are signed, and the mantissa is sign-extended out of the low 24 bits
+        floats[i] = exp2(word >> 24) * ((word << 8) >> 8);
+    }
+}

package/src/core/binary/meshopt/meshopt_decode_filter_octahedral.js

@@ -1,60 +1,60 @@
-import { decode_octahedron_to_unit } from "../../geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
-import { round_half_away_from_zero } from "../../math/round_half_away_from_zero.js";
-import { assert } from "../../assert.js";
-
-/**
- * @type {Float64Array}
- */
-const unit = new Float64Array(3);
-
-/**
- * Turn octahedrally encoded unit vectors back into components, in place.
- *
- * Each element is four components: two octahedral coordinates, then this element's own
- * representation of 1.0 - which is what lets the encoder pick a different precision per vector - and
- * then a fourth that is passed through untouched, because a tangent keeps its handedness there.
- *
- * The octahedron itself is meep's own {@link decode_octahedron_to_unit}. It is the same arithmetic
- * as the specification's `copysign` form, but written with the fold around Y: its `(x, y, z)` is the
- * specification's `(x, z, y)`, and the swizzle below is the whole of the adaptation.
- *
- * A component of the fourth-precision word that is zero, or components outside the range that word
- * implies, are explicitly unspecified by the format. What comes out is finite garbage rather than a
- * value, which is what a typed array does with a NaN, and is not guarded against.
- *
- * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
- *
- * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for its component type
- * @param {number} count elements
- * @param {number} byte_stride 4 for 8-bit components, 8 for 16-bit
- */
-export function meshopt_decode_filter_octahedral(destination, count, byte_stride) {
-    assert.isNonNegativeInteger(count, 'count');
-    assert.isOneOf(byte_stride, [4, 8], 'byte_stride');
-    assert.equal(
-        destination.length, count * byte_stride,
-        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
-    );
-    assert.equal(
-        destination.byteOffset % (byte_stride / 4), 0,
-        `destination must start on a ${byte_stride / 4} byte boundary to be read as components`
-    );
-
-    const components = byte_stride === 4
-        ? new Int8Array(destination.buffer, destination.byteOffset, count * 4)
-        : new Int16Array(destination.buffer, destination.byteOffset, count * 4);
-
-    const max = byte_stride === 4 ? 127 : 32767;
-
-    for (let i = 0; i < count; i++) {
-        const o = i * 4;
-
-        const one = components[o + 2];
-
-        decode_octahedron_to_unit(unit, 0, components[o] / one, components[o + 1] / one);
-
-        components[o] = round_half_away_from_zero(unit[0] * max);
-        components[o + 1] = round_half_away_from_zero(unit[2] * max);
-        components[o + 2] = round_half_away_from_zero(unit[1] * max);
-    }
-}
+import { decode_octahedron_to_unit } from "../../geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
+import { round_half_away_from_zero } from "../../math/round_half_away_from_zero.js";
+import { assert } from "../../assert.js";
+
+/**
+ * @type {Float64Array}
+ */
+const unit = new Float64Array(3);
+
+/**
+ * Turn octahedrally encoded unit vectors back into components, in place.
+ *
+ * Each element is four components: two octahedral coordinates, then this element's own
+ * representation of 1.0 - which is what lets the encoder pick a different precision per vector - and
+ * then a fourth that is passed through untouched, because a tangent keeps its handedness there.
+ *
+ * The octahedron itself is meep's own {@link decode_octahedron_to_unit}. It is the same arithmetic
+ * as the specification's `copysign` form, but written with the fold around Y: its `(x, y, z)` is the
+ * specification's `(x, z, y)`, and the swizzle below is the whole of the adaptation.
+ *
+ * A component of the fourth-precision word that is zero, or components outside the range that word
+ * implies, are explicitly unspecified by the format. What comes out is finite garbage rather than a
+ * value, which is what a typed array does with a NaN, and is not guarded against.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ *
+ * @param {Uint8Array} destination `count * byte_stride` bytes, aligned for its component type
+ * @param {number} count elements
+ * @param {number} byte_stride 4 for 8-bit components, 8 for 16-bit
+ */
+export function meshopt_decode_filter_octahedral(destination, count, byte_stride) {
+    assert.isNonNegativeInteger(count, 'count');
+    assert.isOneOf(byte_stride, [4, 8], 'byte_stride');
+    assert.equal(
+        destination.length, count * byte_stride,
+        `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
+    );
+    assert.equal(
+        destination.byteOffset % (byte_stride / 4), 0,
+        `destination must start on a ${byte_stride / 4} byte boundary to be read as components`
+    );
+
+    const components = byte_stride === 4
+        ? new Int8Array(destination.buffer, destination.byteOffset, count * 4)
+        : new Int16Array(destination.buffer, destination.byteOffset, count * 4);
+
+    const max = byte_stride === 4 ? 127 : 32767;
+
+    for (let i = 0; i < count; i++) {
+        const o = i * 4;
+
+        const one = components[o + 2];
+
+        decode_octahedron_to_unit(unit, 0, components[o] / one, components[o + 1] / one);
+
+        components[o] = round_half_away_from_zero(unit[0] * max);
+        components[o + 1] = round_half_away_from_zero(unit[2] * max);
+        components[o + 2] = round_half_away_from_zero(unit[1] * max);
+    }
+}