@woosh/meep-engine 3.17.1 → 3.18.0

package/src/engine/asset/loaders/gltf_test_fixtures.js

@@ -1,359 +0,0 @@
-/**
- * Shared inline glTF fixtures for the loader test suites — one triangle, in both of the containers
- * the format ships in. Test-only; not imported by production code.
- *
- * The point of authoring the bytes here rather than checking a model in is that every field a loader
- * reads is visible in one place: change the accessor and the test that depends on it says so.
- */
-
-import { encode_meshopt_attributes } from "../../../core/binary/meshopt/__meshopt_test_streams.js";
-import { align_4 } from "../../../core/binary/align_4.js";
-
-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 = 102;
-
-/**
- * @returns {ArrayBuffer}
- */
-export function build_triangle_bin() {
-    const buffer = new ArrayBuffer(GLTF_FIXTURE_BIN_BYTE_LENGTH);
-
-    new Float32Array(buffer, 0, 9).set([0, 0, 0, 1, 0, 0, 0, 1, 0]);
-    new Float32Array(buffer, 36, 9).set([0, 0, 1, 0, 0, 1, 0, 0, 1]);
-    new Float32Array(buffer, 72, 6).set([0, 0, 1, 0, 0, 1]);
-    new Uint16Array(buffer, 96, 3).set([0, 1, 2]);
-
-    return buffer;
-}
-
-/**
- * @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) {
-    return {
-        asset: { version: '2.0' },
-        scene: 0,
-        scenes: [{ nodes: [0] }],
-        nodes: [{ name: GLTF_FIXTURE_NODE_NAME, mesh: 0 }],
-        meshes: [{
-            name: GLTF_FIXTURE_MESH_NAME,
-            primitives: [{ attributes: { POSITION: 0, NORMAL: 1, TEXCOORD_0: 2 }, indices: 3 }]
-        }],
-        accessors: [
-            {
-                bufferView: 0, componentType: 5126, count: 3, type: 'VEC3',
-                min: [0, 0, 0], max: [1, 1, 0]
-            },
-            { bufferView: 1, componentType: 5126, count: 3, type: 'VEC3' },
-            { bufferView: 2, componentType: 5126, count: 3, type: 'VEC2' },
-            { bufferView: 3, componentType: 5123, count: 3, type: 'SCALAR' }
-        ],
-        bufferViews: [
-            { buffer: 0, byteOffset: 0, byteLength: 36 },
-            { buffer: 0, byteOffset: 36, byteLength: 36 },
-            { buffer: 0, byteOffset: 72, byteLength: 24 },
-            { buffer: 0, byteOffset: 96, byteLength: 6 }
-        ],
-        buffers: [buffer_uri === undefined
-            ? { byteLength: GLTF_FIXTURE_BIN_BYTE_LENGTH }
-            : { uri: buffer_uri, byteLength: GLTF_FIXTURE_BIN_BYTE_LENGTH }]
-    };
-}
-
-/**
- * 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, image_uri) {
-    const json = build_triangle_gltf_json(buffer_uri);
-
-    json.meshes[0].primitives[0].material = 0;
-
-    json.materials = [{
-        name: 'unit_skin',
-        pbrMetallicRoughness: { baseColorTexture: { index: 0 } }
-    }];
-
-    json.textures = [{ source: 0, sampler: 0 }];
-    json.samplers = [{}];
-    json.images = [{ uri: image_uri, mimeType: 'image/png' }];
-
-    return json;
-}
-
-/**
- * The same model as a .glb — the JSON chunk followed by the binary one.
- *
- * @returns {ArrayBuffer}
- */
-export function build_triangle_glb() {
-    const json_bytes = new TextEncoder().encode(JSON.stringify(build_triangle_gltf_json(undefined)));
-
-    // both chunks are padded to a four byte boundary, per the container's own rule
-    const json_length = align_4(json_bytes.byteLength);
-
-    const bin = new Uint8Array(build_triangle_bin());
-    const bin_length = align_4(bin.byteLength);
-
-    const total = 12 + 8 + json_length + 8 + bin_length;
-
-    const glb = new ArrayBuffer(total);
-    const view = new DataView(glb);
-    const bytes = new Uint8Array(glb);
-
-    view.setUint32(0, 0x46546C67, true);
-    view.setUint32(4, 2, true);
-    view.setUint32(8, total, true);
-
-    view.setUint32(12, json_length, true);
-    view.setUint32(16, 0x4E4F534A, true);
-    bytes.set(json_bytes, 20);
-    bytes.fill(0x20, 20 + json_bytes.byteLength, 20 + json_length);
-
-    const bin_header = 20 + json_length;
-
-    view.setUint32(bin_header, bin_length, true);
-    view.setUint32(bin_header + 4, 0x004E4942, true);
-    bytes.set(bin, bin_header + 8);
-
-    return glb;
-}
-
-/*
- The same triangle, compressed. Both meshopt extensions are bufferView extensions, so the model is
- unchanged above the bufferViews: same nodes, same mesh, same accessors, same uncompressed layout
- declared on the parent views. What differs is where the bytes come from.
-*/
-
-/**
- * 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 = GLTF_FIXTURE_BIN_BYTE_LENGTH;
-
-/**
- * YCoCg colour for the three vertices, as the `COLOR` filter takes it: luma, the two chroma
- * differences (signed), and an alpha whose most significant set bit declares the precision.
- * @type {number[]}
- */
-const GLTF_FIXTURE_YCOCG = [
-    100, 50, -20 & 0xff, 0xff,
-    200, 0, 0, 0xff,
-    60, -30 & 0xff, 10, 0xc0
-];
-
-/**
- * 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 = [
-    170, 80, 70, 255,
-    200, 200, 200, 255,
-    20, 70, 80, 128
-];
-
-/**
- * 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 = 0, colour = false } = {}) {
-    const bin = build_triangle_bin();
-
-    /**
-     * @param {number[]} modes
-     * @returns {Object}
-     */
-    const attributes = (modes) => codec_version === 1
-        ? { version: 1, channel_modes: modes }
-        : { version: 0 };
-
-    const streams = [
-        encode_meshopt_attributes(new Uint8Array(bin, 0, 36), 3, 12, attributes([
-            2 | (5 << 4), 2 | (5 << 4), 2 | (5 << 4)
-        ])),
-        encode_meshopt_attributes(new Uint8Array(bin, 36, 36), 3, 12, attributes([0, 0, 0])),
-        encode_meshopt_attributes(new Uint8Array(bin, 72, 24), 3, 8, attributes([1, 1])),
-        new Uint8Array([0xe1, 0xf0, ...new Array(16).fill(0)])
-    ];
-
-    if (colour) {
-        streams.push(encode_meshopt_attributes(new Uint8Array(GLTF_FIXTURE_YCOCG), 3, 4, attributes([0])));
-    }
-
-    const total = streams.reduce((sum, stream) => sum + stream.length, 0);
-
-    const bytes = new Uint8Array(total);
-
-    const ranges = [];
-
-    let byteOffset = 0;
-
-    for (const stream of streams) {
-        bytes.set(stream, byteOffset);
-
-        ranges.push({ byteOffset, byteLength: stream.length });
-
-        byteOffset += stream.length;
-    }
-
-    return { buffer: bytes.buffer, ranges };
-}
-
-/**
- * @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, buffer_uri, options = {}) {
-    const { buffer, ranges } = build_meshopt_triangle_bin(options);
-
-    const json = build_triangle_gltf_json(undefined);
-
-    json.extensionsUsed = [extension_name];
-    json.extensionsRequired = [extension_name];
-
-    /**
-     * @param {number} view the parent view's index
-     * @param {number} byteStride
-     * @param {number} count
-     * @param {string} mode
-     * @returns {object}
-     */
-    function compressed(view, byteStride, count, mode) {
-        return {
-            buffer: 0,
-            byteOffset: ranges[view].byteOffset,
-            byteLength: ranges[view].byteLength,
-            byteStride,
-            count,
-            mode
-        };
-    }
-
-    const shapes = [
-        [12, 3, 'ATTRIBUTES', undefined],
-        [12, 3, 'ATTRIBUTES', undefined],
-        [8, 3, 'ATTRIBUTES', undefined],
-        [2, 3, 'TRIANGLES', undefined]
-    ];
-
-    if (options.colour === true) {
-        // an unsigned normalised VEC4, which is what the COLOR filter decodes to
-        json.bufferViews.push({ buffer: 0, byteOffset: 102, byteLength: 12 });
-
-        json.accessors.push({
-            bufferView: 4, componentType: 5121, count: 3, type: 'VEC4', normalized: true
-        });
-
-        json.meshes[0].primitives[0].attributes.COLOR_0 = 4;
-
-        shapes.push([4, 3, 'ATTRIBUTES', 'COLOR']);
-    }
-
-    json.bufferViews = json.bufferViews.map((view, i) => {
-        const [byteStride, count, mode, filter] = shapes[i];
-
-        return {
-            ...view,
-            // the placeholder, which nothing reads once the views below are decoded
-            buffer: 1,
-            // index views are forbidden a stride by the base format, whatever the extension needs
-            ...(mode === 'ATTRIBUTES' ? { byteStride } : {}),
-            extensions: {
-                [extension_name]: {
-                    ...compressed(i, byteStride, count, mode),
-                    ...(filter === undefined ? {} : { filter })
-                }
-            }
-        };
-    });
-
-    json.buffers = [
-        buffer_uri === undefined
-            ? { byteLength: buffer.byteLength }
-            : { uri: buffer_uri, byteLength: buffer.byteLength },
-        {
-            // big enough for every uncompressed view over it, which is what both specs require
-            byteLength: GLTF_FIXTURE_FALLBACK_BYTE_LENGTH + (options.colour === true ? 12 : 0),
-            extensions: { [extension_name]: { fallback: true } }
-        }
-    ];
-
-    return json;
-}
-
-/**
- * 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, options = {}) {
-    const json_bytes = new TextEncoder().encode(
-        JSON.stringify(build_meshopt_triangle_gltf_json(extension_name, undefined, options))
-    );
-
-    const json_length = align_4(json_bytes.byteLength);
-
-    const bin = new Uint8Array(build_meshopt_triangle_bin(options).buffer);
-    const bin_length = align_4(bin.byteLength);
-
-    const total = 12 + 8 + json_length + 8 + bin_length;
-
-    const glb = new ArrayBuffer(total);
-    const view = new DataView(glb);
-    const bytes = new Uint8Array(glb);
-
-    view.setUint32(0, 0x46546C67, true);
-    view.setUint32(4, 2, true);
-    view.setUint32(8, total, true);
-
-    view.setUint32(12, json_length, true);
-    view.setUint32(16, 0x4E4F534A, true);
-    bytes.set(json_bytes, 20);
-    bytes.fill(0x20, 20 + json_bytes.byteLength, 20 + json_length);
-
-    const bin_header = 20 + json_length;
-
-    view.setUint32(bin_header, bin_length, true);
-    view.setUint32(bin_header + 4, 0x004E4942, true);
-    bytes.set(bin, bin_header + 8);
-
-    return glb;
-}

package/src/engine/sound/simulation/core/OcclusionSolver.d.ts

@@ -1,29 +0,0 @@
-/**
- * Computes per-source occlusion + transmission by shooting rays from the listener toward points spread
- * over the source's sphere and counting how many are blocked by the {@link AcousticOccluderIndex}.
- *
- * - Volumetric (not boolean): occlusion is the FRACTION of blocked rays, so partially-hidden sources
- *   attenuate smoothly instead of popping on/off.
- * - Transmission: blocked rays accumulate their occluder's per-band transmission; the average is the
- *   energy that leaks through.
- * - Temporal: the fibonacci sample set is randomly re-oriented each tick (seeded), and the result is
- *   folded into an {@link AcousticSourceState} via EMA — so a low per-tick ray count integrates over
- *   frames and the output stays frame-stable.
- *
- * Pure: geometry in, numbers out. No WebAudio, no ECS, no allocation.
- */
-export class OcclusionSolver {
-    /**
-     * @param {Vector3} listener listener world position
-     * @param {Vector3} source source world position
-     * @param {number} sourceRadius apparent radius of the source (0 = point source → boolean occlusion)
-     * @param {AcousticOccluderIndex} index
-     * @param {number} rayCount rays shot this tick (≥ 1)
-     * @param {number} smoothing EMA factor in (0, 1] — 1 = no smoothing
-     * @param {function():number} random seeded RNG; decorrelates the sample set per call
-     * @param {AcousticSourceState} state per-source temporal accumulation (mutated)
-     * @param {AcousticSolution} out occlusion + transmission written here (medium untouched)
-     */
-    solve(listener: Vector3, source: Vector3, sourceRadius: number, index: AcousticOccluderIndex, rayCount: number, smoothing: number, random: () => number, state: AcousticSourceState, out: AcousticSolution): void;
-}
-//# sourceMappingURL=OcclusionSolver.d.ts.map

