@woosh/meep-engine 3.17.1 → 3.18.0

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

@@ -1,237 +0,0 @@
-/**
- * Minimal meshopt attribute encoders, for tests only - nothing in production imports this.
- *
- * They emit the simplest stream the format admits (every group stored raw), which is legal and
- * compresses nothing. Their job is to exercise the decoder's block, group and channel loops over
- * shapes too large to author by hand, and to give the glTF fixtures something compressed to load.
- *
- * They are deliberately NOT the oracle for the format itself: they were written from the same
- * reading of the specification as the decoder, so a shared misreading would pass. The specification's
- * own worked example, and the hand-derived vectors beside it, are what prove the bitstream.
- */
-
-/**
- * @param {number} previous
- * @param {number} current
- * @returns {number} the spec's `encode`, in 8-bit space
- */
-function zigzag_8(previous, current) {
-    const delta = (current - previous) & 0xff;
-
-    return ((delta & 0x80) !== 0) ? (~(delta << 1)) & 0xff : (delta << 1) & 0xff;
-}
-
-/**
- * @param {number} previous
- * @param {number} current
- * @returns {number} the spec's `encode`, in 16-bit space
- */
-function zigzag_16(previous, current) {
-    const delta = (current - previous) & 0xffff;
-
-    return ((delta & 0x8000) !== 0) ? (~(delta << 1)) & 0xffff : (delta << 1) & 0xffff;
-}
-
-/**
- * @param {number} value
- * @param {number} amount
- * @returns {number}
- */
-function rotate_left_32(value, amount) {
-    return (((value << amount) | (value >>> (32 - amount))) >>> 0);
-}
-
-/**
- * @param {number} byte_stride
- * @returns {number}
- */
-function max_block_elements(byte_stride) {
-    return Math.min(Math.floor(8192 / byte_stride) & ~15, 256);
-}
-
-/**
- * Every group of every data block stored raw, which is header bits `3` under version 0's table and
- * under version 1's control mode 1.
- *
- * @param {number} group_count
- * @param {number} header_value
- * @returns {number[]}
- */
-function build_group_header(group_count, header_value) {
-    const header = new Array((group_count + 3) >> 2).fill(0);
-
-    for (let g = 0; g < group_count; g++) {
-        header[g >> 2] |= header_value << ((g & 3) * 2);
-    }
-
-    return header;
-}
-
-/**
- * Read one channel's value for element `i` out of an element array, at the width its mode implies.
- *
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {number} width bytes
- * @returns {number}
- */
-function read_le(data, offset, width) {
-    let value = 0;
-
-    for (let b = 0; b < width; b++) {
-        value |= data[offset + b] << (b * 8);
-    }
-
-    return value >>> 0;
-}
-
-/**
- * Build an attribute ("mode 0") stream.
- *
- * @param {Uint8Array} data `count * byte_stride` bytes
- * @param {number} count
- * @param {number} byte_stride
- * @param {Object} [options]
- * @param {number} [options.version] 0 or 1
- * @param {number[]} [options.channel_modes] one mode byte per aligned four byte positions;
- *   version 1 only, defaults to all zero (byte deltas)
- * @returns {Uint8Array}
- */
-export function encode_meshopt_attributes(data, count, byte_stride, options = {}) {
-    const version = options.version ?? 0;
-    const channel_count = byte_stride >> 2;
-    const channel_modes = options.channel_modes ?? new Array(channel_count).fill(0);
-
-    const out = [0xa0 | version];
-
-    const baseline = Array.from(data.subarray(0, byte_stride));
-
-    let previous = baseline.slice();
-    let element = 0;
-
-    while (element < count) {
-        const block_elements = Math.min(count - element, max_block_elements(byte_stride));
-        const group_count = Math.ceil(block_elements / 16);
-        const aligned_count = group_count * 16;
-
-        // every byte position gets control mode 1, whose header value 3 is sixteen raw bytes
-        if (version === 1) {
-            const control = new Array(channel_count).fill(0);
-
-            for (let k = 0; k < byte_stride; k++) {
-                control[k >> 2] |= 1 << ((k & 3) * 2);
-            }
-
-            out.push(...control);
-        }
-
-        /**
-         * The block's delta bytes, per byte position, exactly as the decoder will recover them.
-         * @type {number[][]}
-         */
-        const deltas = [];
-
-        for (let k = 0; k < byte_stride; k++) {
-            deltas.push(new Array(aligned_count).fill(0));
-        }
-
-        for (let c = 0; c < channel_count; c++) {
-            const mode_byte = version === 1 ? channel_modes[c] : 0;
-            const mode = mode_byte & 0x0f;
-            const rotation = mode_byte >> 4;
-            const k0 = c * 4;
-
-            const width = mode === 0 ? 1 : (mode === 1 ? 2 : 4);
-
-            for (let lane = 0; lane < 4 / width; lane++) {
-                const k = k0 + lane * width;
-
-                let carried = read_le(previous, k, width);
-
-                for (let i = 0; i < block_elements; i++) {
-                    const value = read_le(data, (element + i) * byte_stride + k, width);
-
-                    let code;
-
-                    if (mode === 0) {
-                        code = zigzag_8(carried, value);
-                    } else if (mode === 1) {
-                        code = zigzag_16(carried, value);
-                    } else {
-                        code = rotate_left_32((value ^ carried) >>> 0, (32 - rotation) & 31);
-                    }
-
-                    for (let b = 0; b < width; b++) {
-                        deltas[k + b][i] = (code >>> (b * 8)) & 0xff;
-                    }
-
-                    carried = value;
-                }
-            }
-        }
-
-        const header_value = 3;
-
-        for (let k = 0; k < byte_stride; k++) {
-            out.push(...build_group_header(group_count, header_value));
-            out.push(...deltas[k]);
-        }
-
-        previous = Array.from(
-            data.subarray((element + block_elements - 1) * byte_stride, (element + block_elements) * byte_stride)
-        );
-
-        element += block_elements;
-    }
-
-    const tail_size = byte_stride + (version === 1 ? channel_count : 0);
-    const tail_min = version === 1 ? 24 : 32;
-    const tail_size_pad = Math.max(tail_size, tail_min);
-
-    // the padding goes IN FRONT of the tail block, which sits flush against the end of the stream
-    for (let i = 0; i < tail_size_pad - tail_size; i++) {
-        out.push(0);
-    }
-
-    out.push(...baseline);
-
-    if (version === 1) {
-        out.push(...channel_modes);
-    }
-
-    return new Uint8Array(out);
-}
-
-/**
- * Build an index-sequence ("mode 2") stream. Every delta is taken against baseline 0.
- *
- * @param {number[]} indices
- * @returns {Uint8Array}
- */
-export function encode_meshopt_index_sequence(indices) {
-    const out = [0xd1];
-
-    let last = 0;
-
-    for (const index of indices) {
-        const delta = index - last;
-        const zigzag = (delta << 1) ^ (delta >> 31);
-
-        // baseline bit 0, then the zigzag delta
-        let value = ((zigzag << 1) >>> 0);
-
-        do {
-            const lower = value & 0x7f;
-
-            value = value >>> 7;
-
-            out.push(value > 0 ? (lower | 0x80) : lower);
-        } while (value > 0);
-
-        last = index;
-    }
-
-    out.push(0, 0, 0, 0);
-
-    return new Uint8Array(out);
-}

