@woosh/meep-engine 3.17.1 → 3.18.0

package/src/core/binary/meshopt/MESHOPT_VERTEX_BLOCK.d.ts

@@ -0,0 +1,56 @@
+/**
+ * How many elements one block holds at a given stride — the same arithmetic on both sides, because
+ * a block boundary is not stored anywhere and both sides have to arrive at it alone.
+ *
+ * @param {number} byte_stride
+ * @returns {number}
+ */
+export function meshopt_max_block_elements(byte_stride: number): number;
+/**
+ * The shape of an attribute stream's blocks, shared by the two sides of the codec. A decoder that
+ * disagreed with an encoder about any of this would not fail — it would produce different bytes.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ */
+/**
+ * Header nibble every attribute stream starts with; the low nibble is the codec version.
+ * @type {number}
+ */
+export const MESHOPT_VERTEX_HEADER: number;
+/**
+ * An attribute block never holds more than this many bytes of element data, which is what keeps a
+ * block's deltas inside one scratch buffer and inside a cache level while they are transposed.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BLOCK_BYTES: number;
+/**
+ * ...nor more than this many elements, whatever the stride.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BLOCK_ELEMENTS: number;
+/**
+ * Largest element the format admits, and so the largest baseline there can be.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BYTE_STRIDE: number;
+/**
+ * How much of the stream sits behind the last attribute block, at the least. The tail block itself
+ * may be longer than this — a wide element's baseline is — and then there is no padding at all.
+ * @type {number[]}
+ */
+export const MESHOPT_TAIL_MIN_BY_VERSION: number[];
+/**
+ * What the two bits stored per group mean, by the control mode that selected the table. Version 0
+ * has no control header and always reads {@link MESHOPT_BITS_VERSION_0}.
+ *
+ * Control mode 2 (nothing stored) and control mode 3 (literal, no header bits) have no table
+ * because they have no header bits to index one with.
+ *
+ * @type {number[][]}
+ */
+export const MESHOPT_BITS_BY_CONTROL: number[][];
+/**
+ * @type {number[]}
+ */
+export const MESHOPT_BITS_VERSION_0: number[];
+//# sourceMappingURL=MESHOPT_VERTEX_BLOCK.d.ts.map

package/src/core/binary/meshopt/MESHOPT_VERTEX_BLOCK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESHOPT_VERTEX_BLOCK.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/MESHOPT_VERTEX_BLOCK.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,wDAHW,MAAM,GACJ,MAAM,CAOlB;AAtED;;;;;GAKG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,sCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,yCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,sCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,0CAFU,MAAM,EAAE,CAEkC;AAEpD;;;;;;;;GAQG;AACH,sCAFU,MAAM,EAAE,EAAE,CAKlB;AAEF;;GAEG;AACH,qCAFU,MAAM,EAAE,CAEiC"}

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

