@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/particles/optimizer/dag/particle_vector_graph.js

@@ -0,0 +1,334 @@
+import { assert } from "../../../../../core/assert.js";
+import { uf_find, uf_union } from "../../../../../core/collection/union-find/union_find.js";
+import { VM_MAX_WIDTH, VM_OP, vm_f32_bits, vm_f32_value } from "../../isa/ParticleVMISA.js";
+import { particle_integer_bound_of_operation, particle_integer_bound_of_value } from "../particle_integer_bounds.js";
+
+/**
+ * The value graph, with a VECTOR as the unit.
+ *
+ * There was a version of this graph in which a value was one LANE, so that every rewrite could be
+ * lane-exact. It was measured to be the wrong trade on this machine and retired; this is the answer
+ * to it, and the measurement is kept because the trade is not obvious and someone will want to take
+ * it again. On `curl4` the scalar graph spent 615 of its 3,182 instructions moving values between
+ * registers, against the pass pipeline's 79 of 2,828 — and an instruction is an instruction here, a
+ * `MOV` costing about what a `MAD` does.
+ *
+ * ## Why lane-exactness cost more than it bought
+ *
+ * A frontend emits every value into a RUN of consecutive registers, and every consumer reads it
+ * there. That satisfies the one constraint this ISA puts on an operand — all of its lanes inside one
+ * window of four — everywhere, by construction, for nothing. Scalarising deletes it, and then the
+ * lane-exact sharing it was for finishes the job: of the 1,946 runs `curl4`'s input writes, 636 have
+ * two of their lanes collapse into ONE VALUE under lane-level common-subexpression elimination, so
+ * the shape can never be one instruction again. Sharing merges lanes; merging lanes breaks runs. In a
+ * scalar graph those two are the same act, taken at full strength on every opportunity, and taken in
+ * the lift — below the level at which extraction could have priced it.
+ *
+ * So here a value is a vector of one to four lanes, which is what the machine has, and lane-level
+ * sharing becomes something the optimizer may CHOOSE, with the copy it costs on the bill.
+ *
+ * ## The shape
+ *
+ * A node is an operation, a width, and one operand per source — each naming a value and the swizzle
+ * it reads that value through, exactly as an instruction's source word does. Hash-consing over that
+ * is common-subexpression elimination per instruction, and it can never break a run, because it only
+ * ever merges two whole instructions that were already the same.
+ *
+ * Multi-output operations need no special case: `CROSS` is a node of width three the way the
+ * instruction is. Nor do the reductions, which are nodes of width one.
+ *
+ * `BUILD` is the one node with no instruction behind it — a vector assembled from lanes of several
+ * others, which is what a frontend's `vec4` constructor is and what a load of record words written by
+ * several different stores is. It lowers to one `MOV` per lane, and getting rid of those again is
+ * what the layout stage is for.
+ */
+
+/**
+ * Node kinds with no opcode of their own. Above every {@link VM_OP} number.
+ * @enum {number}
+ */
+export const PV = {
+    /** literals, one per lane; `imm` holds their bit patterns */
+    CONST: 200,
+    /** record words as the section found them; `imm[0]` is the first word, the width says how many */
+    ATTR: 201,
+    /** a vector assembled from one lane of each source; `patterns[i]` is the lane taken from source `i` */
+    BUILD: 202,
+};
+
+/**
+ * @typedef {object} ParticleVectorNode
+ * @property {number} op a {@link VM_OP} or a {@link PV}
+ * @property {number} width lanes the VALUE has, `1..4`
+ * @property {number} operand_width lanes each source is read at, which is the instruction's width
+ *   field. The same as `width` for anything lanewise; three for a `CROSS`, and the operand's own
+ *   width for a reduction, which reads many lanes to write one.
+ * @property {number[]} children the values its sources read, one per source
+ * @property {number[]} patterns per source, the swizzle it reads that value through — or, for
+ *   `BUILD`, the single lane it takes
+ * @property {number[]} imm static fields: literal bits, a record word, a builtin id, a curve handle,
+ *   the first draw of a `RANDOM`
+ */
+
+/**
+ * @callback ParticleVectorRule
+ * @param {ParticleVectorGraph} graph
+ * @param {ParticleVectorNode} node the node about to be built
+ * @returns {number} a class to use instead, or `-1`
+ */
+
+/** Commutative to the bit on every input, so their operands sort — see the scalar graph's note. */
+const COMMUTATIVE = new Set([VM_OP.ADD, VM_OP.MUL]);
+
+export class ParticleVectorGraph {
+    /**
+     * @param {object} [params]
+     * @param {ParticleVectorRule[]} [params.rules]
+     */
+    constructor({ rules = [], share_window = Infinity } = {}) {
+        /** @type {ParticleVectorRule[]} */
+        this.rules = rules;
+        /**
+         * How far back a value may have been computed and still be reused rather than recomputed.
+         *
+         * Sharing is not free on a machine with forty-eight registers. A value computed once and read
+         * a thousand instructions later occupies its run for all of them: `curl3` measures at 57
+         * slots with sharing unbounded and 33 with none — for 1,100 instructions either way. So the
+         * question is never whether to share but WHICH sharings are free, and the pass pipeline
+         * answers it without seeming to think about it: its common-subexpression pass can only reuse
+         * a value still in its register, so it takes the sharing that extends no live range and
+         * recomputes the rest. This is that policy with a number on it, and the number is a rung of
+         * the ladder in `./optimize_particle_program_vector.js` rather than a constant, because how
+         * much sharing a program can afford is a property of the program.
+         *
+         * @type {number}
+         */
+        this.share_window = share_window;
+        /** @type {ParticleVectorNode[]} */
+        this.nodes = [];
+        /** @type {Map<string, number>} */
+        this.interned = new Map();
+        /** @type {number[]} per node, the class it was created as */
+        this.class_of = [];
+        /** @type {Uint32Array} union-find over class ids */
+        this.parent = new Uint32Array(0);
+        /** @type {Map<number, number[]>} per class root, the nodes in it */
+        this.class_nodes = new Map();
+        /** @type {Map<number, number>} per class root, the magnitude bound on the integer it holds */
+        this.class_bound = new Map();
+    }
+
+    /** @returns {number} */
+    get size() {
+        return this.nodes.length;
+    }
+
+    /**
+     * @param {number} id
+     * @returns {number} the class root
+     */
+    find(id) {
+        assert.ok(id >= 0 && id < this.nodes.length, `particle vector graph: no node ${id}`);
+
+        return uf_find(this.parent, this.class_of[id]);
+    }
+
+    /** @param {number} id @returns {ParticleVectorNode} */
+    node(id) {
+        return this.nodes[id];
+    }
+
+    /** @param {number} id @returns {number[]} */
+    members(id) {
+        return this.class_nodes.get(this.find(id));
+    }
+
+    /** @param {number} id @returns {number} */
+    width_of(id) {
+        return this.node(this.find(id)).width;
+    }
+
+    /** @param {number} id @returns {number} */
+    bound_of(id) {
+        return this.class_bound.get(this.find(id)) ?? Infinity;
+    }
+
+    /**
+     * The literal a value is, lane by lane — `null` where it is not one.
+     *
+     * @param {number} id
+     * @returns {number[]|null}
+     */
+    constants_of(id) {
+        for (const member of this.members(id)) {
+            if (this.nodes[member].op === PV.CONST) {
+                return this.nodes[member].imm.map(bits => vm_f32_value(bits));
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * The literal one lane of a value is.
+     *
+     * @param {number} id
+     * @param {number} lane
+     * @returns {number|null}
+     */
+    constant_at(id, lane) {
+        const values = this.constants_of(id);
+
+        return values === null || lane >= values.length ? null : values[lane];
+    }
+
+    /**
+     * A vector of literals.
+     *
+     * @param {...number} values one per lane, at least one
+     * @returns {number} a class
+     */
+    constant(...values) {
+        return this.make({
+            op: PV.CONST,
+            width: values.length,
+            children: [],
+            patterns: [],
+            imm: values.map(value => vm_f32_bits(value)),
+        });
+    }
+
+    /**
+     * Build a value — or find the one that already means this, or the better one a rule knows.
+     *
+     * @param {Partial<ParticleVectorNode>} shape
+     * @returns {number} a class
+     */
+    make({ op, width = 1, operand_width = width, children = [], patterns = [], imm = [] }) {
+        assert.ok(width >= 1 && width <= VM_MAX_WIDTH, `particle vector graph: width ${width}`);
+
+        const node = {
+            op,
+            width,
+            operand_width,
+            children: children.map(child => this.find(child)),
+            patterns: patterns.slice(),
+            imm: imm.slice(),
+        };
+
+        // Sorting a commutative operation's operands is what makes `a + b` and `b + a` one node. The
+        // swizzle travels with the operand, so the pair moves together.
+        if (COMMUTATIVE.has(op) && node.children.length === 2
+            && (node.children[0] > node.children[1]
+                || (node.children[0] === node.children[1] && node.patterns[0] > node.patterns[1]))) {
+            node.children.reverse();
+            node.patterns.reverse();
+        }
+
+        for (const rule of this.rules) {
+            const replacement = rule(this, node);
+
+            if (replacement >= 0) {
+                return this.find(replacement);
+            }
+        }
+
+        const key = `${node.op}|${node.width}|${node.operand_width}`
+            + `|${node.children.join(",")}|${node.patterns.join(",")}|${node.imm.join(",")}`;
+        const existing = this.interned.get(key);
+
+        // A literal is not a live range: it costs an operand or a pool word, so it is always shared.
+        if (existing !== undefined && (op === PV.CONST || this.nodes.length - existing <= this.share_window)) {
+            return this.find(existing);
+        }
+
+        const id = this.nodes.length;
+
+        this.nodes.push(node);
+        this.class_of.push(id);
+        this.interned.set(key, id);
+        this.#grow(id);
+        this.class_nodes.set(id, [id]);
+        this.class_bound.set(id, this.#bound(node));
+
+        return id;
+    }
+
+    /**
+     * Record that a node means the same as an existing class — for a rewrite whose worth is not
+     * local, and which extraction should therefore be the one to take or leave.
+     *
+     * @param {number} id
+     * @param {number} alternative
+     */
+    add_alternative(id, alternative) {
+        const root = this.find(id);
+        const other = this.find(alternative);
+
+        if (root === other) {
+            return;
+        }
+
+        const merged = uf_union(this.parent, root, other);
+        const nodes = [...this.class_nodes.get(root), ...this.class_nodes.get(other)];
+
+        for (const member of nodes) {
+            for (const child of this.nodes[member].children) {
+                assert.notEqual(
+                    uf_find(this.parent, child),
+                    merged,
+                    `particle vector graph: node ${member} would reach its own class ${merged}`
+                );
+            }
+
+            this.class_of[member] = merged;
+        }
+
+        this.class_nodes.delete(root);
+        this.class_nodes.delete(other);
+        this.class_nodes.set(merged, nodes);
+        this.class_bound.set(
+            merged,
+            Math.min(this.class_bound.get(root) ?? Infinity, this.class_bound.get(other) ?? Infinity)
+        );
+    }
+
+    /**
+     * @param {ParticleVectorNode} node
+     * @returns {number} the magnitude bound on the integer it holds, if it is known to hold one
+     */
+    #bound(node) {
+        if (node.op === PV.CONST) {
+            return node.imm.reduce(
+                (bound, bits) => Math.max(bound, particle_integer_bound_of_value(vm_f32_value(bits))),
+                0
+            );
+        }
+
+        const bound = index => (node.children[index] === undefined ? Infinity : this.bound_of(node.children[index]));
+
+        // The reductions sum over every lane, so their bound is over the whole operand.
+        if (node.op === VM_OP.DOT) {
+            return particle_integer_bound_of_operation(node.op, 0, 0, 0, node.operand_width, () => [bound(0), bound(1)]);
+        }
+
+        return particle_integer_bound_of_operation(node.op, bound(0), bound(1), bound(2));
+    }
+
+    /** @param {number} wanted */
+    #grow(wanted) {
+        if (this.parent.length > wanted) {
+            return;
+        }
+
+        const grown = new Uint32Array(Math.max(16, (wanted + 1) * 2));
+
+        grown.set(this.parent);
+
+        for (let i = this.parent.length; i < grown.length; i++) {
+            grown[i] = i;
+        }
+
+        this.parent = grown;
+    }
+}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_groups.d.ts

@@ -0,0 +1,117 @@
+/**
+ * What a group is, which decides how it becomes instructions.
+ */
+export type PV_GROUP = string;
+export namespace PV_GROUP {
+    let COMPUTE: string;
+    let CONSTANT: string;
+    let GATHER: string;
+    let STORE: string;
+    let KILL: string;
+}
+export type ParticleGroupOperand = {
+    /**
+     * the source slot, `0..2`
+     */
+    slot: number;
+    /**
+     * the group whose base anchors the window the operand reads, or `-1` for a
+     * literal
+     */
+    group: number;
+    /**
+     * per lane of the operand, its slot measured from that group's base
+     */
+    lanes: number[];
+    /**
+     * per lane of the operand, the group and the
+     * lane of it actually read — which is what liveness and ordering want, and stops being the same
+     * thing as `lanes` once the window spans a COALITION of several runs
+     */
+    reads: Array<{
+        group: number;
+        lane: number;
+    }>;
+    /**
+     * for a literal operand, the `f32` it holds in every lane
+     */
+    value: number;
+};
+export type ParticleValueGroup = {
+    /**
+     * its position in {@link ParticleValuePacking.groups }
+     */
+    index: number;
+    /**
+     * a {@link PV_GROUP }
+     */
+    kind: string;
+    /**
+     * the opcode it emits
+     */
+    op: number;
+    /**
+     * the instruction's width field
+     */
+    width: number;
+    /**
+     * slots it writes
+     */
+    span: number;
+    /**
+     * the class in each written slot; `-1` for a slot the instruction writes
+     * that nothing reads
+     */
+    values: number[];
+    /**
+     * static operand words by source slot, `-1` where the slot is not one
+     */
+    raw: number[];
+    /**
+     * resolved register and literal operands
+     */
+    operands: ParticleGroupOperand[];
+    /**
+     * for a gather group, where
+     * each lane comes from: another group's lane, or a literal when `group` is `-1`
+     */
+    gather: Array<{
+        group: number;
+        lane: number;
+        value: number;
+    }>;
+    /**
+     * for a constant group, the literal in each lane
+     */
+    constants: number[];
+    /**
+     * for a `RANDOM` group, the first draw index it takes
+     */
+    draw: number;
+    /**
+     * the coalition of runs this one is laid out inside, or `-1`
+     */
+    coalition: number;
+    /**
+     * roughly where in the section this group's work first appeared — the
+     * newest class it computes, or for a group with no values the newest one it reads. Classes are
+     * numbered as the lift meets them, so this is the order the section was written in, and it is what
+     * the scheduler falls back on when it has no reason to prefer one ready group over another.
+     */
+    sequence: number;
+};
+export type ParticleValuePacking = {
+    groups: ParticleValueGroup[];
+    /**
+     * per class, where it is computed
+     */
+    placement: Map<number, {
+        group: number;
+        lane: number;
+    }>;
+    /**
+     * per coalition, the runs the allocator lays end to end
+     */
+    coalitions: number[][];
+};
+//# sourceMappingURL=particle_vector_groups.d.ts.map

package/src/shade/renderer/particles/optimizer/dag/particle_vector_groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_vector_groups.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_groups.js"],"names":[],"mappings":";;;uBAeU,MAAM;;;;;;;;;;;;UAiBF,MAAM;;;;;WACN,MAAM;;;;WAEN,MAAM,EAAE;;;;;;WACR,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;;;;WAGpC,MAAM;;;;;;WAKN,MAAM;;;;UACN,MAAM;;;;QACN,MAAM;;;;WACN,MAAM;;;;UACN,MAAM;;;;;YACN,MAAM,EAAE;;;;SAER,MAAM,EAAE;;;;cACR,oBAAoB,EAAE;;;;;YACtB,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC;;;;eAEnD,MAAM,EAAE;;;;UACR,MAAM;;;;eACN,MAAM;;;;;;;cACN,MAAM;;;YAQN,kBAAkB,EAAE;;;;eACpB,IAAI,MAAM,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;;;;gBAC1C,MAAM,EAAE,EAAE"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_groups.js

@@ -0,0 +1,70 @@
+/**
+ * The shape the packer hands the lowering: one group per instruction, and where its operands read.
+ *
+ * This is the seam between choosing WHAT to compute and choosing WHERE it lives. `./particle_vector_pack.js`
+ * decides the first and most of the second; `./particle_vector_lower.js` schedules, colours and
+ * emits. Neither knows anything about the graph the values came from, which is why the seam is
+ * described here rather than in either of them.
+ *
+ * A group writes a RUN — `span` consecutive slots — and an operand reads a window of at most four
+ * consecutive slots that may cross from one run into the next when the two are in a coalition. That
+ * is the whole of the machine model these two files share.
+ */
+
+/**
+ * What a group is, which decides how it becomes instructions.
+ * @enum {string}
+ */
+export const PV_GROUP = {
+    /** one instruction writing `values`, its operands resolved from the graph */
+    COMPUTE: "compute",
+    /** a `LOAD_CONST` of a pool run; the literals are in `constants` */
+    CONSTANT: "constant",
+    /** a run assembled one lane at a time, one `MOV` per entry of `gather` */
+    GATHER: "gather",
+    /** a `STORE_ATTR`; writes no run */
+    STORE: "store",
+    /** a `KILL`; writes no run */
+    KILL: "kill",
+};
+
+/**
+ * @typedef {object} ParticleGroupOperand
+ * @property {number} slot the source slot, `0..2`
+ * @property {number} group the group whose base anchors the window the operand reads, or `-1` for a
+ *   literal
+ * @property {number[]} lanes per lane of the operand, its slot measured from that group's base
+ * @property {Array<{group: number, lane: number}>} reads per lane of the operand, the group and the
+ *   lane of it actually read — which is what liveness and ordering want, and stops being the same
+ *   thing as `lanes` once the window spans a COALITION of several runs
+ * @property {number} value for a literal operand, the `f32` it holds in every lane
+ */
+
+/**
+ * @typedef {object} ParticleValueGroup
+ * @property {number} index its position in {@link ParticleValuePacking.groups}
+ * @property {string} kind a {@link PV_GROUP}
+ * @property {number} op the opcode it emits
+ * @property {number} width the instruction's width field
+ * @property {number} span slots it writes
+ * @property {number[]} values the class in each written slot; `-1` for a slot the instruction writes
+ *   that nothing reads
+ * @property {number[]} raw static operand words by source slot, `-1` where the slot is not one
+ * @property {ParticleGroupOperand[]} operands resolved register and literal operands
+ * @property {Array<{group: number, lane: number, value: number}>} gather for a gather group, where
+ *   each lane comes from: another group's lane, or a literal when `group` is `-1`
+ * @property {number[]} constants for a constant group, the literal in each lane
+ * @property {number} draw for a `RANDOM` group, the first draw index it takes
+ * @property {number} coalition the coalition of runs this one is laid out inside, or `-1`
+ * @property {number} sequence roughly where in the section this group's work first appeared — the
+ *   newest class it computes, or for a group with no values the newest one it reads. Classes are
+ *   numbered as the lift meets them, so this is the order the section was written in, and it is what
+ *   the scheduler falls back on when it has no reason to prefer one ready group over another.
+ */
+
+/**
+ * @typedef {object} ParticleValuePacking
+ * @property {ParticleValueGroup[]} groups
+ * @property {Map<number, {group: number, lane: number}>} placement per class, where it is computed
+ * @property {number[][]} coalitions per coalition, the runs the allocator lays end to end
+ */

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Read one section of a compiled program into a {@link ./particle_vector_graph.js vector graph}.
+ *
+ * What a section MEANS is its final record, the kill flag it sets and the RNG state it ends on, and
+ * everything that draws out of that is done here: a load of a word that was stored is the stored
+ * value, a word put back as it was found is not stored, kills are a set, draws are a sequence that
+ * may be re-cut, and nothing past a `HALT` is read.
+ *
+ * What is different is the unit. The register file holds not values but PLACES IN values: slot `s`
+ * holds lane `l` of value `v`. Reading a run of slots then asks one question — do they all come from
+ * one value? If they do, the read is that value through a swizzle, which is what a source word is and
+ * costs nothing. If they do not, it is a `BUILD`, and the copies it costs are visible from here on
+ * rather than discovered at the end.
+ *
+ * That is the whole of the change, and it is why the frontend's vectors reach the other side: a
+ * `vec3` the compiler emitted as one instruction is read back as one value, not inferred from three.
+ */
+/**
+ * @typedef {object} ParticleVectorPlace
+ * @property {number} value the class the slot's value belongs to
+ * @property {number} lane which lane of it the slot holds
+ */
+/**
+ * @typedef {object} ParticleLiftedVectorSection
+ * @property {Array<{word: number, place: ParticleVectorPlace, origin: number}>} stores record words
+ *   whose final contents differ from what the section found, in word order
+ * @property {ParticleVectorPlace[]} kills distinct kill conditions, in the order they were met
+ * @property {number} draw_count draws taken off the RNG
+ * @property {number[]} draws per draw, the class of the `RANDOM` that takes it
+ * @property {number[]} draw_lanes per draw, which lane of that class it is
+ */
+/**
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {ArrayLike<ArrayLike<number>>} instructions four-word tuples, in program order
+ * @param {object} params
+ * @param {ArrayLike<number>} params.constants
+ * @param {number} params.register_slots
+ * @returns {ParticleLiftedVectorSection|null} `null` when the section reaches outside that file, or
+ *   uses an opcode this lift has no model for
+ */
+export function lift_particle_vector_section(graph: import("./particle_vector_graph.js").ParticleVectorGraph, instructions: ArrayLike<ArrayLike<number>>, { constants, register_slots }: {
+    constants: ArrayLike<number>;
+    register_slots: number;
+}): ParticleLiftedVectorSection | null;
+/**
+ * A run of places, as one source operand — or as a `BUILD` when they do not all come from one value.
+ *
+ * This is the whole of what keeping vectors buys, in one function. A frontend put a value in a run
+ * and its consumers read that run, so the places agree and the read is a swizzle: free. Where they do
+ * not agree, the copies are counted here, in the open.
+ *
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {ParticleVectorPlace[]} places one per lane read
+ * @returns {{value: number, pattern: number}}
+ */
+export function read(graph: import("./particle_vector_graph.js").ParticleVectorGraph, places: ParticleVectorPlace[]): {
+    value: number;
+    pattern: number;
+};
+export type ParticleVectorPlace = {
+    /**
+     * the class the slot's value belongs to
+     */
+    value: number;
+    /**
+     * which lane of it the slot holds
+     */
+    lane: number;
+};
+export type ParticleLiftedVectorSection = {
+    /**
+     * record words
+     * whose final contents differ from what the section found, in word order
+     */
+    stores: Array<{
+        word: number;
+        place: ParticleVectorPlace;
+        origin: number;
+    }>;
+    /**
+     * distinct kill conditions, in the order they were met
+     */
+    kills: ParticleVectorPlace[];
+    /**
+     * draws taken off the RNG
+     */
+    draw_count: number;
+    /**
+     * per draw, the class of the `RANDOM` that takes it
+     */
+    draws: number[];
+    /**
+     * per draw, which lane of that class it is
+     */
+    draw_lanes: number[];
+};
+//# sourceMappingURL=particle_vector_lift.d.ts.map

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_vector_lift.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,oDARW,OAAO,4BAA4B,EAAE,mBAAmB,gBACxD,UAAU,UAAU,MAAM,CAAC,CAAC;IAEF,SAAS,EAAnC,UAAU,MAAM,CAAC;IACF,cAAc,EAA7B,MAAM;IACJ,2BAA2B,GAAC,IAAI,CAgK5C;AAED;;;;;;;;;;GAUG;AACH,4BAJW,OAAO,4BAA4B,EAAE,mBAAmB,UACxD,mBAAmB,EAAE,GACnB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB5C;;;;;WAlNa,MAAM;;;;UACN,MAAM;;;;;;;YAKN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAC;QAAC,QAAQ,MAAM,CAAA;KAAC,CAAC;;;;WAEjE,mBAAmB,EAAE;;;;gBACrB,MAAM;;;;WACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}