package/src/core/geom/3d/atlas/atlas_test_fixtures.d.ts

@@ -1,84 +0,0 @@
-/**
- * Shared inline mesh fixtures for the atlas test suites. Each builder returns a
- * fresh {@link BinaryTopology} with face normals computed. Test-only — not
- * imported by production code.
- */
-/**
- * @param {number[]} indices
- * @param {number[]} positions flat xyz
- * @returns {BinaryTopology}
- */
-export function atlas_make_mesh(indices: number[], positions: number[]): BinaryTopology;
-/**
- * Unit square in the z=0 plane, two triangles sharing the 0-2 diagonal.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_unit_quad(): BinaryTopology;
-/**
- * Two triangles sharing edge (0,1), folded to a 90 degree dihedral.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_folded_pair(): BinaryTopology;
-/**
- * The unit quad, but the two triangles use SEPARATE vertex indices at the
- * shared diagonal (coincident positions, distinct ids). Before welding the two
- * triangles are two islands; after welding they share the diagonal edge.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_split_quad(): BinaryTopology;
-/**
- * An open ribbon of `segments` quads bent around an arc of `total_angle`
- * radians, so face normals fan out radially. Drives curvature-based chart
- * splitting. Connected, single island, boundary on all four sides.
- *
- * @param {number} segments
- * @param {number} total_angle radians swept across the ribbon
- * @returns {BinaryTopology}
- */
-export function atlas_build_curved_ribbon(segments: number, total_angle: number): BinaryTopology;
-/**
- * Flat n×n grid of quads in the z=0 plane (2·n·n coplanar triangles). All faces
- * share one normal, so they collapse to a single planar region — the canonical
- * region-atomic case.
- *
- * @param {number} n cells per side
- * @returns {BinaryTopology}
- */
-export function atlas_build_grid_plane(n: number): BinaryTopology;
-/**
- * A good quad plus three deliberately degenerate triangles (each its own
- * island): a collinear zero-area triangle, a coincident-vertex "needle" (two
- * vertices at the same position), and a near-collinear sliver. Real exported /
- * scanned meshes contain these; the pipeline must stay finite and not crash.
- * Use with `weld: false` so the needle's coincident vertices stay distinct.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_degenerate_mix(): BinaryTopology;
-/**
- * Unit UV sphere with `rings` latitude bands and `sectors` longitude segments,
- * shared vertices (pole fans + modulo longitude wrap), consistent winding. A
- * smooth closed surface for testing curvature-driven segmentation.
- *
- * @param {number} rings latitude bands (>= 2)
- * @param {number} sectors longitude segments (>= 3)
- * @returns {BinaryTopology}
- */
-export function atlas_build_uv_sphere(rings: number, sectors: number): BinaryTopology;
-/**
- * Regular octahedron: a closed surface of 8 triangles, outward winding.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_octahedron(): BinaryTopology;
-/**
- * Axis-aligned unit cube, 12 triangles, consistent outward winding.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_unit_cube(): BinaryTopology;
-import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
-//# sourceMappingURL=atlas_test_fixtures.d.ts.map

package/src/core/geom/3d/atlas/atlas_test_fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atlas_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/atlas/atlas_test_fixtures.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;;GAIG;AACH,yCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,cAAc,CAO1B;AAED;;;;GAIG;AACH,yCAFa,cAAc,CAY1B;AAED;;;;GAIG;AACH,2CAFa,cAAc,CAY1B;AAED;;;;;;GAMG;AACH,0CAFa,cAAc,CAc1B;AAED;;;;;;;;GAQG;AACH,oDAJW,MAAM,eACN,MAAM,GACJ,cAAc,CAsB1B;AAED;;;;;;;GAOG;AACH,0CAHW,MAAM,GACJ,cAAc,CAuB1B;AAED;;;;;;;;GAQG;AACH,8CAFa,cAAc,CA0B1B;AAED;;;;;;;;GAQG;AACH,6CAJW,MAAM,WACN,MAAM,GACJ,cAAc,CAkC1B;AAED;;;;GAIG;AACH,0CAFa,cAAc,CAiB1B;AAED;;;;GAIG;AACH,yCAFa,cAAc,CAuB1B;+BAzQ8B,6CAA6C"}

package/src/core/geom/3d/atlas/atlas_test_fixtures.js

@@ -1,266 +0,0 @@
-import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
-import { bt_mesh_compute_face_normals } from "../topology/struct/binary/io/bt_mesh_compute_face_normals.js";
-import { bt_mesh_from_indexed_geometry } from "../topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
-
-/**
- * Shared inline mesh fixtures for the atlas test suites. Each builder returns a
- * fresh {@link BinaryTopology} with face normals computed. Test-only — not
- * imported by production code.
- */
-
-/**
- * @param {number[]} indices
- * @param {number[]} positions flat xyz
- * @returns {BinaryTopology}
- */
-export function atlas_make_mesh(indices, positions) {
-    const mesh = new BinaryTopology();
-    bt_mesh_from_indexed_geometry(mesh, indices, positions);
-    bt_mesh_compute_face_normals(mesh);
-    return mesh;
-}
-
-/**
- * Unit square in the z=0 plane, two triangles sharing the 0-2 diagonal.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_unit_quad() {
-    return atlas_make_mesh(
-        [0, 1, 2, 0, 2, 3],
-        [
-            0, 0, 0,
-            1, 0, 0,
-            1, 1, 0,
-            0, 1, 0,
-        ]
-    );
-}
-
-/**
- * Two triangles sharing edge (0,1), folded to a 90 degree dihedral.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_folded_pair() {
-    return atlas_make_mesh(
-        [0, 1, 2, 0, 3, 1],
-        [
-            0, 0, 0,
-            1, 0, 0,
-            0, 1, 0,
-            0, 0, 1,
-        ]
-    );
-}
-
-/**
- * The unit quad, but the two triangles use SEPARATE vertex indices at the
- * shared diagonal (coincident positions, distinct ids). Before welding the two
- * triangles are two islands; after welding they share the diagonal edge.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_split_quad() {
-    return atlas_make_mesh(
-        [0, 1, 2, 3, 4, 5],
-        [
-            0, 0, 0,
-            1, 0, 0,
-            1, 1, 0,
-            0, 0, 0,  // duplicate of vertex 0
-            1, 1, 0,  // duplicate of vertex 2
-            0, 1, 0,
-        ]
-    );
-}
-
-/**
- * An open ribbon of `segments` quads bent around an arc of `total_angle`
- * radians, so face normals fan out radially. Drives curvature-based chart
- * splitting. Connected, single island, boundary on all four sides.
- *
- * @param {number} segments
- * @param {number} total_angle radians swept across the ribbon
- * @returns {BinaryTopology}
- */
-export function atlas_build_curved_ribbon(segments, total_angle) {
-    const positions = [];
-    const N = segments;
-    // bottom ring at z=0 (indices 0..N), top ring at z=1 (indices N+1..2N+1)
-    for (let j = 0; j <= N; j++) {
-        const a = (j / N) * total_angle;
-        positions.push(Math.cos(a), Math.sin(a), 0);
-    }
-    for (let j = 0; j <= N; j++) {
-        const a = (j / N) * total_angle;
-        positions.push(Math.cos(a), Math.sin(a), 1);
-    }
-
-    const top = N + 1;
-    const indices = [];
-    for (let j = 0; j < N; j++) {
-        indices.push(j, j + 1, top + j + 1);
-        indices.push(j, top + j + 1, top + j);
-    }
-    return atlas_make_mesh(indices, positions);
-}
-
-/**
- * Flat n×n grid of quads in the z=0 plane (2·n·n coplanar triangles). All faces
- * share one normal, so they collapse to a single planar region — the canonical
- * region-atomic case.
- *
- * @param {number} n cells per side
- * @returns {BinaryTopology}
- */
-export function atlas_build_grid_plane(n) {
-    const positions = [];
-    for (let j = 0; j <= n; j++) {
-        for (let i = 0; i <= n; i++) {
-            positions.push(i / n, j / n, 0);
-        }
-    }
-    /**
-     * @param {number} i column index
-     * @param {number} j row index
-     * @returns {number} flat vertex id in the (n+1)×(n+1) grid
-     */
-    const idx = (i, j) => j * (n + 1) + i;
-    const indices = [];
-    for (let j = 0; j < n; j++) {
-        for (let i = 0; i < n; i++) {
-            const a = idx(i, j), b = idx(i + 1, j), c = idx(i + 1, j + 1), d = idx(i, j + 1);
-            indices.push(a, b, c, a, c, d);
-        }
-    }
-    return atlas_make_mesh(indices, positions);
-}
-
-/**
- * A good quad plus three deliberately degenerate triangles (each its own
- * island): a collinear zero-area triangle, a coincident-vertex "needle" (two
- * vertices at the same position), and a near-collinear sliver. Real exported /
- * scanned meshes contain these; the pipeline must stay finite and not crash.
- * Use with `weld: false` so the needle's coincident vertices stay distinct.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_degenerate_mix() {
-    return atlas_make_mesh(
-        [
-            0, 1, 2, 0, 2, 3,   // good unit quad
-            4, 5, 6,            // collinear -> exactly zero area
-            7, 8, 9,            // needle: vertices 7 and 8 coincide -> zero area
-            10, 11, 12,         // near-collinear -> tiny-area sliver
-        ],
-        [
-            0, 0, 0,            // 0
-            1, 0, 0,            // 1
-            1, 1, 0,            // 2
-            0, 1, 0,            // 3
-            2, 0, 0,            // 4
-            3, 0, 0,            // 5  (4,5,6 collinear on y=0)
-            4, 0, 0,            // 6
-            2, 2, 0,            // 7
-            2, 2, 0,            // 8  coincident with 7
-            3, 2, 0,            // 9
-            2, 3, 0,            // 10
-            4, 3, 0,            // 11
-            3, 3.0001, 0,       // 12 just off the 10-11 line -> sliver
-        ]
-    );
-}
-
-/**
- * Unit UV sphere with `rings` latitude bands and `sectors` longitude segments,
- * shared vertices (pole fans + modulo longitude wrap), consistent winding. A
- * smooth closed surface for testing curvature-driven segmentation.
- *
- * @param {number} rings latitude bands (>= 2)
- * @param {number} sectors longitude segments (>= 3)
- * @returns {BinaryTopology}
- */
-export function atlas_build_uv_sphere(rings, sectors) {
-    const positions = [];
-    positions.push(0, 1, 0);  // 0: north pole (latitude band 0)
-    positions.push(0, -1, 0); // 1: south pole (latitude band `rings`)
-    for (let i = 1; i < rings; i++) {
-        const phi = (i / rings) * Math.PI;
-        const y = Math.cos(phi);
-        const r = Math.sin(phi);
-        for (let s = 0; s < sectors; s++) {
-            const theta = (s / sectors) * 2 * Math.PI;
-            positions.push(r * Math.cos(theta), y, r * Math.sin(theta));
-        }
-    }
-
-    const vid = (i, s) => {
-        if (i === 0) return 0;
-        if (i === rings) return 1;
-        return 2 + (i - 1) * sectors + (s % sectors);
-    };
-
-    const indices = [];
-    const tri = (a, b, c) => {
-        if (a !== b && b !== c && a !== c) indices.push(a, b, c);
-    };
-    for (let i = 0; i < rings; i++) {
-        for (let s = 0; s < sectors; s++) {
-            const v00 = vid(i, s), v01 = vid(i, s + 1), v10 = vid(i + 1, s), v11 = vid(i + 1, s + 1);
-            tri(v00, v10, v11);
-            tri(v00, v11, v01);
-        }
-    }
-    return atlas_make_mesh(indices, positions);
-}
-
-/**
- * Regular octahedron: a closed surface of 8 triangles, outward winding.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_octahedron() {
-    return atlas_make_mesh(
-        [
-            4, 0, 2, 4, 2, 1, 4, 1, 3, 4, 3, 0, // top (+z apex)
-            5, 2, 0, 5, 1, 2, 5, 3, 1, 5, 0, 3, // bottom (-z apex)
-        ],
-        [
-            1, 0, 0,
-            -1, 0, 0,
-            0, 1, 0,
-            0, -1, 0,
-            0, 0, 1,
-            0, 0, -1,
-        ]
-    );
-}
-
-/**
- * Axis-aligned unit cube, 12 triangles, consistent outward winding.
- *
- * @returns {BinaryTopology}
- */
-export function atlas_build_unit_cube() {
-    return atlas_make_mesh(
-        [
-            0, 1, 5, 0, 5, 4, // front  (-y)
-            1, 2, 6, 1, 6, 5, // right  (+x)
-            2, 3, 7, 2, 7, 6, // back   (+y)
-            3, 0, 4, 3, 4, 7, // left   (-x)
-            3, 2, 1, 3, 1, 0, // bottom (-z)
-            4, 5, 6, 4, 6, 7, // top    (+z)
-        ],
-        [
-            0, 0, 0,
-            1, 0, 0,
-            1, 1, 0,
-            0, 1, 0,
-            0, 0, 1,
-            1, 0, 1,
-            1, 1, 1,
-            0, 1, 1,
-        ]
-    );
-}