@@ -0,0 +1,73 @@
+import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+
+/**
+ * The shape of an attribute stream's blocks, shared by the two sides of the codec. A decoder that
+ * disagreed with an encoder about any of this would not fail — it would produce different bytes.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ */
+
+/**
+ * Header nibble every attribute stream starts with; the low nibble is the codec version.
+ * @type {number}
+ */
+export const MESHOPT_VERTEX_HEADER = 0xa0;
+
+/**
+ * An attribute block never holds more than this many bytes of element data, which is what keeps a
+ * block's deltas inside one scratch buffer and inside a cache level while they are transposed.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BLOCK_BYTES = 8192;
+
+/**
+ * ...nor more than this many elements, whatever the stride.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BLOCK_ELEMENTS = 256;
+
+/**
+ * Largest element the format admits, and so the largest baseline there can be.
+ * @type {number}
+ */
+export const MESHOPT_MAX_BYTE_STRIDE = 256;
+
+/**
+ * How much of the stream sits behind the last attribute block, at the least. The tail block itself
+ * may be longer than this — a wide element's baseline is — and then there is no padding at all.
+ * @type {number[]}
+ */
+export const MESHOPT_TAIL_MIN_BY_VERSION = [32, 24];
+
+/**
+ * What the two bits stored per group mean, by the control mode that selected the table. Version 0
+ * has no control header and always reads {@link MESHOPT_BITS_VERSION_0}.
+ *
+ * Control mode 2 (nothing stored) and control mode 3 (literal, no header bits) have no table
+ * because they have no header bits to index one with.
+ *
+ * @type {number[][]}
+ */
+export const MESHOPT_BITS_BY_CONTROL = [
+    [0, 1, 2, 4],
+    [1, 2, 4, 8]
+];
+
+/**
+ * @type {number[]}
+ */
+export const MESHOPT_BITS_VERSION_0 = [0, 2, 4, 8];
+
+/**
+ * How many elements one block holds at a given stride — the same arithmetic on both sides, because
+ * a block boundary is not stored anywhere and both sides have to arrive at it alone.
+ *
+ * @param {number} byte_stride
+ * @returns {number}
+ */
+export function meshopt_max_block_elements(byte_stride) {
+    return Math.min(
+        Math.floor(MESHOPT_MAX_BLOCK_BYTES / byte_stride) & ~(MESHOPT_GROUP_SIZE - 1),
+        MESHOPT_MAX_BLOCK_ELEMENTS
+    );
+}

package/src/core/binary/meshopt/meshopt_decode_vertex_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshopt_decode_vertex_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_decode_vertex_buffer.js"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAPW,UAAU,SACV,MAAM,eACN,MAAM,UACN,UAAU,GACR,MAAM,CAyGlB"}
+{"version":3,"file":"meshopt_decode_vertex_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_decode_vertex_buffer.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAPW,UAAU,SACV,MAAM,eACN,MAAM,UACN,UAAU,GACR,MAAM,CAsGlB"}

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

@@ -1,58 +1,16 @@
 import { assert } from "../../assert.js";
 import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+import {
+    MESHOPT_BITS_BY_CONTROL,
+    MESHOPT_BITS_VERSION_0,
+    MESHOPT_MAX_BLOCK_BYTES,
+    MESHOPT_MAX_BYTE_STRIDE,
+    MESHOPT_TAIL_MIN_BY_VERSION,
+    MESHOPT_VERTEX_HEADER,
+    meshopt_max_block_elements
+} from "./MESHOPT_VERTEX_BLOCK.js";
 import { meshopt_decode_data_block } from "./meshopt_decode_data_block.js";
 
-/**
- * Header nibble every attribute stream starts with; the low nibble is the codec version.
- * @type {number}
- */
-const HEADER = 0xa0;
-
-/**
- * An attribute block never holds more than this many bytes of element data, which is what keeps a
- * block's deltas inside {@link delta_scratch} and inside a cache level while they are transposed.
- * @type {number}
- */
-const MAX_BLOCK_BYTES = 8192;
-
-/**
- * ...nor more than this many elements, whatever the stride.
- * @type {number}
- */
-const MAX_BLOCK_ELEMENTS = 256;
-
-/**
- * Largest element the format admits, and so the largest baseline there can be.
- * @type {number}
- */
-const MAX_BYTE_STRIDE = 256;
-
-/**
- * How much of the stream sits behind the last attribute block, at the least. The tail block itself
- * may be longer than this - a wide element's baseline is - and then there is no padding at all.
- * @type {number[]}
- */
-const TAIL_MIN_BY_VERSION = [32, 24];
-
-/**
- * What the two bits stored per group mean, by the control mode that selected the table. Version 0
- * has no control header and always reads {@link BITS_VERSION_0}.
- *
- * Control mode 2 (nothing stored) and control mode 3 (literal, no header bits) have no table
- * because they have no header bits to index one with.
- *
- * @type {number[][]}
- */
-const BITS_BY_CONTROL = [
-    [0, 1, 2, 4],
-    [1, 2, 4, 8]
-];
-
-/**
- * @type {number[]}
- */
-const BITS_VERSION_0 = [0, 2, 4, 8];
-
 /**
  * One attribute block's delta bytes, laid out per byte position: position `k`'s deltas are
  * `group_count * 16` bytes at `k * aligned_count`.
@@ -62,14 +20,14 @@ const BITS_VERSION_0 = [0, 2, 4, 8];
  *
  * @type {Uint8Array}
  */
