@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/particles/graph/particle_node_presentation.js

@@ -0,0 +1,342 @@
+/**
+ * What a person sees of each particle node type: what it is called, the glyph it carries, and the
+ * one line of help a palette offers under its name.
+ *
+ * The library's own names are addresses — they are what a saved graph holds and what
+ * {@link ./ParticleNodeRegistry.js get_particle_node_description} looks a type up by — so they are
+ * terse and they do not change. `div`, `mad`, `setAttribute`. Nobody reads those as "divide",
+ * "multiply-add" and "write attribute" without translating, and an editor that shows only them
+ * makes every author do that translation on every node, every time.
+ *
+ * So the names stay what they are and this says what to draw instead. Kept out of the registry
+ * because that file is about lowering nodes to instructions and this is about none of that; kept
+ * out of the views because all of them — the node, the palette, whatever lists node types next —
+ * have to agree, and a table each is three tables that drift.
+ *
+ * ## The icons
+ *
+ * SVG path data in a 24x24 box, no colour and no stroke width: see
+ * {@link ../../../../core/model/node-graph/node/NodeDescription.js NodeDescription#icon}, which is
+ * where these end up, and `NodeIconView`, which draws them.
+ *
+ * They are drawn on a shared skeleton — strokes between 4 and 20, nothing thinner than a couple of
+ * units apart — because these are read at about fourteen pixels in a node's header, where detail is
+ * lost and only the silhouette survives. Where an operation already has a symbol everybody knows,
+ * that symbol is the icon: `add` is a plus, `mul` is a cross, `compare` is a pair of angle
+ * brackets. Inventing a picture for arithmetic would be worse than the arithmetic.
+ */
+
+/**
+ * A dot, as a path: two half-arcs closing on themselves. Zero-length subpaths with a round cap draw
+ * a dot too, but only where the stroke is round — and these are drawn by a stylesheet that a host
+ * may have opinions about.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} r
+ * @returns {string}
+ */
+function dot(x, y, r) {
+    return `M${x} ${y - r}a${r} ${r} 0 1 0 0 ${r * 2}a${r} ${r} 0 1 0 0 ${-r * 2}`;
+}
+
+/**
+ * Everything the editor shows about a node type, by the type's name.
+ *
+ * Every type in the library has an entry, and no entry names a type the library does not have —
+ * both directions are checked by `ParticleNodeRegistry.spec.js`, so a node type added without a
+ * label fails a test rather than quietly showing up in the graph as `smoothstep`.
+ *
+ * @type {Object<string, {label: string, icon: string, help: string}>}
+ */
+export const PARTICLE_NODE_PRESENTATION = Object.freeze({
+    // --- sources ---
+    const: {
+        label: "Constant",
+        icon: `M6 6h12v12H6z ${dot(12, 12, 1.6)}`,
+        help: "a literal: one number is a scalar, two to four a vector",
+    },
+    color: {
+        label: "Colour",
+        icon: "M12 4c0 0 6 6.6 6 10.4a6 6 0 0 1-12 0C6 10.6 12 4 12 4z",
+        help: "a literal colour — a vec4 that says it is one",
+    },
+    builtin: {
+        label: "Built-in Value",
+        icon: "M6 7h12v10H6z M9 4v3 M15 4v3 M9 17v3 M15 17v3",
+        help: "a value the host provides — delta time, emitter position…",
+    },
+    attribute: {
+        label: "Read Attribute",
+        icon: "M5 5v14 M8 12h11 M16 9l3 3-3 3",
+        help: "read one of this effect's per-particle attributes",
+    },
+    random: {
+        label: "Random",
+        icon: `M5 5h14v14H5z ${dot(9, 9, 1.3)} ${dot(15, 15, 1.3)}`,
+        help: "uniform draws in [0, 1), one per lane, as many lanes as asked",
+    },
+
+    // --- sinks ---
+    setAttribute: {
+        label: "Write Attribute",
+        icon: "M19 5v14 M5 12h11 M13 9l3 3-3 3",
+        help: "write a per-particle attribute",
+    },
+    kill: {
+        label: "Kill Particle",
+        icon: "M12 3a9 9 0 1 0 0 18a9 9 0 1 0 0-18 M9 9l6 6 M15 9l-6 6",
+        help: "destroy the particle where the condition is positive",
+    },
+
+    // --- arithmetic ---
+    add: {
+        label: "Add",
+        icon: "M12 5v14 M5 12h14",
+        help: "a + b",
+    },
+    sub: {
+        label: "Subtract",
+        icon: "M5 12h14",
+        help: "a - b",
+    },
+    mul: {
+        label: "Multiply",
+        icon: "M6 6l12 12 M18 6L6 18",
+        help: "a * b, lane by lane",
+    },
+    div: {
+        label: "Divide",
+        icon: `M5 12h14 ${dot(12, 8, 1.3)} ${dot(12, 16, 1.3)}`,
+        help: "a / b",
+    },
+    min: {
+        label: "Minimum",
+        icon: "M5 8l7 8 7-8",
+        help: "the smaller of the two, lane by lane",
+    },
+    max: {
+        label: "Maximum",
+        icon: "M5 16l7-8 7 8",
+        help: "the larger of the two, lane by lane",
+    },
+    pow: {
+        label: "Power",
+        icon: "M5 19C9 19 11 5 19 5",
+        help: "a raised to b",
+    },
+    step: {
+        label: "Step",
+        icon: "M4 18h7V6h9",
+        help: "0 below the edge, 1 at or above it",
+    },
+    mad: {
+        label: "Multiply Add",
+        icon: "M4 5l5 5 M9 5l-5 5 M18 13v7 M14.5 16.5h7",
+        help: "a * b + c",
+    },
+    mix: {
+        label: "Mix",
+        icon: "M4 6h5c5 0 4 12 9 12h2 M4 18h5c5 0 4-12 9-12h2",
+        help: "a and b blended by t",
+    },
+    clamp: {
+        label: "Clamp",
+        icon: "M6 5v14 M18 5v14 M6 12h12",
+        help: "held between a low and a high bound",
+    },
+    saturate: {
+        // `clamp`'s two walls, drawn where its bounds actually are: at 0 and at 1.
+        label: "Saturate",
+        icon: "M6 5v14 M18 5v14 M6 18h12 M6 18l12-12 M6 6h12",
+        help: "held between 0 and 1",
+    },
+    smoothstep: {
+        label: "Smooth Step",
+        icon: "M4 18C8 18 8 6 12 6s4 12 8 12",
+        help: "a smooth 0..1 ramp between two edges",
+    },
+    scale: {
+        label: "Scale",
+        icon: "M6 18L18 6 M13 6h5v5",
+        help: "a vector times a scalar",
+    },
+
+    // --- unary math ---
+    neg: {
+        label: "Negate",
+        icon: "M12 3a9 9 0 1 0 0 18a9 9 0 1 0 0-18 M8 12h8",
+        help: "the same value with its sign flipped",
+    },
+    abs: {
+        label: "Absolute",
+        icon: "M7 5v14 M17 5v14 M10 8l2 8 2-8",
+        help: "the magnitude, sign discarded",
+    },
+    floor: {
+        label: "Floor",
+        icon: "M6 5v13h12 M6 12h4",
+        help: "rounded down to a whole number",
+    },
+    fract: {
+        label: "Fraction",
+        icon: `M7 17L17 7 ${dot(8.5, 9, 1.6)} ${dot(15.5, 15, 1.6)}`,
+        help: "what is left after the whole part",
+    },
+    sqrt: {
+        label: "Square Root",
+        icon: "M4 13h3l3 7 5-15h9",
+        help: "the square root",
+    },
+    sin: {
+        label: "Sine",
+        icon: "M3 12c3-8 6-8 9 0s6 8 9 0",
+        help: "the sine, in radians",
+    },
+    cos: {
+        label: "Cosine",
+        icon: "M3 7c4.5 0 4.5 10 9 10s4.5-10 9-10",
+        help: "the cosine, in radians",
+    },
+    exp: {
+        label: "Exponential",
+        icon: "M4 4v16h16 M7 18C13 18 13 8 18 6",
+        help: "e raised to x",
+    },
+    log: {
+        label: "Logarithm",
+        icon: "M4 4v16h16 M7 19c1-9 5-12 11-13",
+        help: "the natural logarithm",
+    },
+    rsqrt: {
+        // The radical under a fraction bar: one over what `sqrt` draws.
+        label: "Inverse Square Root",
+        icon: "M6 6h12 M5 14h2.5l2.5 5 4-11h5",
+        help: "one over the square root",
+    },
+    tan: {
+        // Steep at both ends and shallow through the middle, which is the curve between two poles.
+        label: "Tangent",
+        icon: "M6 20c2-4 3-6 6-8s4-4 6-8",
+        help: "the tangent, in radians",
+    },
+    asin: {
+        // The sine wave on its side: an inverse is its function reflected about the diagonal.
+        label: "Arcsine",
+        icon: "M12 4c-7 2.5-7 5.5 0 8s7 5.5 0 8",
+        help: "the angle whose sine this is, in radians",
+    },
+    acos: {
+        label: "Arccosine",
+        icon: "M7 4c0 4 10 4 10 8s-10 4-10 8",
+        help: "the angle whose cosine this is, in radians",
+    },
+    atan2: {
+        // A ray from the origin with the angle it makes marked off against the axis.
+        label: "Arctangent",
+        icon: "M5 19h13 M5 19L16 8 M11 19a6 6 0 0 0 -1.8 -4.2",
+        help: "the angle of the point (x, y), in radians",
+    },
+
+    // --- vector ---
+    normalize: {
+        label: "Normalize",
+        icon: "M12 3a9 9 0 1 0 0 18a9 9 0 1 0 0-18 M12 12l6-6",
+        help: "the same direction, length one",
+    },
+    length: {
+        label: "Length",
+        icon: "M4 8v8 M20 8v8 M4 12h16",
+        help: "how long the vector is",
+    },
+    dot: {
+        label: "Dot Product",
+        icon: `M4 6l5 6-5 6 M20 6l-5 6 5 6 ${dot(12, 12, 1.3)}`,
+        help: "how much two vectors point the same way",
+    },
+    cross: {
+        label: "Cross Product",
+        icon: "M12 21V12 M12 12L4 7 M12 12l8-5",
+        help: "the vector perpendicular to both",
+    },
+    distance: {
+        label: "Distance",
+        icon: `${dot(6, 12, 2)} ${dot(18, 12, 2)} M9 12h6`,
+        help: "how far apart two points are",
+    },
+    swizzle: {
+        label: "Swizzle",
+        icon: "M4 7h5c5 0 4 10 9 10h2 M4 17h5c5 0 4-10 9-10h2",
+        help: "pick and reorder lanes; the pattern's length is the result's width",
+    },
+    // "Combine", rather than the type's own name, so that these and the `decompose` groups read as
+    // the pair they are — and so that looking for either half finds it. The constructors were here
+    // long before anything took a vector apart, and were named after what they produce.
+    vec2: {
+        label: "Combine vec2",
+        icon: "M6 9h12 M6 15h12",
+        help: "two scalars as one vector, x and y",
+    },
+    vec3: {
+        label: "Combine vec3",
+        icon: "M6 7h12 M6 12h12 M6 17h12",
+        help: "three scalars as one vector, x, y and z",
+    },
+    vec4: {
+        label: "Combine vec4",
+        icon: "M6 6h12 M6 10h12 M6 14h12 M6 18h12",
+        help: "four scalars as one vector, x, y, z and w",
+    },
+
+    // --- logic ---
+    compare: {
+        label: "Compare",
+        icon: "M9 7l-5 5 5 5 M15 7l5 5-5 5",
+        help: "component-wise comparison, 1 where it holds",
+    },
+    select: {
+        label: "Select",
+        icon: "M4 8h6l4 4h7 M4 16h6l3-3 M18 9l3 3-3 3",
+        help: "b where the condition is positive, a elsewhere",
+    },
+
+    // --- ramps ---
+    // Two ways to have a curve, and the labels say which is which. The table one came first and was
+    // called just "Curve"; it is renamed here rather than leaving the new one to explain itself,
+    // because "the one that samples the host's table" is the surprising half of the pair and the
+    // one an author has to have decided to want.
+    curve: {
+        label: "Curve Table",
+        icon: `M5 18C10 18 9 6 19 6 ${dot(5, 18, 1.6)} ${dot(19, 6, 1.6)}`,
+        help: "sample a row of the host's animation-curve table at t",
+    },
+    curveLiteral: {
+        // the same curve with its keys on it: this one is the curve rather than a handle to one
+        label: "Curve",
+        icon: `M4 19C10 19 8 5 20 5 ${dot(4, 19, 1.8)} ${dot(12, 12, 1.8)} ${dot(20, 5, 1.8)}`,
+        help: "a curve of your own, written into the program: t in, its value out",
+    },
+    gradientRGBA: {
+        // a strip with its stops underneath, which is what the control is
+        label: "RGBA Gradient",
+        icon: `M4 5h16v8H4z M4 9h16 ${dot(6, 18, 1.8)} ${dot(12, 18, 1.8)} ${dot(18, 18, 1.8)}`,
+        help: "a colour gradient looked up at t, with alpha",
+    },
+    gradientRGB: {
+        label: "RGB Gradient",
+        icon: `M4 5h16v8H4z ${dot(6, 18, 1.8)} ${dot(12, 18, 1.8)} ${dot(18, 18, 1.8)}`,
+        help: "a colour gradient looked up at t, no alpha",
+    },
+});
+
+/**
+ * What to show for a node type. A type with no entry falls back to its own name and no artwork,
+ * which is what the base {@link NodeDescription} does anyway — a library extended at runtime shows
+ * up plainly rather than not at all.
+ *
+ * @param {string} name node type name
+ * @returns {{label: string, icon: string, help: string}}
+ */
+export function particle_node_presentation(name) {
+    return PARTICLE_NODE_PRESENTATION[name] ?? { label: "", icon: "", help: "" };
+}

