@woosh/meep-engine 3.16.0 → 3.17.1

package/src/shade/renderer/particles/runtime/ProgramArena.d.ts

@@ -1,89 +0,0 @@
-/**
- * Packs many compiled {@link ../isa/ParticleProgram.js} programs into one shared buffer — a header,
- * every program's constant pool, then every program's instruction words — and hands back the
- * offsets each emitter records.
- *
- * Data before code, behind a four-word header whose first word says where the code starts: the VM
- * reads both sections through one binding (a storage buffer per stage is not free, and code and
- * constants are read together), and an emitter's constant pool sits next to the pools of the
- * programs it shares a wave with.
- *
- * Because VM instructions carry no absolute code addresses (control flow is branchless) and
- * constant references are program-local (the VM adds the emitter's `constant_offset`), programs
- * can be concatenated at any offset. INIT and UPDATE sections are laid out back-to-back per program.
- */
-export class ProgramArena {
-    /**
-     * Flat instruction words, every program's INIT and UPDATE sections concatenated.
-     * @type {number[]}
-     */
-    instruction_words: number[];
-    /**
-     * Flat constant words (f32 bit patterns), every program's pool concatenated.
-     * @type {number[]}
-     */
-    constant_words: number[];
-    /**
-     * Running instruction index — INIT/UPDATE offsets are in these units.
-     * @type {number}
-     */
-    instruction_count: number;
-    /**
-     * Running constant word index — the pool is addressed by word, so a scalar literal costs one
-     * rather than the four a `vec4` entry used to.
-     * @type {number}
-     */
-    constant_word_count: number;
-    /**
-     * Content key -> the placement the first identical program got.
-     * @type {Map<string, {init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}>}
-     */
-    programs: Map<string, {
-        init_offset: number;
-        init_count: number;
-        update_offset: number;
-        update_count: number;
-        constant_offset: number;
-        program_id: number;
-    }>;
-    /**
-     * Number of distinct programs in the arena — and therefore the number of buckets the
-     * simulation-order pass histograms into. Program ids are dense in `[0, program_count)`.
-     * @returns {number}
-     */
-    get program_count(): number;
-    /**
-     * Append a program, or hand back the placement an identical one already has.
-     *
-     * Deduplication is by CONTENT, not object identity: two emitters that authored the same graph
-     * separately compile to distinct {@link ParticleProgram} objects holding the same bytecode, and
-     * they should still land in one simulation bucket. Emitters are few and long-lived, so hashing
-     * the words is not a cost worth avoiding.
-     *
-     * The `program_id` it returns is what the emitter record carries and what the coherence pass
-     * buckets on. Keying on the emitter index instead would be simpler but strictly worse: N
-     * emitters running one shared effect would become N buckets, each padded to a whole workgroup,
-     * which both wastes lanes and splits a run that was already program-coherent.
-     *
-     * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
-     * @returns {{init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
-     */
-    add(program: import("../isa/ParticleProgram.js").ParticleProgram): {
-        init_offset: number;
-        init_count: number;
-        update_offset: number;
-        update_count: number;
-        constant_offset: number;
-        program_id: number;
-    };
-    /**
-     * The packed buffer: `[header][constants][code]`. Word {@link PARTICLE_PROGRAM_CODE_BASE_WORD} of
-     * the header is the word index the code starts at, which moves every time a program's constants
-     * are appended — the emitter records never carry it, they carry offsets into each section.
-     *
-     * @returns {Uint32Array}
-     */
-    build_program_buffer(): Uint32Array;
-    #private;
-}
-//# sourceMappingURL=ProgramArena.d.ts.map

package/src/shade/renderer/particles/runtime/ProgramArena.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProgramArena.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ProgramArena.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;OAGG;IACH,mBAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAEE;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,UAFU,IAAI,MAAM,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAErI;IAErB;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,aAHW,OAAO,2BAA2B,EAAE,eAAe;qBACnC,MAAM;oBAAc,MAAM;uBAAiB,MAAM;sBAAgB,MAAM;yBAAmB,MAAM;oBAAc,MAAM;MAgC9I;IAUD;;;;;;OAMG;IACH,wBAFa,WAAW,CAcvB;;CACJ"}

package/src/shade/renderer/particles/runtime/ProgramArena.js