-const delta_scratch = new Uint8Array(MAX_BLOCK_BYTES);
+const delta_scratch = new Uint8Array(MESHOPT_MAX_BLOCK_BYTES);
 
 /**
  * The element every block's first delta is taken against - the tail block's for the first block,
  * and the previous block's last element after that.
  * @type {Uint8Array}
  */
-const baseline = new Uint8Array(MAX_BYTE_STRIDE);
+const baseline = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE);
 
 /**
  * How each aligned group of four byte positions turns its deltas back into values. One byte per
@@ -77,7 +35,7 @@ const baseline = new Uint8Array(MAX_BYTE_STRIDE);
  * mode 0.
  * @type {Uint8Array}
  */
-const channel_modes = new Uint8Array(MAX_BYTE_STRIDE / 4);
+const channel_modes = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE / 4);
 
 /**
  * Decode an attribute stream - the `"ATTRIBUTES"` mode of both meshopt extensions, codec version
@@ -102,7 +60,7 @@ export function meshopt_decode_vertex_buffer(destination, count, byte_stride, so
     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.ok(byte_stride <= MAX_BYTE_STRIDE, `byte_stride(=${byte_stride}) must be at most ${MAX_BYTE_STRIDE}`);
+    assert.ok(byte_stride <= MESHOPT_MAX_BYTE_STRIDE, `byte_stride(=${byte_stride}) must be at most ${MESHOPT_MAX_BYTE_STRIDE}`);
     assert.equal(
         destination.length, count * byte_stride,
         `destination(=${destination.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
@@ -116,7 +74,7 @@ export function meshopt_decode_vertex_buffer(destination, count, byte_stride, so
 
     const header = source[0];
 
-    if ((header & 0xf0) !== HEADER) {
+    if ((header & 0xf0) !== MESHOPT_VERTEX_HEADER) {
         throw new Error(
             `meshopt attribute stream starts with 0x${header.toString(16)}, expected 0xa0 or 0xa1`
         );
@@ -137,7 +95,7 @@ export function meshopt_decode_vertex_buffer(destination, count, byte_stride, so
      EXT's wording invites, and it is wrong for every stride under 32.
     */
     const tail_size = byte_stride + (version === 1 ? channel_count : 0);
