@woosh/meep-engine 3.16.0 → 3.17.1

package/src/shade/renderer/particles/optimizer/pass_schedule.js

@@ -0,0 +1,244 @@
+import { decode_particle_instructions, particle_peak_live_slots, particle_read_slots } from "./particle_program_analysis.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_SCHEDULE = "schedule";
+
+/**
+ * Reorder the instructions so that fewer values are alive at once.
+ *
+ * A frontend lowers in whatever order it visits, and the node compiler's order is the graph's: a
+ * constant is loaded where the graph mentions it and a corner offset is computed alongside the
+ * others, both a long way above their one consumer. Every instruction in between then carries that
+ * value in the file. The register allocator can only reuse slots whose values have died, so a
+ * value that lives longer than it needs to is a slot the allocator cannot give back — the
+ * curl-noise effect held a vec4 across seventy instructions this way.
+ *
+ * ## What may be reordered
+ *
+ * Straight-line code has three hazards per slot — a read must follow the write it reads, a write
+ * must follow the reads of the value it replaces, and two writes keep their order — and the
+ * schedule keeps every one of them, so the sequence of writes and reads of each slot is the one the
+ * program had. Instructions with side effects are barriers: nothing crosses a draw, a store, a kill
+ * or a halt in either direction, and they keep their order among themselves. That is stricter than
+ * a pure instruction crossing a store needs, and it is what keeps the ordering promises of
+ * `optimize_particle_program.js` — the draw sequence, attribute aliasing — structural for this pass
+ * as for every other.
+ *
+ * ## How the order is chosen
+ *
+ * Backwards, one instruction at a time, from the set whose consumers are all already placed: the
+ * one whose placement leaves the fewest slots alive above it, which is the one that frees the most
+ * of what it writes against what it reads. Ties go to the instruction that came last in the program
+ * as it was, so an order that is already as good as this greedy can make it comes back unchanged —
+ * and the schedule is kept only when its peak is strictly lower than the program's, so the pass is
+ * a fixed point of itself and never makes a program worse by the one measure it is for.
+ *
+ * It is a greedy, and a greedy can be fooled; the differential harness holds it to bit-identity
+ * whatever order it picks, and the peak is measured rather than assumed.
+ *
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_schedule(instructions, context) {
+    const decoded = decode_particle_instructions(instructions);
+    const slots = context.register_slots;
+    const order = schedule(decoded, slots);
+
+    if (order === null) {
+        return null;
+    }
+
+    const scheduled = order.map(index => decoded[index]);
+
+    if (particle_peak_live_slots(scheduled, slots) >= particle_peak_live_slots(decoded, slots)) {
+        return null;
+    }
+
+    return order.map(index => instructions[index]);
+}
+
+/**
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
+ * @param {number} slots size of the register file
+ * @returns {number[]|null} instruction indices in their new order, or `null` when an operand
+ *   reaches outside the file
+ */
+function schedule(decoded, slots) {
+    const count = decoded.length;
+    const predecessors = build_dependencies(decoded, slots);
+
+    if (predecessors === null) {
+        return null;
+    }
+
+    /** @type {Int32Array} per instruction, how many of its dependents are still unplaced */
+    const pending = new Int32Array(count);
+
+    for (let i = 0; i < count; i++) {
+        for (const predecessor of predecessors[i]) {
+            pending[predecessor]++;
+        }
+    }
+
+    /** @type {Set<number>} instructions whose dependents are all placed */
+    const ready = new Set();
+
+    for (let i = 0; i < count; i++) {
+        if (pending[i] === 0) {
+            ready.add(i);
+        }
+    }
+
+    /** @type {Uint8Array} slots alive just above the instructions placed so far */
+    const live = new Uint8Array(slots);
+    /** @type {Uint8Array} scratch for scoring a candidate */
+    const trial = new Uint8Array(slots);
+    /** @type {number[]} placed instructions, last first */
+    const reversed = [];
+
+    while (reversed.length < count) {
+        let best = -1;
+        let best_live = Infinity;
+
+        for (const candidate of ready) {
+            const alive = live_above(decoded[candidate], live, trial);
+
+            if (alive < best_live || (alive === best_live && candidate > best)) {
+                best = candidate;
+                best_live = alive;
+            }
+        }
+
+        live_above(decoded[best], live, trial);
+        live.set(trial);
+        reversed.push(best);
+        ready.delete(best);
+
+        for (const predecessor of predecessors[best]) {
+            if (--pending[predecessor] === 0) {
+                ready.add(predecessor);
+            }
+        }
+    }
+
+    return reversed.reverse();
+}
+
+/**
+ * The slots alive just above an instruction, given those alive just below it: what it reads, plus
+ * whatever was alive that it does not write.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
+ * @param {Uint8Array} below
+ * @param {Uint8Array} above written here
+ * @returns {number} how many
+ */
+function live_above(instruction, below, above) {
+    above.set(below);
+
+    if (instruction.write !== null) {
+        for (let lane = 0; lane < instruction.write.span; lane++) {
+            above[instruction.write.base + lane] = 0;
+        }
+    }
+
+    for (const read of instruction.reads) {
+        for (const slot of particle_read_slots(read)) {
+            above[slot] = 1;
+        }
+    }
+
+    let alive = 0;
+
+    for (let slot = 0; slot < above.length; slot++) {
+        alive += above[slot];
+    }
+
+    return alive;
+}
+
+/**
+ * Per instruction, the instructions it must come after.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
+ * @param {number} slots
+ * @returns {Set<number>[]|null} `null` when an operand reaches outside the file
+ */
+function build_dependencies(decoded, slots) {
+    const predecessors = decoded.map(() => new Set());
+    /** @type {Int32Array} per slot, the last instruction to write it */
+    const writer = new Int32Array(slots).fill(-1);
+    /** @type {number[][]} per slot, the instructions that read its current value */
+    const readers = Array.from({ length: slots }, () => []);
+
+    let barrier = -1;
+
+    for (let i = 0; i < decoded.length; i++) {
+        const instruction = decoded[i];
+        const read_slots = new Set();
+
+        for (const read of instruction.reads) {
+            for (const slot of particle_read_slots(read)) {
+                if (slot < 0 || slot >= slots) {
+                    return null;
+                }
+
+                read_slots.add(slot);
+            }
+        }
+
+        // After the write it reads.
+        for (const slot of read_slots) {
+            if (writer[slot] >= 0) {
+                predecessors[i].add(writer[slot]);
+            }
+        }
+
+        const write = instruction.write;
+
+        if (write !== null) {
+            if (write.base + write.span > slots) {
+                return null;
+            }
+
+            // After the previous write, and after every read of the value it replaces.
+            for (let lane = 0; lane < write.span; lane++) {
+                const slot = write.base + lane;
+
+                if (writer[slot] >= 0) {
+                    predecessors[i].add(writer[slot]);
+                }
+
+                for (const reader of readers[slot]) {
+                    predecessors[i].add(reader);
+                }
+            }
+        }
+
+        for (const slot of read_slots) {
+            readers[slot].push(i);
+        }
+
+        if (write !== null) {
+            for (let lane = 0; lane < write.span; lane++) {
+                writer[write.base + lane] = i;
+                readers[write.base + lane] = [];
+            }
+        }
+
+        // A barrier comes after everything above it — the previous barrier included, since two of
+        // them may be adjacent — and everything below it comes after it.
+        if (instruction.semantics.side_effects) {
+            for (let j = Math.max(barrier, 0); j < i; j++) {
+                predecessors[i].add(j);
+            }
+
+            barrier = i;
+        } else if (barrier >= 0) {
+            predecessors[i].add(barrier);
+        }
+
+        predecessors[i].delete(i);
+    }
+
+    return predecessors;
+}