package/src/engine/sound/simulation/core/OcclusionSolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OcclusionSolver.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/OcclusionSolver.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;;;OAUG;IACH,wDARW,MAAM,0CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DA4F3B;CACJ"}

package/src/shade/renderer/animation/skin_test_fixtures.d.ts

@@ -1,86 +0,0 @@
-/**
- * A rigged character in one of the two shapes.
- *
- * The rest pose **is** the bind pose, which is what a well-formed file has. The bind matrices are
- * taken off the skeleton itself rather than composed by hand: the fixture walks the hierarchy once
- * with the root's conversion in place and once without, and the two snapshots *are* the two bind
- * spaces. Nothing here can drift from the hierarchy it describes, because it is read from it.
- *
- * The placement node goes on last, after the bind matrices are settled — which is what happens for
- * real, and is what makes "the correction does not depend on where the character stands" a fact this
- * fixture can be asked about rather than an assumption.
- *
- * @param {object} options
- * @param {BindSpace} options.bind_space
- * @param {number} [options.scale] the root's uniform conversion
- * @param {boolean} [options.up_axis_rotation] whether the root also carries the −90° about x that an
- *        FBX-derived file pairs with its conversion. On by default: a correction that handles only
- *        the scale passes without it.
- * @param {number[]} [options.placement] a translation applied above the whole character
- * @returns {{
- *     placement: Node3D,
- *     root: Node3D,
- *     mesh: SkinnedMesh,
- *     skin: Skin,
- *     joints: Node3D[],
- * }}
- */
-export function make_character({ bind_space, scale, up_axis_rotation, placement, }: {
-    bind_space: BindSpace;
-    scale?: number;
-    up_axis_rotation?: boolean;
-    placement?: number[];
-}): {
-    placement: Node3D;
-    root: Node3D;
-    mesh: SkinnedMesh;
-    skin: Skin;
-    joints: Node3D[];
-};
-/**
- * The two shapes a glTF character actually arrives in, built as scene graphs.
- *
- * Both are legal glTF and both are in the wild; the difference is only the space the file's author
- * wrote the inverse-bind matrices in, and it decides whether `inverse(mesh.global) × joint.global ×
- * inverse_bind` — the matrix the skinning pass converts to a dual quaternion — comes out rigid. See
- * `SKINNING_FRAME_PLAN.md`.
- *
- * One hierarchy serves both, because the difference is not in the hierarchy:
- *
- * ```
- * "placement"      added at runtime, above the file's own roots
- * └── "Character"  the file's unit conversion and up-axis rotation
- *     ├── "Mesh"   the skinned mesh, no local transform of its own
- *     └── "Joint0" the joint root — the mesh node's *sibling*, as every rigged glTF has it
- *         └── "Joint1"
- *             └── "Joint2"
- * ```
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/**
- * What every one of this game's creature models puts on its glTF root node — an FBX unit
- * conversion, uniform, and inherited by the joints and the mesh node alike.
- *
- * @type {number}
- */
-export const EXPORT_SCALE: number;
-/**
- * The centimetre→metre conversion `Michelle.glb` carries on hers.
- *
- * @type {number}
- */
-export const MICHELLE_SCALE: number;
-/**
- * Where the file's author wrote the inverse-bind matrices.
- */
-export type BindSpace = string;
-export namespace BindSpace {
-    let PreScale: string;
-    let World: string;
-}
-import { Node3D } from "../scene/Node3D.js";
-import { SkinnedMesh } from "../scene/SkinnedMesh.js";
-import { Skin } from "./Skin.js";
-//# sourceMappingURL=skin_test_fixtures.d.ts.map

package/src/shade/renderer/animation/skin_test_fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skin_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_test_fixtures.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAd8B,UAAU,EAA7B,SAAS;IACQ,KAAK,GAAtB,MAAM;IACY,gBAAgB,GAAlC,OAAO;IAGY,SAAS,GAA5B,MAAM,EAAE;;eAED,MAAM;UACX,MAAM;UACN,WAAW;UACX,IAAI;YACF,MAAM,EAAE;EAgFtB;AAjLD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;GAKG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;GAIG;AACH,6BAFU,MAAM,CAEmB;;;;wBAKzB,MAAM;;;;;uBA7CO,oBAAoB;4BACf,yBAAyB;qBAChC,WAAW"}