-    const tail_min = TAIL_MIN_BY_VERSION[version];
+    const tail_min = MESHOPT_TAIL_MIN_BY_VERSION[version];
     const tail_size_pad = tail_size < tail_min ? tail_min : tail_size;
 
     if (source_end < 1 + tail_size_pad) {
@@ -171,10 +129,7 @@ export function meshopt_decode_vertex_buffer(destination, count, byte_stride, so
         channel_modes.fill(0, 0, channel_count);
     }
 
-    const max_block_elements = Math.min(
-        Math.floor(MAX_BLOCK_BYTES / byte_stride) & ~(MESHOPT_GROUP_SIZE - 1),
-        MAX_BLOCK_ELEMENTS
-    );
+    const max_block_elements = meshopt_max_block_elements(byte_stride);
 
     let offset = 1;
     let element = 0;
@@ -240,7 +195,7 @@ function decode_block(
             offset = meshopt_decode_data_block(
                 delta_scratch, deltas_offset, group_count,
                 source, offset, source_end,
-                BITS_VERSION_0
+                MESHOPT_BITS_VERSION_0
             );
 
             continue;
@@ -264,7 +219,7 @@ function decode_block(
             offset = meshopt_decode_data_block(
                 delta_scratch, deltas_offset, group_count,
                 source, offset, source_end,
-                BITS_BY_CONTROL[control]
+                MESHOPT_BITS_BY_CONTROL[control]
             );
         }
     }

package/src/core/binary/meshopt/meshopt_encode_byte_group.d.ts

@@ -0,0 +1,53 @@
+/**
+ * What one group of sixteen deltas costs at a given width, in bytes.
+ *
+ * The packed codes are fixed-size, so the only thing that varies is how many deltas did not fit and
+ * had to be written out whole after them. A delta *equal* to the sentinel does not fit either — the
+ * decoder would read it as an escape — which is why the comparison is `>=` and not `>`.
+ *
+ * Width 0 stores nothing and can therefore only carry a group that is entirely zero; for any other
+ * group it is not a choice at all, and this says so with an infinite price rather than a flag the
+ * caller has to remember to look at.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} offset sixteen deltas are read from here
+ * @param {number} bits 0, 1, 2, 4 or 8
+ * @returns {number} bytes, or `Number.POSITIVE_INFINITY` if the width cannot carry this group
+ */
+export function meshopt_byte_group_size(deltas: Uint8Array, offset: number, bits: number): number;
+/**
+ * The cheapest width a group can be coded at, out of the four a header value can name.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} offset
+ * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8 — what the control mode decided
+ *   the two stored header bits mean
+ * @returns {{header: number, size: number}} the header value to store, and what it costs
+ */
+export function meshopt_choose_byte_group_bits(deltas: Uint8Array, offset: number, bit_table: number[]): {
+    header: number;
+    size: number;
+};
+/**
+ * Encode one group of sixteen byte deltas at a chosen width — the inverse of
+ * {@link meshopt_decode_byte_group}, and laid out the same way round: the 2-bit and 4-bit packings
+ * run from the most significant bit of each byte down, the 1-bit packing the other way.
+ *
+ * PRECONDITION: `bits` can carry this group, which is what {@link meshopt_choose_byte_group_bits}
+ * returns. Passing a width that cannot produces a stream that decodes to different deltas.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset sixteen deltas are read from here
+ * @param {number} bits 0, 1, 2, 4 or 8
+ * @returns {number} the offset just past the group
+ */
+export function meshopt_encode_byte_group(destination: Uint8Array, destination_offset: number, deltas: Uint8Array, deltas_offset: number, bits: number): number;
+/**
+ * The widths a group can be coded at, cheapest first. {@link meshopt_choose_byte_group_bits} walks
+ * this in order, so a tie is settled in favour of the narrower code.
+ * @type {number[]}
+ */
+export const MESHOPT_GROUP_BITS: number[];
+//# sourceMappingURL=meshopt_encode_byte_group.d.ts.map

package/src/core/binary/meshopt/meshopt_encode_byte_group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_encode_byte_group.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_encode_byte_group.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,gDALW,UAAU,UACV,MAAM,QACN,MAAM,GACJ,MAAM,CA8BlB;AAED;;;;;;;;GAQG;AACH,uDANW,UAAU,UACV,MAAM,aACN,MAAM,EAAE,GAEN;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAmB1C;AAED;;;;;;;;;;;;;;GAcG;AACH,uDAPW,UAAU,sBACV,MAAM,UACN,UAAU,iBACV,MAAM,QACN,MAAM,GACJ,MAAM,CA0ClB;AAxID;;;;GAIG;AACH,iCAFU,MAAM,EAAE,CAEgC"}

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

@@ -0,0 +1,140 @@
+import { assert } from "../../assert.js";
+import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+
+/**
+ * The widths a group can be coded at, cheapest first. {@link meshopt_choose_byte_group_bits} walks
+ * this in order, so a tie is settled in favour of the narrower code.
+ * @type {number[]}
+ */
+export const MESHOPT_GROUP_BITS = [0, 1, 2, 4, 8];
+
+/**
+ * What one group of sixteen deltas costs at a given width, in bytes.
+ *
+ * The packed codes are fixed-size, so the only thing that varies is how many deltas did not fit and
+ * had to be written out whole after them. A delta *equal* to the sentinel does not fit either — the
+ * decoder would read it as an escape — which is why the comparison is `>=` and not `>`.
+ *
+ * Width 0 stores nothing and can therefore only carry a group that is entirely zero; for any other
+ * group it is not a choice at all, and this says so with an infinite price rather than a flag the
+ * caller has to remember to look at.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} offset sixteen deltas are read from here
+ * @param {number} bits 0, 1, 2, 4 or 8
+ * @returns {number} bytes, or `Number.POSITIVE_INFINITY` if the width cannot carry this group
+ */
+export function meshopt_byte_group_size(deltas, offset, bits) {
+    assert.isOneOf(bits, MESHOPT_GROUP_BITS, 'bits');
+
+    if (bits === 8) {
+        return MESHOPT_GROUP_SIZE;
+    }
+
+    if (bits === 0) {
+        for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+            if (deltas[offset + i] !== 0) {
+                return Number.POSITIVE_INFINITY;
+            }
+        }
+
+        return 0;
+    }
+
+    const sentinel = (1 << bits) - 1;
+
+    let escapes = 0;
+
+    for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+        if (deltas[offset + i] >= sentinel) {
+            escapes++;
+        }
+    }
+
+    return MESHOPT_GROUP_SIZE / (8 / bits) + escapes;
+}
+
+/**
+ * The cheapest width a group can be coded at, out of the four a header value can name.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} offset
+ * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8 — what the control mode decided
+ *   the two stored header bits mean
+ * @returns {{header: number, size: number}} the header value to store, and what it costs
+ */
+export function meshopt_choose_byte_group_bits(deltas, offset, bit_table) {
+    let best_header = 0;
+    let best_size = Number.POSITIVE_INFINITY;
+
+    for (let header = 0; header < 4; header++) {
+        const size = meshopt_byte_group_size(deltas, offset, bit_table[header]);
+
+        if (size < best_size) {
+            best_header = header;
+            best_size = size;
+        }
+    }
+
+    // 8 is in every table that has no 0, and 0 is in every table that has no 8, so one of them fits
+    assert.ok(Number.isFinite(best_size), `no width in [${bit_table}] can carry the group at ${offset}`);
+
+    return { header: best_header, size: best_size };
+}
+
+/**
+ * Encode one group of sixteen byte deltas at a chosen width — the inverse of
+ * {@link meshopt_decode_byte_group}, and laid out the same way round: the 2-bit and 4-bit packings
+ * run from the most significant bit of each byte down, the 1-bit packing the other way.
+ *
+ * PRECONDITION: `bits` can carry this group, which is what {@link meshopt_choose_byte_group_bits}
+ * returns. Passing a width that cannot produces a stream that decodes to different deltas.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset sixteen deltas are read from here
+ * @param {number} bits 0, 1, 2, 4 or 8
+ * @returns {number} the offset just past the group
+ */
+export function meshopt_encode_byte_group(destination, destination_offset, deltas, deltas_offset, bits) {
+    assert.isOneOf(bits, MESHOPT_GROUP_BITS, 'bits');
+
+    if (bits === 0) {
+        return destination_offset;
+    }
+
+    if (bits === 8) {
+        for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+            destination[destination_offset + i] = deltas[deltas_offset + i];
+        }
+
+        return destination_offset + MESHOPT_GROUP_SIZE;
+    }
+
+    const per_byte = 8 / bits;
+    const packed_bytes = MESHOPT_GROUP_SIZE / per_byte;
+    const sentinel = (1 << bits) - 1;
+
+    const ascending = bits === 1;
+
+    destination.fill(0, destination_offset, destination_offset + packed_bytes);
+
+    let sentinel_offset = destination_offset + packed_bytes;
+
+    for (let i = 0; i < MESHOPT_GROUP_SIZE; i++) {
+        const delta = deltas[deltas_offset + i];
+        const code = delta < sentinel ? delta : sentinel;
+
+        const lane = i % per_byte;
+        const shift = ascending ? (lane * bits) : (8 - bits - lane * bits);
+
+        destination[destination_offset + ((i / per_byte) | 0)] |= code << shift;
+
+        if (code === sentinel) {
+            destination[sentinel_offset++] = delta;
+        }
+    }
+
+    return sentinel_offset;
+}