package/src/engine/asset/loaders/gltf_test_fixtures.d.ts

@@ -1,97 +0,0 @@
-/**
- * @returns {ArrayBuffer}
- */
-export function build_triangle_bin(): ArrayBuffer;
-/**
- * @param {string|undefined} buffer_uri `undefined` for a .glb, whose buffer is the binary chunk
- * @returns {object}
- */
-export function build_triangle_gltf_json(buffer_uri: string | undefined): object;
-/**
- * The same model with a base-colour texture on it, so that a test can watch what an image costs.
- *
- * The texture names its image the way the game's own models do — a `source` index into `images`,
- * whose entry carries a relative `uri` — because that is the shape {@link gltf_used_image_indices}
- * decides against a DDS sibling with, and the one whose bytes have to come from somewhere.
- *
- * @param {string} buffer_uri
- * @param {string} image_uri
- * @returns {object}
- */
-export function build_textured_triangle_gltf_json(buffer_uri: string, image_uri: string): object;
-/**
- * The same model as a .glb — the JSON chunk followed by the binary one.
- *
- * @returns {ArrayBuffer}
- */
-export function build_triangle_glb(): ArrayBuffer;
-/**
- * The compressed streams, laid out back to back.
- *
- * Positions, normals and texture coordinates go through the attribute codec; the indices are a
- * hand-written triangle stream, because writing a triangle encoder to test a triangle decoder with
- * would prove nothing. `0xf0` reads entry 0 of the lookup table, which is `0x00` - three fresh
- * vertices, which is exactly (0, 1, 2).
- *
- * At `codec_version` 1 the attribute streams carry a channel mode each - a rotated exclusive-or for
- * the positions, plain byte deltas for the normals, 16-bit deltas for the texture coordinates - and
- * with `colour` there is a `COLOR`-filtered stream too. Either makes a file that only
- * `KHR_meshopt_compression` defines, and that the vendor extension refuses.
- *
- * @param {Object} [options]
- * @param {number} [options.codec_version] 0 or 1
- * @param {boolean} [options.colour] append a `COLOR_0` stream carrying the `COLOR` filter
- * @returns {{buffer: ArrayBuffer, ranges: {byteOffset:number, byteLength:number}[]}}
- */
-export function build_meshopt_triangle_bin({ codec_version, colour }?: {
-    codec_version?: number;
-    colour?: boolean;
-}): {
-    buffer: ArrayBuffer;
-    ranges: {
-        byteOffset: number;
-        byteLength: number;
-    }[];
-};
-/**
- * @param {string} extension_name `EXT_meshopt_compression` or `KHR_meshopt_compression`
- * @param {string|undefined} buffer_uri `undefined` for a .glb, whose compressed data is the binary chunk
- * @param {Object} [options] see {@link build_meshopt_triangle_bin}
- * @param {number} [options.codec_version]
- * @param {boolean} [options.colour]
- * @returns {object}
- */
-export function build_meshopt_triangle_gltf_json(extension_name: string, buffer_uri: string | undefined, options?: {
-    codec_version?: number;
-    colour?: boolean;
-}): object;
-/**
- * The compressed model as a .glb: the JSON chunk, then the compressed data as the binary one.
- *
- * @param {string} extension_name
- * @param {Object} [options] see {@link build_meshopt_triangle_bin}
- * @returns {ArrayBuffer}
- */
-export function build_meshopt_triangle_glb(extension_name: string, options?: any): ArrayBuffer;
-export const GLTF_FIXTURE_NODE_NAME: "unit_root";
-export const GLTF_FIXTURE_MESH_NAME: "unit_body";
-/**
- * Byte length of what {@link build_triangle_bin} produces — three positions, three normals, three
- * texture coordinates and three indices, laid out back to back.
- * @type {number}
- */
-export const GLTF_FIXTURE_BIN_BYTE_LENGTH: number;
-/**
- * Byte length of the placeholder the compressed views point at. It has to be big enough to hold
- * every uncompressed view referencing it, which is the same 102 bytes {@link build_triangle_bin}
- * lays out.
- * @type {number}
- */
-export const GLTF_FIXTURE_FALLBACK_BYTE_LENGTH: number;
-/**
- * What those decode to: R = Y + Co - Cg, G = Y + Cg, B = Y - Co - Cg, with alpha widened by the bit
- * its marker cost it.
- * @type {number[]}
- */
-export const GLTF_FIXTURE_COLOURS: number[];
-//# sourceMappingURL=gltf_test_fixtures.d.ts.map

package/src/engine/asset/loaders/gltf_test_fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/gltf_test_fixtures.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,sCAFa,WAAW,CAWvB;AAED;;;GAGG;AACH,qDAHW,MAAM,GAAC,SAAS,GACd,MAAM,CA+BlB;AAED;;;;;;;;;;GAUG;AACH,8DAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;GAIG;AACH,sCAFa,WAAW,CAiCvB;AAsCD;;;;;;;;;;;;;;;;;GAiBG;AACH;IAJ4B,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;;YACI,WAAW;;oBAAsB,MAAM;oBAAa,MAAM;;EA2C/E;AAED;;;;;;;GAOG;AACH,iEAPW,MAAM,cACN,MAAM,GAAC,SAAS;IAEC,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;IACL,MAAM,CA8ElB;AAED;;;;;;GAMG;AACH,2DAJW,MAAM,kBAEJ,WAAW,CAkCvB;AA3VD,iDAAkD;AAClD,iDAAkD;AAElD;;;;GAIG;AACH,2CAFU,MAAM,CAEgC;AA2HhD;;;;;GAKG;AACH,gDAFU,MAAM,CAE8D;AAa9E;;;;GAIG;AACH,mCAFU,MAAM,EAAE,CAMhB"}