package/src/shade/renderer/particles/graph/particle_ramp.d.ts

@@ -0,0 +1,230 @@
+/**
+ * A fresh straight 0..1 ramp: what a curve node starts as.
+ *
+ * Linear rather than eased, because a curve node's first job is almost always to be *changed*, and a
+ * straight line is the shape whose change is easiest to see. Tangents of 1 are what make it straight
+ * — see {@link roll_out_particle_curve}.
+ *
+ * @returns {ParticleCurveParameter}
+ */
+export function particle_curve_default(): ParticleCurveParameter;
+/**
+ * A fresh black-to-white gradient: what a gradient node starts as.
+ *
+ * @returns {ParticleGradientStop[]}
+ */
+export function particle_gradient_default(): ParticleGradientStop[];
+/**
+ * Whether a value is a curve parameter this can lower — every key a record of four finite numbers.
+ *
+ * The validator's question and the editor's, asked in one place so that "a curve" means the same
+ * thing to both. Not a repair: something that fails this is reported against the node rather than
+ * quietly turned into a curve nobody asked for.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function is_particle_curve(value: any): boolean;
+/**
+ * Whether a value is a gradient parameter this can lower.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function is_particle_gradient(value: any): boolean;
+/**
+ * A curve's keys in time order.
+ *
+ * Sorted here rather than trusted, because a key dragged past its neighbour in the editor is an
+ * ordinary thing to do and the rollout's telescoping sum is only the piecewise function if the
+ * segments are walked in order.
+ *
+ * @param {ParticleCurveParameter} value
+ * @returns {ParticleCurveKey[]}
+ */
+export function particle_curve_keys(value: ParticleCurveParameter): ParticleCurveKey[];
+/**
+ * The same curve as the engine's own {@link AnimationCurve} — what the editor draws and evaluates,
+ * and what a spec checks the rolled-out instructions against.
+ *
+ * @param {ParticleCurveParameter} value
+ * @returns {AnimationCurve}
+ */
+export function particle_curve_animation(value: ParticleCurveParameter): AnimationCurve;
+/**
+ * A curve parameter holding what this {@link AnimationCurve} holds.
+ *
+ * @param {AnimationCurve} curve
+ * @returns {ParticleCurveParameter}
+ */
+export function particle_curve_from_animation(curve: AnimationCurve): ParticleCurveParameter;
+/**
+ * A gradient's stops in position order, each with its colour copied.
+ *
+ * @param {ParticleGradientStop[]} value
+ * @returns {ParticleGradientStop[]}
+ */
+export function particle_gradient_stops(value: ParticleGradientStop[]): ParticleGradientStop[];
+/**
+ * What a gradient is at `t`, in JavaScript: the same piecewise-linear function the rollout computes,
+ * for an editor to draw the strip with and for a spec to check the instructions against.
+ *
+ * @param {ParticleGradientStop[]} value
+ * @param {number} t
+ * @returns {number[]} four channels
+ */
+export function particle_gradient_sample(value: ParticleGradientStop[], t: number): number[];
+/**
+ * Roll a curve out into arithmetic: `t` in, the curve's value at `t` out, as a scalar.
+ *
+ * Each segment is a cubic Hermite in its own weight, written in the form the sum wants — `c(0) = 0`
+ * and `c(1)` the step across the segment — which is the standard basis with the leading value
+ * subtracted back off:
+ *
+ *     c(u) = ((A·u + B)·u + C)·u,   A = m0 + m1 - 2Δv,  B = 3Δv - 2m0 - m1,  C = m0
+ *
+ * where `Δv` is the segment's rise and `m0`, `m1` are its tangents scaled by its width — exactly what
+ * {@link ../../../../engine/animation/curve/evaluate_two_key_curve.js} hands
+ * {@link ../../../../core/math/spline/spline3_hermite.js}, so a curve evaluates here to what it
+ * evaluates to anywhere else in the engine. Three multiply-adds, the last of which is also the
+ * accumulation.
+ *
+ * A segment whose tangents are its own slope has `A` and `B` at zero, which is a straight line and
+ * one instruction instead of three. A segment that neither rises nor turns contributes nothing at
+ * all and is not emitted — which is how the flat tail an author leaves on a fade costs nothing.
+ *
+ * @param {import("./ParticleGroupBuilder.js").ParticleGroupBuilder} g
+ * @param {*} t
+ * @param {ParticleCurveParameter} value
+ * @returns {*} a scalar
+ */
+export function roll_out_particle_curve(g: import("./ParticleGroupBuilder.js").ParticleGroupBuilder, t: any, value: ParticleCurveParameter): any;
+/**
+ * Roll a gradient out into arithmetic: `t` in, the colour at `t` out.
+ *
+ * The same sum as the curve's, with a vector where the curve has a number and a straight line where
+ * it has a cubic — a stop's difference times the segment's weight, scaled and added. The weight is
+ * one lane and the difference is three or four, which is what `scale` is for: a vector times a
+ * broadcast scalar, one instruction, no widening.
+ *
+ * A segment between two stops of the same colour adds a zero vector and is not emitted, so the flat
+ * run an author leaves at either end of a gradient is free.
+ *
+ * @param {import("./ParticleGroupBuilder.js").ParticleGroupBuilder} g
+ * @param {*} t
+ * @param {ParticleGradientStop[]} value
+ * @param {number} components how many channels to produce: 3 for an RGB gradient, 4 for RGBA
+ * @returns {*} a vector of `components` lanes
+ */
+export function roll_out_particle_gradient(g: import("./ParticleGroupBuilder.js").ParticleGroupBuilder, t: any, value: ParticleGradientStop[], components: number): any;
+/**
+ * Ramps: a curve and a colour gradient, and the arithmetic either one becomes.
+ *
+ * Both are the same shape of thing — a value that depends on one number `t`, written down as a
+ * handful of points with something interpolated between them — and both are *authored data* rather
+ * than wiring, so neither can be a {@link ./ParticleNodeGroup.js node group}: a group's body is
+ * fixed when the group is built, and a gradient with five stops is different arithmetic from a
+ * gradient with two. They are expanding node types instead (see
+ * {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand}), and this is what they expand
+ * *into*: stock nodes, which is to say VM instructions, with the curve rolled out along them.
+ *
+ * ## Rolled out, not sampled
+ *
+ * There is a `CURVE` opcode, and it is not this. That one samples a row of the animation-curve table
+ * a host uploads, which is the right answer for a curve an author is dragging around at runtime and
+ * the wrong one for a curve that is part of the effect: it costs a table, a row, a handle to keep in
+ * step with it, and a texture fetch. A ramp with four stops rolls out to about twenty instructions
+ * of pure arithmetic, needs nothing from the host, and constant-folds where an author has left a
+ * segment flat.
+ *
+ * ## How a piecewise function becomes straight-line code
+ *
+ * There is no control flow to pick a segment with, so every segment is evaluated and the ones that
+ * do not apply are made to contribute nothing. Each segment gets a weight
+ *
+ *     u = clamp((t - t0) / (t1 - t0), 0, 1)
+ *
+ * which is 0 everywhere before the segment, 1 everywhere after it, and the position within it in
+ * between. Contributions are then written as *differences* and summed:
+ *
+ *     f(t) = v0 + sum over segments of c(u), where c(0) = 0 and c(1) = v1 - v0
+ *
+ * Before a segment, `u` is 0 and it adds nothing. After it, `u` is 1 and it has added exactly the
+ * step from its start value to its end value, so the segments before the one `t` is in telescope to
+ * "the value at the start of this segment" and the ones after it are silent. Only one segment is
+ * ever partway through, and its `c(u)` is the interpolation. The sum is therefore the piecewise
+ * function exactly — not an approximation of it — and it is three or four instructions per segment
+ * with no comparisons and no branches.
+ *
+ * It also gives the endpoint behaviour for free: `t` below the first stop leaves every weight at 0
+ * and the value is the first stop's, and above the last stop every weight is 1. That is what
+ * {@link AnimationCurve#evaluate} does at the ends, so the rollout and the editor's own preview
+ * agree there as well as in the middle.
+ *
+ * ## Why a gradient is not four curves
+ *
+ * A curve is an {@link AnimationCurve} — keys with tangents, the same class the rest of the engine
+ * animates with, so a curve authored here can be moved anywhere a curve is wanted and the editor's
+ * preview is the engine's own evaluation rather than a second opinion about it.
+ *
+ * A gradient is *not* four of those. A colour stop is one position with a colour on it, and that is
+ * the whole reason a gradient is easy to author: drag the stop and the colour moves. Four
+ * independent curves would let the red key drift away from the green one, and the interface the
+ * stops are for — Photoshop's, and everybody else's — could no longer be drawn over the data. So a
+ * gradient keeps a shared position per stop and interpolates linearly, and shares with the curve the
+ * thing actually worth sharing: the weights above, and the sum they go into.
+ */
+/**
+ * One key of a curve, as it is stored in a node's parameters — the shape {@link AnimationCurve}
+ * writes and reads.
+ *
+ * @typedef {object} ParticleCurveKey
+ * @property {number} time
+ * @property {number} value
+ * @property {number} inTangent
+ * @property {number} outTangent
+ */
+/**
+ * A curve, as a node parameter holds one.
+ *
+ * @typedef {{keys: ParticleCurveKey[]}} ParticleCurveParameter
+ */
+/**
+ * One stop of a gradient: where it sits along `t`, and the colour there. The colour is always four
+ * numbers, whatever the node reads of it — an RGB gradient uses the first three — so that a gradient
+ * survives being moved between the two node types with its alpha intact.
+ *
+ * @typedef {{position: number, color: number[]}} ParticleGradientStop
+ */
+/**
+ * How many lanes a gradient's colour is written with, whichever node reads it.
+ * @type {number}
+ */
+export const PARTICLE_GRADIENT_COLOR_COMPONENTS: number;
+/**
+ * One key of a curve, as it is stored in a node's parameters — the shape {@link AnimationCurve }
+ * writes and reads.
+ */
+export type ParticleCurveKey = {
+    time: number;
+    value: number;
+    inTangent: number;
+    outTangent: number;
+};
+/**
+ * A curve, as a node parameter holds one.
+ */
+export type ParticleCurveParameter = {
+    keys: ParticleCurveKey[];
+};
+/**
+ * One stop of a gradient: where it sits along `t`, and the colour there. The colour is always four
+ * numbers, whatever the node reads of it — an RGB gradient uses the first three — so that a gradient
+ * survives being moved between the two node types with its alpha intact.
+ */
+export type ParticleGradientStop = {
+    position: number;
+    color: number[];
+};
+import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+//# sourceMappingURL=particle_ramp.d.ts.map