package/src/core/binary/meshopt/meshopt_encode_data_block.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Price one "data block" — the delta bytes for a single byte position of the element, across one
+ * attribute block's worth of groups — and record the header value each group wants.
+ *
+ * Every group is priced on its own, because the header spends two bits per group either way: a
+ * block of mostly-zero groups with one noisy one pays for the noisy one alone.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset
+ * @param {number} group_count
+ * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8
+ * @param {Uint8Array} choices `group_count` header values are written here
+ * @param {number} choices_offset
+ * @returns {number} what the block costs in bytes, header included
+ */
+export function meshopt_choose_data_block(deltas: Uint8Array, deltas_offset: number, group_count: number, bit_table: number[], choices: Uint8Array, choices_offset: number): number;
+/**
+ * Write a data block: `ceil(group_count / 4)` header bytes, two bits per group packed least
+ * significant first, then the groups. The inverse of {@link meshopt_decode_data_block}.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset
+ * @param {number} group_count
+ * @param {number[]} bit_table
+ * @param {Uint8Array} choices the header values {@link meshopt_choose_data_block} settled on
+ * @param {number} choices_offset
+ * @returns {number} the offset just past the data block
+ */
+export function meshopt_encode_data_block(destination: Uint8Array, destination_offset: number, deltas: Uint8Array, deltas_offset: number, group_count: number, bit_table: number[], choices: Uint8Array, choices_offset: number): number;
+//# sourceMappingURL=meshopt_encode_data_block.d.ts.map

