@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -1,117 +1,438 @@
 import { assert } from "../../../../core/assert.js";
+import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
 import {
-    EMITTER_ATTACH_NONE,
-    EMITTER_STRIDE,
-    make_emitter_flags,
-    pack_emitter,
-} from "../data/PARTICLE_EMITTER_LAYOUT.js";
-import { ProgramArena } from "./ProgramArena.js";
+    PARTICLE_DATABASE_INITIAL_SIZE,
+    PARTICLE_DATABASE_SPEC,
+    PARTICLE_EMITTER_STATE_TABLE,
+    PARTICLE_EMITTER_TABLE
+} from "../data/PARTICLE_DATABASE_SPEC.js";
+import { PARTICLE_EMITTER_STATE_EMPTY } from "../data/PARTICLE_EMITTER_STATE.js";
+import { create_emitter_record, write_emitter_record } from "../data/particle_emitter_record.js";
+import { PARTICLE_GENERATION_FIRST, particle_generation_next } from "../data/particle_header.js";
+import { GPUParticleEmitterContext } from "./GPUParticleEmitterContext.js";
+import { ParticleEmitter } from "./ParticleEmitter.js";
+import { ProgramHeap } from "./ProgramHeap.js";
 
-const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-const RENDER_KEYS = ["position", "size", "color", "rotation", "frame", "velocity"];
+/**
+ * Staging for one emitter row. Reused across every write — the table serializes it into its page
+ * shadow synchronously, so nothing outlives the call. This is what keeps a frame's flush free of
+ * allocation whatever the number of rows it restages.
+ */
+const RECORD = create_emitter_record();
 
 /**
- * CPU-side registry of emitters. Each emitter binds a compiled effect (from
- * {@link ./create_particle_effect.js}) to instance parameters — world transform, spawn rate, blend /
- * projection / feature flags, bounds, render-attribute binding, atlas region and flipbook grid.
+ * The emitter set: {@link ParticleEmitter} instances on the CPU, one GPU table row each.
+ *
+ * Rows live in a {@link GPUDatabase} table ({@link ../data/PARTICLE_DATABASE_SPEC.js}), which is
+ * what makes the set editable at runtime. Adding an emitter stages one record; removing one frees
+ * its slot for the next add; changing one restages that record and nothing else. Rows are handed
+ * out by the table and are stable for an emitter's lifetime — they have to be, because every live
+ * particle's record header stores the row of the emitter that spawned it.
+ *
+ * Reuse of a freed row is made safe by the **generation**: every add takes the next value of one
+ * running counter, so no two emitters this registry has ever registered share one, and the
+ * particles of a removed emitter — which carry its generation — cannot be mistaken for the new
+ * tenant's. The simulate pass kills them on sight; see {@link ../data/particle_header.js}.
+ *
+ * **None of that bookkeeping is on the emitter.** An emitter is a scene node and a description of
+ * an effect, with nothing in it that depends on a device; the row, the generation, the program
+ * placement, the node's `transforms` row and the atlas patch are a
+ * {@link ./GPUParticleEmitterContext.js} this registry holds against the emitter and hands out
+ * through {@link EmitterRegistry#context}. Registering an emitter creates one, removing it destroys
+ * one, and an emitter with no context here is an emitter this registry does not have.
  *
- * {@link build} produces the three upload-ready buffers the GPU passes consume: the packed emitter
- * records, the concatenated program instructions, and the constant pool. Emitters are few and
- * long-lived, so the whole set is repacked when it changes.
+ * The GPU-owned per-emitter state is the database's second table, claimed and released here at the
+ * emitter's row and never written by the CPU otherwise.
+ *
+ * Programs are the one thing NOT in the database: they are variable-length and shared, so they go
+ * into a packed {@link ProgramHeap} buffer and the emitter record carries offsets into it. The heap
+ * is content-deduplicated and reference-counted — two emitters compiled from the same graph land on
+ * one program id, which is what the simulation-order bucketing buckets on, and the last emitter of
+ * an effect is what releases it.
  */
 export class EmitterRegistry {
-    constructor() {
-        /** @type {object[]} */
-        this.emitters = [];
+
+    /**
+     * @type {GPUDatabase}
+     */
+    database;
+
+    /**
+     * Packed instruction + constant buffers for every distinct program in the set.
+     * @type {ProgramHeap}
+     */
+    programs = new ProgramHeap();
+
+    /**
+     * The live emitters, in no particular order — the row in {@link context} is the identity.
+     * @type {ParticleEmitter[]}
+     */
+    emitters = [];
+
+    /**
+     * The live emitters by table row. Sparse: a freed row reads `undefined` until it is reused.
+     * Rows are small dense integers handed out lowest-free-first, so an array is the right index.
+     *
+     * @type {ParticleEmitter[]}
+     */
+    by_row = [];
+
+    /**
+     * Whether {@link programs} has changed since {@link build_program} last packed it. The buffer is
+     * monolithic (a program is variable-length, so there is no table to page it into), so any change
+     * means re-uploading it whole — which is why the heap dedupes by content, and why this is
+     * separate from the per-row dirtiness the table tracks.
+     *
+     * Read off the heap's own version rather than kept as a flag: there is then no path that changes
+     * the programs and forgets to say so.
+     *
+     * @returns {boolean}
+     */
+    get programs_dirty() {
+        return this.programs.version !== this.#built_programs_version;
     }
 
-    /** @returns {number} number of registered emitters */
+    /**
+     * {@link ProgramHeap#version} the last {@link build_program} packed. `-1` for "nothing has been
+     * built yet", which no version reaches.
+     *
+     * @type {number}
+     */
+    #built_programs_version = -1;
+
+    /**
+     * {@link ProgramHeap#placement_version} the rows were last staged against. When the heap repacks,
+     * every program that was already placed moves, so every row built from the old offsets has to be
+     * written again — see {@link flush}.
+     *
+     * @type {number}
+     */
+    #staged_placement_version = 0;
+
+    /**
+     * What this registry knows about each emitter it holds, and the only place any of it exists.
+     *
+     * @type {Map<ParticleEmitter, GPUParticleEmitterContext>}
+     */
+    #contexts = new Map();
+
+    /**
+     * The generation the next add will take.
+     * @type {number}
+     */
+    #generation = PARTICLE_GENERATION_FIRST;
+
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.database = new GPUDatabase({
+            device,
+            definition: PARTICLE_DATABASE_SPEC,
+            label: 'Particles / Emitters',
+            initial_data_size_bytes: PARTICLE_DATABASE_INITIAL_SIZE,
+        });
+    }
+
+    /**
+     * The emitter table.
+     * @returns {GPUTypedTable}
+     */
+    get table() {
+        return this.database.get(PARTICLE_EMITTER_TABLE);
+    }
+
+    /**
+     * The GPU-owned state table: one row per emitter, at the emitter's row, claimed and released
+     * here and otherwise the GPU's.
+     * @returns {GPUTypedTable}
+     */
+    get state_table() {
+        return this.database.get(PARTICLE_EMITTER_STATE_TABLE);
+    }
+
+    /**
+     * @returns {number} number of live emitters
+     */
     get count() {
         return this.emitters.length;
     }
 
     /**
-     * Register an emitter.
+     * Number of distinct compiled programs registered.
+     * @returns {number}
+     */
+    get program_count() {
+        return this.programs.program_count;
+    }
+
+    /**
+     * Number of buckets the simulation-order coherence pass histograms into: every live program id
+     * is below it. See {@link ProgramHeap#program_id_capacity}.
      *
-     * @param {object} config
-     * @param {{layout: object, program: object}} config.effect compiled effect
-     * @param {number[]} [config.transform] 16-element column-major local-to-world matrix
-     * @param {number} [config.seed]
-     * @param {number} [config.spawn_rate] particles/second
-     * @param {object} [config.flags] passed to {@link make_emitter_flags}
-     * @param {{center?: number[], radius?: number}} [config.bounds]
-     * @param {Object<string,string>} [config.render] map of render channel -> attribute name
-     * @param {number[]} [config.atlas_region] [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
-     * @param {number[]} [config.flipbook] [cols, rows]
-     * @param {number} [config.attach_row] scene transforms row for bone attachment
-     * @returns {number} the emitter index
+     * @returns {number}
      */
-    add(config) {
-        assert.defined(config.effect, "config.effect");
-        assert.defined(config.effect.program, "config.effect.program");
-        assert.defined(config.effect.layout, "config.effect.layout");
+    get program_id_capacity() {
+        return this.programs.program_id_capacity;
+    }
 
-        this.emitters.push(config);
-        return this.emitters.length - 1;
+    /**
+     * Register slots the hungriest registered effect needs — a property of the whole set, since
+     * there is one simulate pipeline and it is chosen once. What a caller does with the number (pick
+     * a register backing, refuse the effect, warn an author) is the caller's; see
+     * {@link ProgramHeap#max_register_count}.
+     *
+     * @returns {number}
+     */
+    get max_register_count() {
+        return this.programs.max_register_count;
     }
 
     /**
-     * Pack all emitters + their programs into upload-ready buffers.
+     * What this registry assigned an emitter: its table row, generation, program placement, the
+     * `transforms` row of its node and its atlas patch.
      *
-     * `program_count` is the number of DISTINCT programs across the emitter set — the bucket count
-     * the simulation-order coherence pass histograms into. It is CPU-known and low-churn (it only
-     * changes when the emitter set does), which is why that pass can size its histogram, its cursor
-     * and its padding dispatch on the host without any of the per-frame counts ever leaving the GPU.
+     * `undefined` for an emitter this registry does not hold — which is the way to ask whether one
+     * is live, there being no `-1` on the emitter to read instead.
      *
-     * @returns {{ emitters: Uint32Array, program: Uint32Array, constants: Uint32Array, program_count: number }}
+     * @param {ParticleEmitter} emitter
+     * @returns {GPUParticleEmitterContext|undefined}
      */
-    build() {
-        const arena = new ProgramArena();
-        const emitters = new Uint32Array(Math.max(1, this.emitters.length) * EMITTER_STRIDE);
-        const f32 = new Float32Array(emitters.buffer);
+    context(emitter) {
+        return this.#contexts.get(emitter);
+    }
 
-        this.emitters.forEach((config, index) => {
-            const offsets = arena.add(config.effect.program);
-            const layout = config.effect.layout;
+    /**
+     * Register an emitter and give it a table row.
+     *
+     * @param {ParticleEmitter|object} config a {@link ParticleEmitter}, or a description
+     *        {@link ParticleEmitter.from} accepts
+     * @param {number} [transform_row] the emitter node's row in the scene's `transforms` table, if
+     *        already known; {@link set_transform_row} sets it later otherwise
+     * @returns {ParticleEmitter}
+     */
+    add(config, transform_row = 0) {
+        const emitter = config.isParticleEmitter === true ? config : ParticleEmitter.from(config);
 
-            const render = {};
-            if (config.render !== undefined) {
-                for (const key of RENDER_KEYS) {
-                    const attribute = config.render[key];
-                    if (attribute !== undefined) {
-                        render[key] = layout.offsetOf(attribute);
-                    }
-                }
-            }
+        assert.equal(this.#contexts.has(emitter), false, 'this emitter is already registered');
 
-            pack_emitter(emitters, f32, index, {
-                ...offsets,
-                seed: config.seed ?? (index + 1),
-                flags: make_emitter_flags(config.flags ?? {}),
-                spawn_rate: config.spawn_rate ?? 0,
-                transform: config.transform ?? IDENTITY,
-                bounds_center: config.bounds?.center,
-                bounds_radius: config.bounds?.radius,
-                render,
-                atlas_region: config.atlas_region,
-                flipbook: config.flipbook,
-            });
-        });
+        const context = new GPUParticleEmitterContext();
+
+        context.placement = this.programs.acquire(emitter.program);
+
+        context.generation = this.#generation;
+        this.#generation = particle_generation_next(this.#generation);
+
+        context.transform_row = transform_row;
 
-        return {
-            emitters,
-            program: arena.build_instruction_buffer(),
-            constants: arena.build_constant_buffer(),
-            program_count: Math.max(1, arena.program_count),
-        };
+        // The table picks the slot — the lowest free one, so a removed emitter's row is reused
+        // rather than the id space growing without bound.
+        context.row = this.table.add(write_emitter_record(RECORD, emitter, context));
+        context.staged(emitter);
+
+        // Claim the state row alongside: zeroed, so the first tick starts it over. The CPU never
+        // writes it again — see PARTICLE_EMITTER_STATE.
+        this.state_table.set(context.row, PARTICLE_EMITTER_STATE_EMPTY);
+
+        this.#contexts.set(emitter, context);
+        this.emitters.push(emitter);
+        this.by_row[context.row] = emitter;
+
+        return emitter;
     }
 
     /**
-     * The scene-node row an emitter is attached to (for bone attachment), or the "none" sentinel.
-     * @param {number} index
-     * @returns {number}
+     * Unregister an emitter and free its table row.
+     *
+     * Its particles are not touched here; they carry its generation, the row they will read is
+     * zero-filled (or a later tenant's, with a different generation), and the simulate pass frees
+     * them the next time it sees them. Retiring an emitter gently — spawn rate to zero, remove once
+     * its particles have died — remains available to an author who wants the tail to play out.
+     *
+     * The emitter itself comes out of this unchanged: what it loses is its context, which is
+     * everything being registered gave it. Its program goes with the context — the heap counts
+     * references, so an effect is only unpacked when its last emitter leaves.
+     *
+     * @param {ParticleEmitter} emitter
+     */
+    remove(emitter) {
+        assert.defined(emitter, 'emitter');
+        assert.equal(emitter.isParticleEmitter, true, 'emitter.isParticleEmitter !== true');
+
+        const context = this.#contexts.get(emitter);
+
+        assert.defined(context, 'emitter is not registered here');
+
+        const position = this.emitters.indexOf(emitter);
+
+        // Swap-remove: order carries no meaning, and a splice would allocate.
+        const last = this.emitters.pop();
+
+        if (last !== emitter) {
+            this.emitters[position] = last;
+        }
+
+        this.by_row[context.row] = undefined;
+        this.table.remove(context.row);
+        this.state_table.remove(context.row);
+
+        this.programs.release(context.placement);
+
+        context.placement = null;
+
+        this.#contexts.delete(emitter);
+    }
+
+    /**
+     * Give a registered emitter different bytecode to run: its old program loses a reference, the new
+     * one gains one, and its row is restaged with the new placement.
+     *
+     * This is the runtime edit the emitter table has always allowed and the program buffer used not
+     * to — an author reworking an effect in the editor changes the program of an emitter that is
+     * already live, and the effect it used to run goes away with the last emitter that ran it.
+     *
+     * The attribute {@link ../layout/ParticleLayout.js layout} is NOT part of this and must not
+     * change with it: particles already in flight are laid out the old way, and new bytecode reading
+     * them at new offsets would read somebody else's field. Re-laying-out an effect means new
+     * emitters.
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
+     */
+    set_program(emitter, program) {
+        assert.defined(program, 'program');
+
+        const context = this.#contexts.get(emitter);
+
+        assert.defined(context, 'emitter is not registered here');
+
+        const previous = context.placement;
+
+        // acquired before the old one is let go, so that re-setting the program an emitter already
+        // runs — which is what an editor does on every keystroke that changes nothing — neither
+        // unpacks it nor gives it a new id
+        context.placement = this.programs.acquire(program);
+
+        emitter.program = program;
+
+        this.programs.release(previous);
+
+        context.invalidate();
+    }
+
+    /**
+     * Look up a live emitter by its table row.
+     *
+     * @param {number} row
+     * @returns {ParticleEmitter|undefined}
+     */
+    get(row) {
+        return this.by_row[row];
+    }
+
+    /**
+     * Point an emitter's record at its node's row in the scene's `transforms` table. The row is
+     * restaged on the next flush.
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {number} transform_row
      */
-    attachRow(index) {
-        return this.emitters[index]?.attach_row ?? EMITTER_ATTACH_NONE;
+    set_transform_row(emitter, transform_row) {
+        assert.isNonNegativeInteger(transform_row, 'transform_row');
+
+        const context = this.#contexts.get(emitter);
+
+        assert.defined(context, 'emitter is not registered here');
+
+        if (context.transform_row === transform_row) {
+            return;
+        }
+
+        context.transform_row = transform_row;
+        context.invalidate();
+    }
+
+    /**
+     * Point an emitter's record at the patch its texture was packed into: uv offset `.xy`, uv scale
+     * `.zw`. The row is restaged on the next flush.
+     *
+     * For whoever owns the atlas to call, on registration and again after every repack — a repack
+     * moves every patch, and an emitter left holding the old one draws the wrong image.
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {ArrayLike<number>} region [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
+     */
+    set_atlas_region(emitter, region) {
+        assert.equal(region.length, 4, 'region.length');
+
+        const context = this.#contexts.get(emitter);
+
+        assert.defined(context, 'emitter is not registered here');
+
+        const atlas_region = context.atlas_region;
+
+        if (
+            atlas_region[0] === region[0] && atlas_region[1] === region[1]
+            && atlas_region[2] === region[2] && atlas_region[3] === region[3]
+        ) {
+            return;
+        }
+
+        atlas_region.set(region);
+        context.invalidate();
+    }
+
+    /**
+     * Restage the table rows of every emitter whose fields have moved since the last flush.
+     *
+     * "Moved" is the node's own change counter: an emitter is restaged when its
+     * {@link ../../scene/Node3D.js Node3D#version} is not the one its row was staged from, or when
+     * something in its context changed. So an author marks an edited emitter the way they mark any
+     * edited node, with `needsUpdate = true`, and there is no second flag to forget.
+     *
+     * Cheap to call every frame: an emitter that has not changed costs one integer comparison, and
+     * the table coalesces repeated writes to one row within a frame anyway. Walks the context map
+     * rather than the emitter list so that a pass over the set is not also a lookup per emitter.
+     * Stages through the one module-static record, so a frame's restaging allocates nothing however
+     * many rows it touches.
+     */
+    flush() {
+        const table = this.table;
+
+        const placement_version = this.programs.placement_version;
+
+        // A repack moved every program that was already placed, so every row holds offsets into
+        // where its code used to be. That is the one change no emitter announces — it is not an edit
+        // to any of them — so it is asked of the heap once here rather than pushed onto each context.
+        const relocated = placement_version !== this.#staged_placement_version;
+
+        this.#staged_placement_version = placement_version;
+
+        for (const [emitter, context] of this.#contexts) {
+            if (!relocated && !context.is_stale(emitter)) {
+                continue;
+            }
+
+            table.set(context.row, write_emitter_record(RECORD, emitter, context));
+            context.staged(emitter);
+        }
+    }
+
+    /**
+     * The packed program buffer — header, constant pools, code — rebuilt whole.
+     *
+     * Call when {@link programs_dirty}; it answers the flag. The buffer is monolithic (a program is
+     * variable-length, so there is no table to page it into), so this is a full rebuild — the heap's
+     * content deduplication is what keeps it rare (it changes only when an effect the set has never
+     * seen is registered, or when the sections are repacked to make room for one).
+     *
+     * @returns {Uint32Array}
+     */
+    build_program() {
+        this.#built_programs_version = this.programs.version;
+
+        return this.programs.build_buffer();
     }
 }

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

@@ -0,0 +1,109 @@
+/**
+ * Everything the GPU side knows about one {@link ./ParticleEmitter.js} that the emitter itself has
+ * no business knowing.
+ *
+ * An emitter is a scene node and a description of an effect: what to run, how fast, how big, which
+ * attribute is the colour. None of that depends on a device. The rest — which row of the emitter
+ * table it was given, which tenancy of that row it is, where its program was placed in the program
+ * heap, which `transforms` row its node ended up in, where its texture was packed into the atlas —
+ * is the particle system's bookkeeping, true only while the emitter is registered and only for the
+ * registry that registered it. Kept on the emitter it would travel with a saved effect, mean
+ * nothing when loaded, and be there for an author to set to a number the table has never heard of.
+ *
+ * So it lives here, in an object the registry owns and hands out ({@link ./EmitterRegistry.js#context}),
+ * and an emitter that no registry holds simply has none. That is also what makes "is this emitter
+ * live?" a question with one answer — the presence of a context — rather than a `row` of `-1` that
+ * anything could have written.
+ *
+ * Fields are set by the registry. Reading them is what a caller wants (the spawn ring addresses an
+ * emitter by row, a spec reads the generation a particle header should carry); writing them outside
+ * of {@link ./EmitterRegistry.js} desynchronises the context from the table it describes.
+ */
+export class GPUParticleEmitterContext {
+    /**
+     * Row this emitter occupies in the emitter table. Stable for as long as the emitter is
+     * registered — it is what every live particle's record header stores, so it cannot be
+     * renumbered while particles are in flight.
+     *
+     * Not to be confused with {@link ./ParticleEmitter.js Node3D#id}, which is the node's own
+     * identity and the key the scene context maps to a `transforms` row.
+     *
+     * @type {number}
+     */
+    row: number;
+    /**
+     * Which tenancy of {@link row} this is. Distinct from every other the registry has ever handed
+     * out, and never zero. Stamped into every particle the emitter spawns, and what lets the
+     * simulate pass tell those particles from a later tenant's.
+     *
+     * @type {number}
+     */
+    generation: number;
+    /**
+     * Row of the scene database's `transforms` table the emitter's node occupies, as the scene
+     * context reported it — what the record's `node` field carries. `0` (the scene root) until
+     * bound, so an emitter registered before its node is placed still reads a valid row.
+     *
+     * @type {number}
+     */
+    transform_row: number;
+    /**
+     * Where this emitter's program sits in the shared {@link ./ProgramHeap.js}, and the program id
+     * the simulation-order bucketing keys on. Emitters compiled from the same graph hold the same
+     * object — which is also why it is held rather than copied out: the heap rewrites its offsets in
+     * place when it moves the program.
+     *
+     * @type {import("./ProgramPlacement.js").ProgramPlacement|null}
+     */
+    placement: import("./ProgramPlacement.js").ProgramPlacement | null;
+    /**
+     * Where {@link ./ParticleEmitter.js#texture} landed in the particle system's atlas: uv offset
+     * `.xy`, uv scale `.zw`. Mirrors meep's `AtlasPatch`.
+     *
+     * Resolved, never authored. The emitter names an image; which sheet it is packed into and where
+     * is the system's answer, and it changes without the emitter changing — a repack moves every
+     * patch. `[0, 0, 1, 1]` is the whole sheet, which is what an emitter with no texture of its own
+     * gets: the default atlas is a single white texel.
+     *
+     * @type {Float32Array}
+     */
+    atlas_region: Float32Array;
+    /**
+     * The emitter's {@link ../../scene/Node3D.js Node3D#version} as of the last time its row was
+     * staged, or `-1` for a row that must be restaged whatever the emitter says.
+     *
+     * This is the whole of the dirty tracking: {@link ./EmitterRegistry.js#flush} restages an
+     * emitter whose version has moved since. A node already counts its own changes for the
+     * renderer, and a second flag on the emitter saying the same thing would be one more thing to
+     * forget to set — so the emitter carries none, and an author who changes a field marks it the
+     * way they mark any node change, with `needsUpdate = true`.
+     *
+     * The version is the node's, so it also moves when the node merely moves, and the row is
+     * restaged for a change it does not hold. That costs one row: an emitter that moved is an
+     * emitter whose `transforms` row the scene context is uploading this frame anyway.
+     *
+     * A version of `-1` is unreachable for a node — the counter starts at 0 and only rises — so it
+     * is safe as the "not staged" sentinel, and it is what the fields above are set back to when
+     * one of *them* changes, since those move without the emitter moving.
+     *
+     * @type {number}
+     */
+    staged_version: number;
+    /**
+     * @param {import("./ParticleEmitter.js").ParticleEmitter} emitter the emitter this describes
+     * @returns {boolean} whether the table row is out of step with `emitter`
+     */
+    is_stale(emitter: import("./ParticleEmitter.js").ParticleEmitter): boolean;
+    /**
+     * Mark the row as needing to be restaged on the next flush, for a change the emitter's version
+     * does not record — one of this context's own fields.
+     */
+    invalidate(): void;
+    /**
+     * Record that the table row now holds `emitter` as it currently is.
+     *
+     * @param {import("./ParticleEmitter.js").ParticleEmitter} emitter
+     */
+    staged(emitter: import("./ParticleEmitter.js").ParticleEmitter): void;
+}
+//# sourceMappingURL=GPUParticleEmitterContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GPUParticleEmitterContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/GPUParticleEmitterContext.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;;;;;;OASG;IACH,KAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;OAOG;IACH,WAFU,OAAO,uBAAuB,EAAE,gBAAgB,GAAC,IAAI,CAE9C;IAEjB;;;;;;;;;;OAUG;IACH,cAFU,YAAY,CAEwB;IAE9C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,kBAHW,OAAO,sBAAsB,EAAE,eAAe,GAC5C,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;;OAIG;IACH,gBAFW,OAAO,sBAAsB,EAAE,eAAe,QAMxD;CACJ"}