@@ -1,155 +0,0 @@
-import {
-    PARTICLE_PROGRAM_CODE_BASE_WORD,
-    PARTICLE_PROGRAM_HEADER_WORDS,
-    PARTICLE_VM_INSTRUCTION_WORDS,
-} from "../ParticleConstants.js";
-
-/**
- * Packs many compiled {@link ../isa/ParticleProgram.js} programs into one shared buffer — a header,
- * every program's constant pool, then every program's instruction words — and hands back the
- * offsets each emitter records.
- *
- * Data before code, behind a four-word header whose first word says where the code starts: the VM
- * reads both sections through one binding (a storage buffer per stage is not free, and code and
- * constants are read together), and an emitter's constant pool sits next to the pools of the
- * programs it shares a wave with.
- *
- * Because VM instructions carry no absolute code addresses (control flow is branchless) and
- * constant references are program-local (the VM adds the emitter's `constant_offset`), programs
- * can be concatenated at any offset. INIT and UPDATE sections are laid out back-to-back per program.
- */
-export class ProgramArena {
-
-    /**
-     * Flat instruction words, every program's INIT and UPDATE sections concatenated.
-     * @type {number[]}
-     */
-    instruction_words = [];
-
-    /**
-     * Flat constant words (f32 bit patterns), every program's pool concatenated.
-     * @type {number[]}
-     */
-    constant_words = [];
-
-    /**
-     * Running instruction index — INIT/UPDATE offsets are in these units.
-     * @type {number}
-     */
-    instruction_count = 0;
-
-    /**
-     * Running constant word index — the pool is addressed by word, so a scalar literal costs one
-     * rather than the four a `vec4` entry used to.
-     * @type {number}
-     */
-    constant_word_count = 0;
-
-    /**
-     * Content key -> the placement the first identical program got.
-     * @type {Map<string, {init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}>}
-     */
-    programs = new Map();
-
-    /**
-     * Number of distinct programs in the arena — and therefore the number of buckets the
-     * simulation-order pass histograms into. Program ids are dense in `[0, program_count)`.
-     * @returns {number}
-     */
-    get program_count() {
-        return this.programs.size;
-    }
-
-    /**
-     * Append a program, or hand back the placement an identical one already has.
-     *
-     * Deduplication is by CONTENT, not object identity: two emitters that authored the same graph
-     * separately compile to distinct {@link ParticleProgram} objects holding the same bytecode, and
-     * they should still land in one simulation bucket. Emitters are few and long-lived, so hashing
-     * the words is not a cost worth avoiding.
-     *
-     * The `program_id` it returns is what the emitter record carries and what the coherence pass
-     * buckets on. Keying on the emitter index instead would be simpler but strictly worse: N
-     * emitters running one shared effect would become N buckets, each padded to a whole workgroup,
-     * which both wastes lanes and splits a run that was already program-coherent.
-     *
-     * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
-     * @returns {{init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
-     */
-    add(program) {
-        const key = program_content_key(program);
-
-        const existing = this.programs.get(key);
-        if (existing !== undefined) {
-            return existing;
-        }
-
-        const init_offset = this.instruction_count;
-        this.#append_instructions(program.init);
-        const init_count = program.init_instruction_count;
-
-        const update_offset = this.instruction_count;
-        this.#append_instructions(program.update);
-        const update_count = program.update_instruction_count;
-
-        const constant_offset = this.constant_word_count;
-        const constant_u32 = new Uint32Array(program.constants.buffer, program.constants.byteOffset, program.constants.length);
-        for (let i = 0; i < constant_u32.length; i++) {
-            this.constant_words.push(constant_u32[i]);
-        }
-        this.constant_word_count += program.constant_word_count;
-
-        const placement = {
-            init_offset, init_count, update_offset, update_count, constant_offset,
-            program_id: this.programs.size,
-        };
-        this.programs.set(key, placement);
-
-        return placement;
-    }
-
-    /** @param {Uint32Array} words */
-    #append_instructions(words) {
-        for (let i = 0; i < words.length; i++) {
-            this.instruction_words.push(words[i]);
-        }
-        this.instruction_count += words.length / PARTICLE_VM_INSTRUCTION_WORDS;
-    }
-
-    /**
-     * The packed buffer: `[header][constants][code]`. Word {@link PARTICLE_PROGRAM_CODE_BASE_WORD} of
-     * the header is the word index the code starts at, which moves every time a program's constants
-     * are appended — the emitter records never carry it, they carry offsets into each section.
-     *
-     * @returns {Uint32Array}
-     */
-    build_program_buffer() {
-        const constants = this.constant_words;
-        const code = this.instruction_words;
-
-        const code_base = PARTICLE_PROGRAM_HEADER_WORDS + constants.length;
-        const buffer = new Uint32Array(code_base + code.length);
-
-        buffer[PARTICLE_PROGRAM_CODE_BASE_WORD] = code_base;
-        buffer.set(constants, PARTICLE_PROGRAM_HEADER_WORDS);
-        buffer.set(code, code_base);
-
-        return buffer;
-    }
-}
-
-/**
- * A key that is equal exactly when two programs would execute identically.
- *
- * Constants are keyed by their `u32` bit patterns rather than their float values, so `-0` and `0`
- * — which stringify the same but differ in the buffer the shader reads — stay distinct.
- *
- * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
- * @returns {string}
- */
-function program_content_key(program) {
-    const constants = program.constants;
-    const constant_u32 = new Uint32Array(constants.buffer, constants.byteOffset, constants.length);
-
-    return `${program.register_count}|${program.init.join(",")}|${program.update.join(",")}|${constant_u32.join(",")}`;
-}

package/src/shade/renderer/particles/runtime/emitter_database_image.d.ts