package/src/core/binary/meshopt/meshopt_encode_data_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_encode_data_block.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_encode_data_block.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,kDARW,UAAU,iBACV,MAAM,eACN,MAAM,aACN,MAAM,EAAE,WACR,UAAU,kBACV,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;;;;;GAaG;AACH,uDAVW,UAAU,sBACV,MAAM,UACN,UAAU,iBACV,MAAM,eACN,MAAM,aACN,MAAM,EAAE,WACR,UAAU,kBACV,MAAM,GACJ,MAAM,CA4BlB"}

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

@@ -0,0 +1,77 @@
+import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+import { meshopt_choose_byte_group_bits, meshopt_encode_byte_group } from "./meshopt_encode_byte_group.js";
+
+/**
+ * Price one "data block" — the delta bytes for a single byte position of the element, across one
+ * attribute block's worth of groups — and record the header value each group wants.
+ *
+ * Every group is priced on its own, because the header spends two bits per group either way: a
+ * block of mostly-zero groups with one noisy one pays for the noisy one alone.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset
+ * @param {number} group_count
+ * @param {number[]} bit_table four entries, each 0, 1, 2, 4 or 8
+ * @param {Uint8Array} choices `group_count` header values are written here
+ * @param {number} choices_offset
+ * @returns {number} what the block costs in bytes, header included
+ */
+export function meshopt_choose_data_block(
+    deltas, deltas_offset,
+    group_count,
+    bit_table,
+    choices, choices_offset
+) {
+    let size = (group_count + 3) >> 2;
+
+    for (let g = 0; g < group_count; g++) {
+        const choice = meshopt_choose_byte_group_bits(deltas, deltas_offset + g * MESHOPT_GROUP_SIZE, bit_table);
+
+        choices[choices_offset + g] = choice.header;
+        size += choice.size;
+    }
+
+    return size;
+}
+
+/**
+ * Write a data block: `ceil(group_count / 4)` header bytes, two bits per group packed least
+ * significant first, then the groups. The inverse of {@link meshopt_decode_data_block}.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset
+ * @param {number} group_count
+ * @param {number[]} bit_table
+ * @param {Uint8Array} choices the header values {@link meshopt_choose_data_block} settled on
+ * @param {number} choices_offset
+ * @returns {number} the offset just past the data block
+ */
+export function meshopt_encode_data_block(
+    destination, destination_offset,
+    deltas, deltas_offset,
+    group_count,
+    bit_table,
+    choices, choices_offset
+) {
+    const header_bytes = (group_count + 3) >> 2;
+
+    destination.fill(0, destination_offset, destination_offset + header_bytes);
+
+    let offset = destination_offset + header_bytes;
+
+    for (let g = 0; g < group_count; g++) {
+        const header = choices[choices_offset + g];
+
+        destination[destination_offset + (g >> 2)] |= header << ((g & 3) * 2);
+
+        offset = meshopt_encode_byte_group(
+            destination, offset,
+            deltas, deltas_offset + g * MESHOPT_GROUP_SIZE,
+            bit_table[header]
+        );
+    }
+
+    return offset;
+}