package/src/shade/renderer/particles/optimizer/pass_share_subexpressions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pass_share_subexpressions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_share_subexpressions.js"],"names":[],"mappings":"AA0E6E,4JAGoC;AAtEjH,qBAAqB;AACrB,iDADW,MAAM,CACwD"}
+{"version":3,"file":"pass_share_subexpressions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_share_subexpressions.js"],"names":[],"mappings":"AA8GU,4JAM8C;AA7GxD,qBAAqB;AACrB,iDADW,MAAM,CACwD"}

package/src/shade/renderer/particles/optimizer/pass_share_subexpressions.js

@@ -1,151 +1,154 @@
-import { VM_OP, VM_OPERAND, vm_dest_width, vm_encode_word0 } from "../isa/ParticleVMISA.js";
-import {
-    ParticleValueNumbering,
-    decode_particle_instructions,
-    particle_instruction_is_well_formed,
-} from "./particle_program_analysis.js";
-
-/** @type {string} */
-export const PARTICLE_PASS_SHARE_SUBEXPRESSIONS = "share_subexpressions";
-
-/**
- * Recognise an instruction that recomputes something a register already holds, and read the register
- * instead.
- *
- * Two executions of a shareable opcode over equal operands produce equal results, so the second is
- * a copy of the first — and where the two write the same register, it is not even that: the register
- * already holds the answer and the instruction goes entirely.
- *
- * Equality is by value number rather than by register: the same expression computed from registers
- * that have since been copied about still matches, and a register overwritten since fails the match
- * without any separate invalidation. It is the machinery `pass_propagate_copies` uses, asked a
- * different question.
- *
- * ## What is not shared
- *
- * `LOAD_ATTR` reads the record, which a `STORE_ATTR` in between may have changed, and `RANDOM` reads
- * the RNG, which every draw changes. Neither is shareable, so neither is ever considered here — the
- * `shareable` column of {@link ./particle_vm_semantics.js} is the whole of the rule, which is what
- * keeps the aliasing question from having to be answered a second time in this file.
- *
- * `ADD`, `MUL` and `CMP_EQ` match with their operands either way round. `MIN` and `MAX` do not,
- * although they look just as commutative: `min(-0, 0)` and `min(0, -0)` are different registers'
- * worth of zero, and the record is compared to the bit.
- *
- * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
- */
-export function pass_share_subexpressions(instructions, context) {
-    const decoded = decode_particle_instructions(instructions);
-    const values = new ParticleValueNumbering(context.register_slots);
-
-    /** @type {Map<string, {base: number, ids: number[]}>} expression -> where its result was left */
-    const available = new Map();
-
-    /** @type {number[][]} */
-    const out = [];
-
-    let changed = false;
-
-    for (const instruction of decoded) {
-        const span = instruction.write === null ? 0 : vm_dest_width(instruction.op, instruction.width);
-        const key = is_shareable(instruction) && span > 0 ? expression_key(instruction, values) : null;
-        const previous = key === null ? undefined : available.get(key);
-
-        let shared = false;
-
-        if (previous !== undefined && values.holds(previous.base, previous.ids)) {
-            const replacement = share(instruction, previous, span);
-
-            if (replacement !== null) {
-                for (const words of replacement) {
-                    out.push(words);
-                    values.publish(words);
-                }
-
-                shared = true;
-                changed = true;
-            }
-        }
-
-        if (!shared) {
-            out.push(instruction.words);
-            values.publish(instruction.words);
-        }
-
-        // Recorded after the write, so an expression that overwrites one of its own sources names
-        // the register as it stands once the instruction has run.
-        if (key !== null && !shared) {
-            available.set(key, { base: instruction.write.base, ids: values.ids_of(instruction.write.base, span) });
-        }
-    }
-
-    return changed ? out : null;
-}
-
-/**
- * `MOV` is shareable in the sense the semantics table means, but it is not shared here: replacing
- * one copy with another copy is no gain, and `pass_propagate_copies` — which reads THROUGH copies —
- * would immediately rewrite the result back, leaving the two passes trading the same instruction
- * between them for as many sweeps as they are given.
- *
- * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
- * @returns {boolean}
- */
-function is_shareable(instruction) {
-    return instruction.semantics.shareable && instruction.op !== VM_OP.MOV;
-}
-
-/** Opcodes whose two register operands may be matched either way round. */
-const COMMUTATIVE = new Set([VM_OP.ADD, VM_OP.MUL, VM_OP.CMP_EQ]);
-
-/**
- * What makes two executions the same one: the opcode, the width, every immediate, and the value
- * numbers behind every lane an operand reads.
- *
- * @returns {string|null} `null` when an operand reaches outside the file, which is nothing to match
- */
-function expression_key(instruction, values) {
-    /** @type {Map<number, string>} */
-    const operands = new Map();
-
-    for (const read of instruction.reads) {
-        const ids = values.ids_of(read.base, read.span);
-
-        if (ids === null) {
-            return null;
-        }
-
-        operands.set(read.operand, ids.join(","));
-    }
-
-    /** @type {string[]} */
-    const parts = [];
-
-    for (let slot = 0; slot < 3; slot++) {
-        parts.push(
-            instruction.meta.operands[slot] === VM_OPERAND.REG
-                ? `r${operands.get(slot)}`
-                : `i${instruction.words[2 + slot]}`
-        );
-    }
-
-    if (COMMUTATIVE.has(instruction.op)) {
-        parts.sort();
-    }
-
-    return `${instruction.op}.${instruction.width}|${parts.join("|")}`;
-}
-
-/**
- * @returns {number[][]|null} what to emit instead — nothing at all when the result is already in the
- *   destination, otherwise a copy of it — or `null` when the copy would not be a legal instruction
- */
-function share(instruction, previous, span) {
-    if (previous.base === instruction.write.base) {
-        return [];
-    }
-
-    const words = [vm_encode_word0(VM_OP.MOV, span), instruction.write.base, previous.base, 0, 0];
-
-    return particle_instruction_is_well_formed(words) ? [words] : null;
-}
+import { VM_KIND, VM_OP, vm_dest_width, vm_pack_instruction } from "../isa/ParticleVMISA.js";
+import {
+    ParticleValueNumbering,
+    decode_particle_instructions,
+    particle_instruction_is_well_formed,
+} from "./particle_program_analysis.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_SHARE_SUBEXPRESSIONS = "share_subexpressions";
+
+/**
+ * Recognise an instruction that recomputes something a register already holds, and read the register
+ * instead.
+ *
+ * Two executions of a shareable opcode over equal operands produce equal results, so the second is
+ * a copy of the first — and where the two write the same register, it is not even that: the register
+ * already holds the answer and the instruction goes entirely.
+ *
+ * Equality is by value number rather than by register: the same expression computed from registers
+ * that have since been copied about still matches, and a register overwritten since fails the match
+ * without any separate invalidation. It is the machinery `pass_propagate_copies` uses, asked a
+ * different question. A register operand contributes the numbers of the lanes it reads, through its
+ * swizzle, so `r0.xxx` and `r4.yyy` match when r0 and r5 hold the same value; a literal contributes
+ * itself.
+ *
+ * ## What is not shared
+ *
+ * `LOAD_ATTR` reads the record, which a `STORE_ATTR` in between may have changed, and `RANDOM` reads
+ * the RNG, which every draw changes. Neither is shareable, so neither is ever considered here — the
+ * `shareable` column of {@link ./particle_vm_semantics.js} is the whole of the rule, which is what
+ * keeps the aliasing question from having to be answered a second time in this file.
+ *
+ * `ADD`, `MUL` and `CMP_EQ` match with their operands either way round. `MIN` and `MAX` do not,
+ * although they look just as commutative: `min(-0, 0)` and `min(0, -0)` are different registers'
+ * worth of zero, and the record is compared to the bit.
+ *
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_share_subexpressions(instructions, context) {
+    const decoded = decode_particle_instructions(instructions);
+    const values = new ParticleValueNumbering(context.register_slots);
+
+    /** @type {Map<string, {base: number, ids: number[]}>} expression -> where its result was left */
+    const available = new Map();
+
+    /** @type {number[][]} */
+    const out = [];
+
+    let changed = false;
+
+    for (const instruction of decoded) {
+        const span = instruction.write === null ? 0 : vm_dest_width(instruction.op, instruction.width);
+        const key = is_shareable(instruction) && span > 0 ? expression_key(instruction, values) : null;
+        const previous = key === null ? undefined : available.get(key);
+
+        let shared = false;
+
+        if (previous !== undefined && values.holds(previous.base, previous.ids)) {
+            const replacement = share(instruction, previous, span);
+
+            if (replacement !== null) {
+                for (const words of replacement) {
+                    out.push(words);
+                    values.publish(words);
+                }
+
+                shared = true;
+                changed = true;
+            }
+        }
+
+        if (!shared) {
+            out.push(instruction.words);
+            values.publish(instruction.words);
+        }
+
+        // Recorded after the write, so an expression that overwrites one of its own sources names
+        // the register as it stands once the instruction has run.
+        if (key !== null && !shared) {
+            available.set(key, { base: instruction.write.base, ids: values.ids_of(instruction.write.base, span) });
+        }
+    }
+
+    return changed ? out : null;
+}
+
+/**
+ * `MOV` is shareable in the sense the semantics table means, but it is not shared here: replacing
+ * one copy with another copy is no gain, and `pass_propagate_copies` — which reads THROUGH copies —
+ * would immediately rewrite the result back, leaving the two passes trading the same instruction
+ * between them for as many sweeps as they are given.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
+ * @returns {boolean}
+ */
+function is_shareable(instruction) {
+    return instruction.semantics.shareable && instruction.op !== VM_OP.MOV;
+}
+
+/** Opcodes whose two register operands may be matched either way round. */
+const COMMUTATIVE = new Set([VM_OP.ADD, VM_OP.MUL, VM_OP.CMP_EQ]);
+
+/**
+ * What makes two executions the same one: the opcode, the width, every raw field, and per source
+ * either the value numbers behind the lanes it reads or the literal it is.
+ *
+ * @returns {string|null} `null` when an operand reaches outside the file, which is nothing to match
+ */
+function expression_key(instruction, values) {
+    /** @type {string[]} */
+    const parts = [];
+
+    for (let slot = 0; slot < 3; slot++) {
+        const source = instruction.sources.find(candidate => candidate.operand === slot);
+
+        if (source === undefined) {
+            parts.push(`i${instruction.words[1 + slot]}`);
+        } else if (source.kind === VM_KIND.IMM) {
+            parts.push(`#${source.word}`);
+        } else {
+            const ids = values.ids_read(source);
+
+            if (ids === null) {
+                return null;
+            }
+
+            parts.push(`r${ids.join(",")}`);
+        }
+    }
+
+    if (COMMUTATIVE.has(instruction.op)) {
+        parts.sort();
+    }
+
+    return `${instruction.op}.${instruction.width}|${parts.join("|")}`;
+}
+
+/**
+ * @returns {number[][]|null} what to emit instead — nothing at all when the result is already in the
+ *   destination, otherwise a copy of it — or `null` when the copy would not be a legal instruction
+ */
+function share(instruction, previous, span) {
+    if (previous.base === instruction.write.base) {
+        return [];
+    }
+
+    const words = vm_pack_instruction(
+        VM_OP.MOV, span, instruction.write.base,
+        [VM_KIND.REG, VM_KIND.NONE, VM_KIND.NONE],
+        [previous.base, 0, 0]
+    );
+
+    return particle_instruction_is_well_formed(words) ? [words] : null;
+}