@@ -1,15 +0,0 @@
-/**
- * The emitter table as the `array<u32>` a shader binds, built on the CPU.
- *
- * For the WGSL emulator: on a device the rows get there through the database's upload dispatch, and
- * the software device records dispatches without running them, so a spec that wants to run
- * `shader_particle_emit` (or simulate, or sort, or the bucket histogram) over real emitters has no
- * other way to hand it their bytes. See
- * {@link ../../buffer/table/gpu_database_emulator_image.js}.
- *
- * @param {Iterable<import("./Emitter.js").Emitter>} emitters registered emitters — each one's
- *        {@link Emitter#id} is the row it lands on, so the layout matches what the shaders index
- * @returns {Uint32Array}
- */
-export function emitter_database_image(emitters: Iterable<import("./Emitter.js").Emitter>): Uint32Array;
-//# sourceMappingURL=emitter_database_image.d.ts.map

package/src/shade/renderer/particles/runtime/emitter_database_image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter_database_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/emitter_database_image.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,iDAJW,SAAS,OAAO,cAAc,EAAE,OAAO,CAAC,GAEtC,WAAW,CAMvB"}

package/src/shade/renderer/particles/runtime/spawn_request_encoding.d.ts

@@ -1,34 +0,0 @@
-/**
- * @param {number} emitter_index
- * @param {number} fraction in [0, 1]
- * @returns {number} packed u32
- */
-export function spawn_request_pack(emitter_index: number, fraction: number): number;
-/**
- * @param {number} packed
- * @returns {number} emitter index
- */
-export function spawn_request_emitter(packed: number): number;
-/**
- * @param {number} packed
- * @returns {number} batch fraction in [0, 1]
- */
-export function spawn_request_fraction(packed: number): number;
-/**
- * Encoding of one spawn request as a single `u32`.
- *
- * The emit pass needs two things per request: which emitter owns the new particle, and the
- * particle's fraction within its emitter's batch this frame (`i / spawn_count`, the SPAWN_FRACTION
- * VM builtin — used to spread a batch along spawn curves). Packing both into the one `u32` keeps
- * the request stream a single buffer with unchanged upload paths.
- *
- * Layout: low 16 bits = emitter index, high 16 bits = batch fraction quantized to [0, 0xFFFF].
- * The WGSL emit shader mirrors this exactly (shader_particle_emit).
- */
-/** @type {number} */
-export const SPAWN_REQUEST_EMITTER_MASK: number;
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_SHIFT: number;
-/** @type {number} */
-export const SPAWN_REQUEST_FRACTION_MAX: number;
-//# sourceMappingURL=spawn_request_encoding.d.ts.map

package/src/shade/renderer/particles/runtime/spawn_request_encoding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawn_request_encoding.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/spawn_request_encoding.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,kDAJW,MAAM,YACN,MAAM,GACJ,MAAM,CASlB;AAED;;;GAGG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,+CAHW,MAAM,GACJ,MAAM,CAIlB;AAjDD;;;;;;;;;;GAUG;AAEH,qBAAqB;AACrB,yCADW,MAAM,CACgC;AAEjD,qBAAqB;AACrB,2CADW,MAAM,CAC8B;AAE/C,qBAAqB;AACrB,yCADW,MAAM,CACgC"}

package/src/shade/renderer/particles/shaders/chunk_particle_context.d.ts

@@ -1,32 +0,0 @@
-/**
- * Populates the VM's builtin context and seeds its RNG for one particle before a program section
- * runs.
- *
- * The emitter's world position / direction / up come from its scene node — the `global` of its row
- * in the scene database's `transforms` table, which the GPU hierarchy pass composed this frame from
- * the node's own transform and its parents'. An emitter parented to an animated joint therefore
- * spawns and simulates where the joint is *now*, with nothing copied through the CPU: the joint's
- * pose was written by the animation passes and composed by the hierarchy pass, and this reads the
- * result. The caller fetches the node with `scene_read_node(&scene_database, em.node)`.
- *
- * The emitter's age is the tick pass's running total, read off the `emitter_state` table of the
- * same database the emitter record came from ({@link ../data/PARTICLE_EMITTER_STATE.js}) — one
- * binding for both, through the table's single-field reader.
- *
- * Depends on {@link chunk_particle_vm} (owns `vm_ctx` / `vm_rng_state`),
- * {@link chunk_particle_emitter} (the `ParticleEmitter` struct) and
- * {@link chunk_scene_database_access} (the node struct + reader).
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_context: CodeChunk;
-/**
- * Default curve provider: no curves bound, `CURVE` opcodes evaluate to 0. The production feature
- * swaps this for an animation-database-backed provider (see the feature wiring). Kept separate so an
- * effect that uses no curves compiles without any animation bindings.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_curve_disabled: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_context.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_context.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_context.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qCAFU,SAAS,CA8ChB;AAEH;;;;;;GAMG;AACH,4CAFU,SAAS,CAIhB;0BAnFuB,oCAAoC"}