package/src/core/binary/meshopt/meshopt_encode_index_sequence.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Encode an index stream of no particular topology — the `"INDICES"` mode of both meshopt
+ * extensions, and the inverse of {@link meshopt_decode_index_sequence}.
+ *
+ * Each index is a zigzag delta against one of *two* running baselines, and which one is the low bit
+ * of the stored value. Two rather than one is what lets two independently monotonic runs be spliced
+ * together and still pay one small delta per index — a triangle strip's own indices against one, a
+ * degenerate seam against the other — so the choice is where the compression is, and it is made per
+ * index by pricing both:
+ *
+ * - the baseline whose delta encodes in fewer bytes wins;
+ * - a tie goes to the smaller delta, which leaves both baselines nearer the runs they are tracking;
+ * - a tie in that too goes to baseline 0, which keeps baseline 1 free for a run that has not
+ *   started yet.
+ *
+ * Greedy, and deliberately so: a baseline that is cheap now is cheap because it is near, and near is
+ * what makes it cheap again next time.
+ *
+ * A baseline both of whose deltas are further away than {@link MESHOPT_INDEX_SEQUENCE_MAX_DELTA} is
+ * not a choice at all, and an index that is out of reach of both is refused.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ *
+ * @param {ArrayLike<number>} indices unsigned 32-bit
+ * @param {Object} [options]
+ * @param {number} [options.version] 0 or 1, defaulting to 1 — the two are the same bitstream, and
+ *   the nibble is there for a codec change that has not happened
+ * @returns {Uint8Array} the whole compressed stream, reserved tail included
+ * @throws {Error} on an index further than {@link MESHOPT_INDEX_SEQUENCE_MAX_DELTA} from both
+ *   baselines, which the format has no way to write down
+ */
+export function meshopt_encode_index_sequence(indices: ArrayLike<number>, options?: {
+    version?: number;
+}): Uint8Array;
+/**
+ * How far one index may sit from the baseline it is coded against.
+ *
+ * The stored value spends its low bit on which baseline, leaving thirty-one for the zigzag, whose
+ * own low bit is the sign — so the delta has thirty bits and a sign, and half of the 32-bit index
+ * range is out of reach of any one step. Nothing that indexes a real vertex buffer comes near it,
+ * but a stream that crossed it would decode to different indices rather than fail, so it is checked.
+ *
+ * @type {number}
+ */
+export const MESHOPT_INDEX_SEQUENCE_MAX_DELTA: number;
+//# sourceMappingURL=meshopt_encode_index_sequence.d.ts.map

package/src/core/binary/meshopt/meshopt_encode_index_sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshopt_encode_index_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/meshopt_encode_index_sequence.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uDARW,UAAU,MAAM,CAAC;IAEA,OAAO,GAAxB,MAAM;IAEJ,UAAU,CA2DtB;AAlGD;;;;;;;;;GASG;AACH,+CAFU,MAAM,CAEwC"}