package/src/shade/renderer/particles/particle_test_fixtures.d.ts

@@ -32,6 +32,26 @@ export function particle_scene_fixture(): ParticleSceneFixture;
  * @returns {ParticleEmitter}
  */
 export function place_emitter(fixture: ParticleSceneFixture, config: ParticleEmitter | object, parent?: import("../scene/Node3D.js").Node3D): ParticleEmitter;
+/**
+ * What the fixture's registry assigned an emitter: its table row, its generation, the heap
+ * placement of its program, the atlas patch. The emitter carries none of it — see
+ * {@link ./runtime/GPUParticleEmitterContext.js} — so a spec that wants the row a particle header
+ * should carry asks the registry, the way the passes' own callers do.
+ *
+ * @param {ParticleSceneFixture} fixture
+ * @param {ParticleEmitter} emitter
+ * @returns {import("./runtime/GPUParticleEmitterContext.js").GPUParticleEmitterContext}
+ */
+export function emitter_context(fixture: ParticleSceneFixture, emitter: ParticleEmitter): import("./runtime/GPUParticleEmitterContext.js").GPUParticleEmitterContext;
+/**
+ * The emitter table row an emitter was given — {@link emitter_context}`.row`, which specs index
+ * per-emitter buffers with often enough to be worth naming.
+ *
+ * @param {ParticleSceneFixture} fixture
+ * @param {ParticleEmitter} emitter
+ * @returns {number}
+ */
+export function emitter_row(fixture: ParticleSceneFixture, emitter: ParticleEmitter): number;
 /**
  * The two databases as the `array<u32>` buffers the particle shaders bind. Call after the last
  * change to either; it flushes both.

package/src/shade/renderer/particles/particle_test_fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_test_fixtures.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AACH,0CAFa,oBAAoB,CAUhC;AAED;;;;;;;;GAQG;AACH,uCALW,oBAAoB,UACpB,eAAe,GAAC,MAAM,WACtB,OAAO,oBAAoB,EAAE,MAAM,GACjC,eAAe,CAkB3B;AAED;;;;;;GAMG;AACH,iDAHW,oBAAoB,GAClB;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,gBAAgB,EAAE,WAAW,CAAA;CAAC,CAUxE;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,SACN,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AAED;;;;GAIG;AACH,qCAFa;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AA2BD;;;;;;GAMG;AACH,qDAJW,WAAW,OACX,MAAM,GACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAalG;AAED;;;;;;;GAOG;AACH,sDAJW,WAAW,OACX,MAAM,UACN;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,QAWrG;AAED;;;;;;;GAOG;AACH,sCAJW,MAAM,aACN,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAIlD;AAED;;;;;;GAMG;AACH,2CAHW;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,GACpC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAWlD;;YAlLa,iBAAiB;cACjB,eAAe;WACf,KAAK;mBACL,OAAO,6BAA6B,EAAE,eAAe;cACrD,eAAe;;gCAnBG,8BAA8B;kCAT5B,wCAAwC;gCAC1C,uBAAuB;sBAEjC,mBAAmB;gCAKT,8BAA8B"}
+{"version":3,"file":"particle_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/particle_test_fixtures.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AACH,0CAFa,oBAAoB,CAUhC;AAED;;;;;;;;GAQG;AACH,uCALW,oBAAoB,UACpB,eAAe,GAAC,MAAM,WACtB,OAAO,oBAAoB,EAAE,MAAM,GACjC,eAAe,CAkB3B;AAED;;;;;;;;;GASG;AACH,yCAJW,oBAAoB,WACpB,eAAe,GACb,OAAO,wCAAwC,EAAE,yBAAyB,CAItF;AAED;;;;;;;GAOG;AACH,qCAJW,oBAAoB,WACpB,eAAe,GACb,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iDAHW,oBAAoB,GAClB;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,gBAAgB,EAAE,WAAW,CAAA;CAAC,CAUxE;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,SACN,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AAED;;;;GAIG;AACH,qCAFa;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,EAAE,CAI7B;AA2BD;;;;;;GAMG;AACH,qDAJW,WAAW,OACX,MAAM,GACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAalG;AAED;;;;;;;GAOG;AACH,sDAJW,WAAW,OACX,MAAM,UACN;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,QAWrG;AAED;;;;;;;GAOG;AACH,sCAJW,MAAM,aACN,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAIlD;AAED;;;;;;GAMG;AACH,2CAHW;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,GACpC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAC,CAWlD;;YA5Ma,iBAAiB;cACjB,eAAe;WACf,KAAK;mBACL,OAAO,6BAA6B,EAAE,eAAe;cACrD,eAAe;;gCAnBG,8BAA8B;kCAT5B,wCAAwC;gCAC1C,uBAAuB;sBAEjC,mBAAmB;gCAKT,8BAA8B"}