package/src/shade/renderer/particles/graph/particle_ramp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_ramp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_ramp.js"],"names":[],"mappings":"AA2FA;;;;;;;;GAQG;AACH,0CAFa,sBAAsB,CASlC;AAED;;;;GAIG;AACH,6CAFa,oBAAoB,EAAE,CAOlC;AAUD;;;;;;;;;GASG;AACH,+CAFa,OAAO,CAanB;AAED;;;;;GAKG;AACH,kDAFa,OAAO,CAanB;AAED;;;;;;;;;GASG;AACH,2CAHW,sBAAsB,GACpB,gBAAgB,EAAE,CAI9B;AAED;;;;;;GAMG;AACH,gDAHW,sBAAsB,GACpB,cAAc,CAQ1B;AAED;;;;;GAKG;AACH,qDAHW,cAAc,GACZ,sBAAsB,CAWlC;AAED;;;;;GAKG;AACH,+CAHW,oBAAoB,EAAE,GACpB,oBAAoB,EAAE,CAMlC;AAED;;;;;;;GAOG;AACH,gDAJW,oBAAoB,EAAE,KACtB,MAAM,GACJ,MAAM,EAAE,CAsBpB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CALW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,sBAAsB,OA+ChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,oBAAoB,EAAE,cACtB,MAAM,OA8BhB;AA/YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,iDAFU,MAAM,CAEoC;;;;;;UAxBtC,MAAM;WACN,MAAM;eACN,MAAM;gBACN,MAAM;;;;;qCAMP;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAC;;;;;;mCAQ1B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC;+BAlFjB,sDAAsD"}