framefields 2.2.0 → 2.3.1

package/dist/renderer-HMl2V4iM.mjs

@@ -0,0 +1,541 @@
+import "./chunk-GBe2k3y8.mjs";
+import { n as defineRenderer, s as resolveSignalField } from "./renderer-BSitV56h.mjs";
+import { Nn as signalRegistry } from "./dist-jU289ehm.mjs";
+import { a as createFullscreenPipeline, f as signalTiming, l as fragmentBindGroupLayout, p as texturesLayout, t as FULLSCREEN_QUAD_WGSL, u as perDevice } from "./gpu-BA1Wz_mS.mjs";
+
+//#region ../../nodes/node-procedural-vfx/dist/renderers-DiW7Lt7Y.mjs
+const VFX_SHADER = `
+struct VFXUniforms {
+    effectType             : f32,
+    outputType             : f32,
+    time                   : f32,
+    _pad0                  : f32,
+
+    density                : f32,
+    scale                  : f32,
+    speed                  : f32,
+    intensity              : f32,
+
+    seed                   : f32,
+    hasSigDensity          : f32,
+    hasSigScale            : f32,
+    hasSigSpeed            : f32,
+
+    hasSigIntensity        : f32,
+    hasSigSeed             : f32,
+    _pad1                  : f32,
+    _pad2                  : f32,
+
+    colorStart             : vec4<f32>,
+    colorEnd               : vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u : VFXUniforms;
+
+@group(1) @binding(0) var densityTex   : texture_2d<f32>;
+@group(1) @binding(1) var scaleTex     : texture_2d<f32>;
+@group(1) @binding(2) var speedTex     : texture_2d<f32>;
+@group(1) @binding(3) var intensityTex : texture_2d<f32>;
+@group(1) @binding(4) var seedTex      : texture_2d<f32>;
+@group(1) @binding(5) var signalSamp   : sampler;
+${FULLSCREEN_QUAD_WGSL}
+
+// ---- hashing & noise primitives -------------------------------------------
+fn hash21(p: vec2<f32>) -> vec2<f32> {
+    let p3 = fract(vec3<f32>(p.xyx) * vec3<f32>(0.1031, 0.1030, 0.0973));
+    let p4 = p3 + dot(p3, p3.yzx + 33.33);
+    return fract((p4.xx + p4.yz) * p4.zy);
+}
+
+fn hash1(n: f32) -> f32 {
+    return fract(sin(n) * 43758.5453);
+}
+
+fn valueNoise(p: vec2<f32>) -> f32 {
+    let i = floor(p);
+    let f = fract(p);
+    let u = f * f * (3.0 - 2.0 * f);
+    let a = hash1(dot(i, vec2<f32>(127.1, 311.7)));
+    let b = hash1(dot(i + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7)));
+    let c = hash1(dot(i + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7)));
+    let d = hash1(dot(i + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7)));
+    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+fn fbm(p: vec2<f32>, octaves: i32) -> f32 {
+    var value = 0.0;
+    var amp = 0.5;
+    var freq = 1.0;
+    for (var i = 0; i < 8; i++) {
+        if (i >= octaves) { break; }
+        value += amp * valueNoise(p * freq);
+        freq *= 2.0;
+        amp *= 0.5;
+    }
+    return value;
+}
+
+fn get_field(val: f32, hasSig: f32, tex: texture_2d<f32>, samp: sampler) -> f32 {
+    if (hasSig > 0.5) {
+        return textureSampleLevel(tex, samp, vec2<f32>(0.5, 0.5), 0.0).r;
+    }
+    return val;
+}
+
+// ---- effect synthesizers (return straight-alpha RGBA) ----------------------
+fn fxSmoke(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let sp = p * scl;
+    // Domain-warped FBM gives structured puffs instead of a solid fill.
+    let q = vec2<f32>(fbm(sp + time * 0.10, 4), fbm(sp + vec2<f32>(5.2, 1.3) + time * 0.08, 4));
+    let f = fbm(sp + 4.0 * q + vec2<f32>(1.7, 9.2) + time * 0.05, 4); // ~[0, 0.94]
+    // Billowing plume: denser at the base (bottom, p.y=0), dissipating toward the top.
+    let vgrad = 1.0 - smoothstep(0.45, 0.9, p.y);
+    let n = f * 2.0 - 1.0; // remap to [-1, 1]
+    // Thresholded so only bright fbm patches are opaque -> reads as puffs, not solid.
+    let cov = smoothstep(0.28, 0.6, n) * dens * (0.25 + 0.75 * vgrad);
+    let alpha = cov * inten;
+    let col = mix(cB * 0.35, cA, clamp(f + vgrad * 0.5, 0.0, 1.0));
+    return vec4<f32>(col, clamp(alpha, 0.0, 1.0));
+}
+
+fn fxFire(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let pn = vec2<f32>(p.x * 1.5, p.y) * scl;
+    let n = fbm(pn * 6.0 + vec2<f32>(time * 2.0, time * 3.0), 4);
+    // Heat concentrated near base, flickering upward
+    let heat = n * smoothstep(1.0, 0.0 + (1.0 - dens) * 0.3, p.y);
+    // Channeled vertical columns
+    let columns = smoothstep(0.45, 0.9, n + 0.4 * sin(p.x * (20.0 + 40.0 * dens) * scl + time * 8.0));
+    let d = clamp(heat * inten + columns * 0.3 * inten, 0.0, 1.0);
+    // Fire color ramp mapped dynamically to cA and cB
+    let dark = cB * 0.15;
+    let orange = cB;
+    let yellow = mix(cB, cA, 0.5);
+    let white = cA;
+    var col = mix(dark, orange, smoothstep(0.0, 0.4, d));
+    col = mix(col, yellow, smoothstep(0.4, 0.75, d));
+    col = mix(col, white, smoothstep(0.75, 1.0, d));
+    let alpha = smoothstep(0.0, 0.3, d) * inten;
+    return vec4<f32>(col, clamp(alpha, 0.0, 1.0));
+}
+
+fn fxRain(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let n = (60.0 * dens + 4.0) * scl;
+    let gx = floor(p.x * n);
+    let h = hash1(gx);
+    let speed = 0.8 + h;
+    let yFrac = fract(p.y * 8.0 - time * speed);
+    let dropY = abs(yFrac - 0.5);
+    let reveal = step(0.35, yFrac);
+    let st = smoothstep(0.18, 0.02, dropY);
+    let d = st * reveal;
+    let g = smoothstep(0.18, 0.02, abs(fract(p.x * n) + h * 0.2 - 0.5));
+    let a = d * g * inten;
+    let col = mix(cA, cB, h);
+    return vec4<f32>(col, clamp(a, 0.0, 1.0));
+}
+
+fn fxSnow(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let n = (50.0 * dens + 6.0) * scl;
+    let cell = floor(p * n);
+    let f = fract(p * n);
+    let h = hash21(cell);
+    let center = vec2<f32>(0.5, 0.5) + 0.3 * hash21(cell + 7.0);
+    let sway = 0.1 * sin(time * 1.2 + cell.y * 3.0);
+    // Fall downward (toward p.y=0, the bottom): subtract an advancing phase.
+    let fall = fract(time * (0.25 + 0.45 * h.y) + h.x);
+    let pos = vec2<f32>(f.x - center.x - sway, f.y - center.y) - vec2<f32>(0.0, fall);
+    let d = length(pos);
+    let size = 0.05 + 0.07 * h.x;
+    let a = smoothstep(size, size * 0.4, d) * inten;
+    let col = mix(cA, cB, h.x);
+    return vec4<f32>(col, clamp(a, 0.0, 1.0));
+}
+
+fn fxDust(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let n = (90.0 * dens + 6.0) * scl;
+    let cell = floor(p * n);
+    let f = fract(p * n);
+    let h = hash21(cell);
+    let center = h;
+    let drift = fract(time * 0.05 * (0.5 + h.y) + cell.x * 0.01);
+    let pos = vec2<f32>(f.x - center.x, f.y - center.y) + vec2<f32>((drift - 0.5) * 0.03, 0.0);
+    let d = length(pos);
+    let a = smoothstep(0.12, 0.0, d) * smoothstep(0.0, 0.3, dens) * inten * 0.6;
+    let col = mix(cA, cB, h.y);
+    return vec4<f32>(col, clamp(a, 0.0, 1.0));
+}
+
+fn fxEmbers(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let n = (50.0 * dens + 4.0) * scl;
+    let cell = floor(p * n);
+    let f = fract(p * n);
+    let h = hash21(cell);
+    let sway = 0.12 * sin(time * 2.0 + cell.y * 2.0);
+    let rise = fract(time * 0.18 * (0.7 + h.y) + cell.y * 0.12);
+    // Rising: as rise grows, move toward p.y=1 (top).
+    let pos = vec2<f32>(f.x - 0.5 - sway, f.y + rise * 1.2);
+    let d = length(pos);
+    let a = smoothstep(0.12, 0.0, d) * (1.0 - rise) * inten;
+    let col = mix(cA, cB, clamp(rise, 0.0, 1.0));
+    return vec4<f32>(col, clamp(a, 0.0, 1.0));
+}
+
+fn fxSparks(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    // Burst radiating from a low-center source; travel grows over time so it expands outward.
+    let src = vec2<f32>(0.5, 0.15);
+    let dir = p - src;
+    let dist = length(dir);
+    let ang = atan2(dir.y, dir.x);
+    let n = (20.0 * dens + 5.0) * scl;
+    let seg = floor(ang * n);
+    let tFrame = floor(time * 3.0);
+    let timeVal = tFrame - 10000.0 * floor(tFrame / 10000.0);
+    let h = hash1(seg + timeVal * 97.0);
+    let launch = fract(0.5 + h + time * 0.5);
+    let travel = launch * 0.8;
+    let trail = smoothstep(0.9, 0.4, dist - travel);
+    let w = 0.02 + 0.02 * h;
+    let blast = smoothstep(0.0, w * 2.0, dist - travel) * trail;
+    let streak = smoothstep(w, 0.0, abs(dist - travel)) * trail;
+    let a = clamp(max(streak, blast * 0.4), 0.0, 1.0) * inten;
+    let col = mix(cA, cB, clamp(h, 0.0, 1.0));
+    return vec4<f32>(col, clamp(a, 0.0, 1.0));
+}
+
+fn fxMagic(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let center = vec2<f32>(0.5, 0.5);
+    let dv = p - center;
+    let r = length(dv);
+    let ang = atan2(dv.y, dv.x);
+    let swirl = fbm(vec2<f32>(r * 8.0 * scl + time * 0.5, ang * 3.0 + time * 0.8), 4);
+    let halo = smoothstep(0.5, 0.1, r) * 0.4 * dens;
+    let wisp = smoothstep(1.0 - dens * 0.8, 1.5 - dens * 0.8, swirl) * (0.5 + 0.5 * sin(r * 20.0 * scl - time * 3.0));
+    let a = clamp((halo + wisp * 0.8) * inten, 0.0, 1.0);
+    let col = mix(cA, cB, clamp(swirl, 0.0, 1.0));
+    return vec4<f32>(col * 0.8 + vec3<f32>(1.0) * halo * 0.4, a);
+}
+
+fn fxLensFlare(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let center = vec2<f32>(0.5, 0.5);
+    let dv = p - center;
+    let r = length(dv) * scl;
+    let ang = atan2(dv.y, dv.x);
+    // Radial streak
+    let streakCount = 2.0 * floor(1.0 + dens * 3.0);
+    let streak = smoothstep(0.35, 0.6, fract(ang / 3.14159 * streakCount + 0.5)) * pow(1.0 - r, 3.0);
+    // Concentric halos / chromatic rings
+    let rings = (0.5 + 0.5 * sin(r * 40.0 - time * 2.0)) * dens;
+    let core = smoothstep(0.25, 0.0, r);
+    let chroma = mix(cA, cB, 0.5 + 0.5 * cos(ang * 3.0 + r * 30.0));
+    let a = clamp((core * 0.9 + streak * 0.5 * dens + rings * 0.15 * (1.0 - r)) * inten, 0.0, 1.0);
+    return vec4<f32>(chroma, a);
+}
+
+fn fxLightning(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    // Periodic bolt striking vertically, flickering briefly
+    let period = mix(4.0, 0.6, clamp(dens, 0.0, 1.0));
+    let cycle = fract(time / period);
+    let flashWindow = mix(0.05, 0.35, clamp(dens, 0.0, 1.0));
+    let flash = smoothstep(flashWindow, 0.0, cycle);
+    
+    let tFlicker = floor(time * 60.0);
+    let flickerVal = tFlicker - 10000.0 * floor(tFlicker / 10000.0);
+    let flicker = step(hash1(flickerVal * 1.7), 0.8); // rapid on/off shimmer
+
+    // Jitter a vertical bolt with per-row hashes and interpolate between rows
+    let rows = 18.0 * scl;
+    let rg = p.y * rows;
+    let row = floor(rg);
+    let fr = fract(rg);
+    
+    let tLightning = floor(time * 24.0);
+    let lightningVal = tLightning - 10000.0 * floor(tLightning / 10000.0);
+    let x0 = 0.3 + 0.4 * hash1(row * 13.7 + lightningVal * 3.1);
+    let x1 = 0.3 + 0.4 * hash1((row + 1.0) * 13.7 + lightningVal * 3.1);
+    let boltX = mix(x0, x1, fr);
+
+    // Secondary tiny forks
+    let forkDrift = (hash1(row * 7.3) - 0.5) * 0.12 * smoothstep(0.0, 0.6, 1.0 - p.y);
+    let boltDist = abs(p.x - (boltX + forkDrift)) * scl;
+    let core = smoothstep(0.012, 0.0, boltDist);
+    let glow = smoothstep(0.07, 0.0, boltDist) * 0.5;
+    let a = clamp((core + glow) * flash * flicker * inten, 0.0, 1.0);
+    let col = mix(cA, cB, clamp(boltDist * 8.0, 0.0, 1.0) + 0.3 * flash);
+    // Soft ambient flash behind the bolt
+    let amb = smoothstep(0.35, 0.0, length(p - vec2<f32>(boltX, p.y)) * scl) * flash * 0.15;
+    return vec4<f32>(col * (1.0 + amb), clamp(a + amb, 0.0, 1.0));
+}
+
+fn fxEnergyBeam(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    let src = vec2<f32>(0.15, 0.5);
+    let dirv = vec2<f32>(1.0, 0.0);
+    let w = p - src;
+    let along = dot(w, dirv) * scl;
+    let perp = dot(w, vec2<f32>(-dirv.y, dirv.x)) * scl;
+    let beamWidth = 0.01 + 0.03 * dens;
+    let glowWidth = 0.05 + 0.1 * dens;
+    let core = smoothstep(beamWidth, 0.0, abs(perp));
+    let glow = smoothstep(glowWidth, 0.0, abs(perp)) * 0.4 * dens;
+    let falloff = smoothstep(0.0, 1.0, along);
+    let pulse = 0.7 + 0.3 * sin(along * 30.0 - time * 10.0);
+    let a = clamp((core + glow) * falloff * pulse * inten, 0.0, 1.0);
+    let col = mix(cA, cB, clamp(along, 0.0, 1.0));
+    return vec4<f32>(col * (1.0 + glow * 2.0), a);
+}
+
+fn fxAurora(p: vec2<f32>, seedOff: f32, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {
+    // Northern lights: curtains hanging from a wavy band across the upper sky,
+    // rippling sideways, with fine vertical rays. cA at the base, cB at the top.
+    var acc = vec3<f32>(0.0);
+    var keep = 1.0;
+    for (var k = 0; k < 3; k++) {
+        let fk = f32(k);
+        let x = p.x * (1.0 + fk * 0.35) * scl * 1.5 + seedOff * 13.0 + fk * 3.1;
+        // Curtain base line, a slow wave across the frame.
+        let base = 0.42 + fk * 0.06 + 0.12 * (fbm(vec2<f32>(x * 1.3, time * 0.05 + fk), 3) - 0.5)
+            + 0.05 * sin(x * 4.0 + time * 0.3 + fk);
+        let h = 0.38 + 0.2 * fbm(vec2<f32>(x * 2.0 + 7.0, time * 0.04), 3);
+        let d = base - p.y; // 0 at the base, rising upward
+        let body = smoothstep(-0.06, 0.035, d) * pow(1.0 - smoothstep(0.0, h, d), 1.5);
+        // Vertical rays drifting sideways.
+        let rn = fbm(vec2<f32>(x * 40.0 + time * 0.3, d * 2.0 - time * 0.1), 3);
+        let rays = 0.25 + 1.2 * rn * rn;
+        let fold = 0.6 + 0.4 * sin(x * 9.0 + time * 0.5 + fbm(vec2<f32>(x * 3.0, time * 0.1), 2) * 6.0);
+        let a = body * rays * fold * (1.0 - fk * 0.25);
+        let col = mix(cA, cB, clamp(d / max(h, 1e-3), 0.0, 1.0));
+        acc += col * a;
+        keep *= 1.0 - clamp(a, 0.0, 1.0);
+    }
+    let alpha = 1.0 - keep;
+    let a = clamp(alpha * (0.35 + 0.65 * dens) * inten * 1.4, 0.0, 1.0);
+    return vec4<f32>(acc / max(alpha, 1e-3) * min(alpha * 2.0, 1.0), a);
+}
+
+// ---- main dispatch ---------------------------------------------------------
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+    let density   = get_field(u.density,   u.hasSigDensity,   densityTex,   signalSamp);
+    let scale     = get_field(u.scale,     u.hasSigScale,     scaleTex,     signalSamp);
+    let speed     = get_field(u.speed,     u.hasSigSpeed,     speedTex,     signalSamp);
+    let intensity = get_field(u.intensity, u.hasSigIntensity, intensityTex, signalSamp);
+    let seed      = get_field(u.seed,      u.hasSigSeed,      seedTex,      signalSamp);
+
+    let isVideo = u.outputType > 0.5;
+    let time = select(0.0, u.time * max(speed, 1e-4), isVideo);
+    let seedOff = fract(seed * 1.618033);
+
+    // Aspect correction
+    let uv = in.uv;
+    let p = vec2<f32>(uv.x, uv.y);
+
+    // Move to a seed-scrambled space so different seeds look different
+    let sp = p + vec2<f32>(seedOff * 17.0, seedOff * 31.0);
+
+    var eff = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+    let cA = u.colorStart.rgb;
+    let cB = u.colorEnd.rgb;
+    let scl = max(scale, 1e-4);
+    let factor = scl * 100.0;
+
+    if (u.effectType < 0.5) {
+        eff = fxSmoke(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 1.5) {
+        eff = fxFire(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 2.5) {
+        eff = fxRain(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 3.5) {
+        eff = fxSparks(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 4.5) {
+        eff = fxSnow(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 5.5) {
+        eff = fxDust(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 6.5) {
+        eff = fxLightning(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 7.5) {
+        eff = fxMagic(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 8.5) {
+        eff = fxLensFlare(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 9.5) {
+        eff = fxEmbers(sp, time, factor, density, intensity, cA, cB);
+    } else if (u.effectType < 10.5) {
+        eff = fxEnergyBeam(sp, time, factor, density, intensity, cA, cB);
+    } else {
+        eff = fxAurora(p, seedOff, time, factor, density, intensity, cA, cB);
+    }
+
+    // Straight alpha is fine for compositing onto a transparent canvas.
+    let a = clamp(eff.a, 0.0, 1.0);
+    return vec4<f32>(clamp(eff.rgb, vec3<f32>(0.0), vec3<f32>(1.0)) * a, a);
+}
+`;
+const vfxUniformData = new Float32Array(24);
+const getDeviceLayouts = perDevice((device) => ({
+	uniformLayout: fragmentBindGroupLayout(device, ["uniform"]),
+	signalsLayout: texturesLayout(device, 5),
+	pipelineCache: /* @__PURE__ */ new Map()
+}));
+function getVFXResources(device, format) {
+	const layouts = getDeviceLayouts(device);
+	const cacheKey = `procedural_vfx_${format}`;
+	let pipeline = layouts.pipelineCache.get(cacheKey);
+	if (!pipeline) {
+		const vfxModule = device.createShaderModule({
+			label: `procedural_vfx_${format}.wgsl`,
+			code: VFX_SHADER
+		});
+		pipeline = createFullscreenPipeline(device, {
+			label: `ProceduralVFXPipeline_${format}`,
+			module: vfxModule,
+			layouts: [layouts.uniformLayout, layouts.signalsLayout],
+			format
+		});
+		layouts.pipelineCache.set(cacheKey, pipeline);
+	}
+	return {
+		vfxPipeline: pipeline,
+		uniformLayout: layouts.uniformLayout,
+		signalsLayout: layouts.signalsLayout
+	};
+}
+function hexToRgba(hex) {
+	let h = hex.replace("#", "");
+	if (h.length === 3 || h.length === 4) h = h.split("").map((c) => c + c).join("");
+	const r = parseInt(h.substring(0, 2), 16) / 255;
+	const g = parseInt(h.substring(2, 4), 16) / 255;
+	const b = parseInt(h.substring(4, 6), 16) / 255;
+	let a = 1;
+	if (h.length === 8) a = parseInt(h.substring(6, 8), 16) / 255;
+	return [
+		r,
+		g,
+		b,
+		a
+	];
+}
+const VFX_EFFECT_INDEX = {
+	Smoke: 0,
+	Fire: 1,
+	Rain: 2,
+	Sparks: 3,
+	Snow: 4,
+	Dust: 5,
+	Lightning: 6,
+	Magic: 7,
+	LensFlare: 8,
+	Embers: 9,
+	EnergyBeam: 10,
+	Aurora: 11
+};
+const ProceduralVFXWebGPURenderer = async (args) => {
+	const { ctx, encoder, pass, targetWidth, targetHeight, props } = args;
+	const op = props.virtualMedia?.operation;
+	if (op?.op !== "ProceduralVFX" || !op) return;
+	const { vfxPipeline: pipeline, uniformLayout: uLayout, signalsLayout: sigLayout } = getVFXResources(ctx.device, ctx.renderer.format);
+	const frame = props.frame ?? 0;
+	const fps = props.fps || 30;
+	const densityInfo = resolveSignalField(op, "density", .6);
+	const scaleInfo = resolveSignalField(op, "scale", .01);
+	const speedInfo = resolveSignalField(op, "speed", 1);
+	const intensityInfo = resolveSignalField(op, "intensity", .8);
+	const seedInfo = resolveSignalField(op, "seed", 1234);
+	const effectIndex = VFX_EFFECT_INDEX[op.effectType ?? "Smoke"] ?? 0;
+	const outputTypeVal = op.outputType === "Video" ? 1 : 0;
+	const { elapsedSeconds, durationSeconds } = signalTiming(props, frame, fps);
+	const colorStartVal = hexToRgba(op.colorStart ?? "#ffffff");
+	const colorEndVal = hexToRgba(op.colorEnd ?? "#ff5500");
+	vfxUniformData[0] = effectIndex;
+	vfxUniformData[1] = outputTypeVal;
+	vfxUniformData[2] = elapsedSeconds;
+	vfxUniformData[3] = 0;
+	vfxUniformData[4] = densityInfo.value;
+	vfxUniformData[5] = scaleInfo.value;
+	vfxUniformData[6] = speedInfo.value;
+	vfxUniformData[7] = intensityInfo.value;
+	vfxUniformData[8] = seedInfo.value;
+	vfxUniformData[9] = densityInfo.hasSignal ? 1 : 0;
+	vfxUniformData[10] = scaleInfo.hasSignal ? 1 : 0;
+	vfxUniformData[11] = speedInfo.hasSignal ? 1 : 0;
+	vfxUniformData[12] = intensityInfo.hasSignal ? 1 : 0;
+	vfxUniformData[13] = seedInfo.hasSignal ? 1 : 0;
+	vfxUniformData[14] = 0;
+	vfxUniformData[15] = 0;
+	vfxUniformData[16] = colorStartVal[0];
+	vfxUniformData[17] = colorStartVal[1];
+	vfxUniformData[18] = colorStartVal[2];
+	vfxUniformData[19] = colorStartVal[3];
+	vfxUniformData[20] = colorEndVal[0];
+	vfxUniformData[21] = colorEndVal[1];
+	vfxUniformData[22] = colorEndVal[2];
+	vfxUniformData[23] = colorEndVal[3];
+	const uniformBuffer = ctx.renderer.getTemporaryBuffer(vfxUniformData);
+	const signalFields = [
+		{
+			name: "density",
+			info: densityInfo
+		},
+		{
+			name: "scale",
+			info: scaleInfo
+		},
+		{
+			name: "speed",
+			info: speedInfo
+		},
+		{
+			name: "intensity",
+			info: intensityInfo
+		},
+		{
+			name: "seed",
+			info: seedInfo
+		}
+	];
+	const signalViews = [];
+	const sampler = ctx.renderer.samplerCache.getSampler(ctx.device);
+	for (const f of signalFields) if (!!(f.info.hasSignal && f.info.sd)) {
+		const view = signalRegistry.getOrCreate2DTextureView(ctx.device, encoder, f.info.sd?.nodeId ?? `procedural_vfx_${f.name}_sig`, elapsedSeconds, durationSeconds, f.info.sd, targetWidth, targetHeight, props.renderId, frame, fps);
+		signalViews.push(view);
+	} else signalViews.push(signalRegistry.getDummy1x1TextureView(ctx.device));
+	pass.setPipeline(pipeline);
+	pass.setBindGroup(0, ctx.device.createBindGroup({
+		layout: uLayout,
+		entries: [{
+			binding: 0,
+			resource: { buffer: uniformBuffer }
+		}]
+	}));
+	pass.setBindGroup(1, ctx.device.createBindGroup({
+		layout: sigLayout,
+		entries: [
+			{
+				binding: 0,
+				resource: signalViews[0]
+			},
+			{
+				binding: 1,
+				resource: signalViews[1]
+			},
+			{
+				binding: 2,
+				resource: signalViews[2]
+			},
+			{
+				binding: 3,
+				resource: signalViews[3]
+			},
+			{
+				binding: 4,
+				resource: signalViews[4]
+			},
+			{
+				binding: 5,
+				resource: sampler
+			}
+		]
+	}));
+	pass.draw(4);
+};
+var renderers_default = defineRenderer({ WebGPURenderer: ProceduralVFXWebGPURenderer });
+
+//#endregion
+export { ProceduralVFXWebGPURenderer, renderers_default as default };
+//# sourceMappingURL=renderer-HMl2V4iM.mjs.map

package/dist/renderer-HMl2V4iM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-HMl2V4iM.mjs","names":[],"sources":["../../../nodes/node-procedural-vfx/dist/renderers-DiW7Lt7Y.mjs"],"sourcesContent":["import { defineRenderer } from \"@framefields/node-sdk/renderer\";\nimport { resolveSignalField } from \"@framefields/node-sdk\";\nimport { FULLSCREEN_QUAD_WGSL, createFullscreenPipeline, fragmentBindGroupLayout, perDevice, signalTiming, texturesLayout } from \"@framefields/node-sdk/gpu\";\nimport { signalRegistry } from \"@framefields/webgpu-renderers\";\n\n//#region src/renderers/webgpu-renderer.ts\nconst VFX_SHADER = `\nstruct VFXUniforms {\n    effectType             : f32,\n    outputType             : f32,\n    time                   : f32,\n    _pad0                  : f32,\n\n    density                : f32,\n    scale                  : f32,\n    speed                  : f32,\n    intensity              : f32,\n\n    seed                   : f32,\n    hasSigDensity          : f32,\n    hasSigScale            : f32,\n    hasSigSpeed            : f32,\n\n    hasSigIntensity        : f32,\n    hasSigSeed             : f32,\n    _pad1                  : f32,\n    _pad2                  : f32,\n\n    colorStart             : vec4<f32>,\n    colorEnd               : vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u : VFXUniforms;\n\n@group(1) @binding(0) var densityTex   : texture_2d<f32>;\n@group(1) @binding(1) var scaleTex     : texture_2d<f32>;\n@group(1) @binding(2) var speedTex     : texture_2d<f32>;\n@group(1) @binding(3) var intensityTex : texture_2d<f32>;\n@group(1) @binding(4) var seedTex      : texture_2d<f32>;\n@group(1) @binding(5) var signalSamp   : sampler;\n${FULLSCREEN_QUAD_WGSL}\n\n// ---- hashing & noise primitives -------------------------------------------\nfn hash21(p: vec2<f32>) -> vec2<f32> {\n    let p3 = fract(vec3<f32>(p.xyx) * vec3<f32>(0.1031, 0.1030, 0.0973));\n    let p4 = p3 + dot(p3, p3.yzx + 33.33);\n    return fract((p4.xx + p4.yz) * p4.zy);\n}\n\nfn hash1(n: f32) -> f32 {\n    return fract(sin(n) * 43758.5453);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n    let i = floor(p);\n    let f = fract(p);\n    let u = f * f * (3.0 - 2.0 * f);\n    let a = hash1(dot(i, vec2<f32>(127.1, 311.7)));\n    let b = hash1(dot(i + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7)));\n    let c = hash1(dot(i + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7)));\n    let d = hash1(dot(i + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7)));\n    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfn fbm(p: vec2<f32>, octaves: i32) -> f32 {\n    var value = 0.0;\n    var amp = 0.5;\n    var freq = 1.0;\n    for (var i = 0; i < 8; i++) {\n        if (i >= octaves) { break; }\n        value += amp * valueNoise(p * freq);\n        freq *= 2.0;\n        amp *= 0.5;\n    }\n    return value;\n}\n\nfn get_field(val: f32, hasSig: f32, tex: texture_2d<f32>, samp: sampler) -> f32 {\n    if (hasSig > 0.5) {\n        return textureSampleLevel(tex, samp, vec2<f32>(0.5, 0.5), 0.0).r;\n    }\n    return val;\n}\n\n// ---- effect synthesizers (return straight-alpha RGBA) ----------------------\nfn fxSmoke(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let sp = p * scl;\n    // Domain-warped FBM gives structured puffs instead of a solid fill.\n    let q = vec2<f32>(fbm(sp + time * 0.10, 4), fbm(sp + vec2<f32>(5.2, 1.3) + time * 0.08, 4));\n    let f = fbm(sp + 4.0 * q + vec2<f32>(1.7, 9.2) + time * 0.05, 4); // ~[0, 0.94]\n    // Billowing plume: denser at the base (bottom, p.y=0), dissipating toward the top.\n    let vgrad = 1.0 - smoothstep(0.45, 0.9, p.y);\n    let n = f * 2.0 - 1.0; // remap to [-1, 1]\n    // Thresholded so only bright fbm patches are opaque -> reads as puffs, not solid.\n    let cov = smoothstep(0.28, 0.6, n) * dens * (0.25 + 0.75 * vgrad);\n    let alpha = cov * inten;\n    let col = mix(cB * 0.35, cA, clamp(f + vgrad * 0.5, 0.0, 1.0));\n    return vec4<f32>(col, clamp(alpha, 0.0, 1.0));\n}\n\nfn fxFire(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let pn = vec2<f32>(p.x * 1.5, p.y) * scl;\n    let n = fbm(pn * 6.0 + vec2<f32>(time * 2.0, time * 3.0), 4);\n    // Heat concentrated near base, flickering upward\n    let heat = n * smoothstep(1.0, 0.0 + (1.0 - dens) * 0.3, p.y);\n    // Channeled vertical columns\n    let columns = smoothstep(0.45, 0.9, n + 0.4 * sin(p.x * (20.0 + 40.0 * dens) * scl + time * 8.0));\n    let d = clamp(heat * inten + columns * 0.3 * inten, 0.0, 1.0);\n    // Fire color ramp mapped dynamically to cA and cB\n    let dark = cB * 0.15;\n    let orange = cB;\n    let yellow = mix(cB, cA, 0.5);\n    let white = cA;\n    var col = mix(dark, orange, smoothstep(0.0, 0.4, d));\n    col = mix(col, yellow, smoothstep(0.4, 0.75, d));\n    col = mix(col, white, smoothstep(0.75, 1.0, d));\n    let alpha = smoothstep(0.0, 0.3, d) * inten;\n    return vec4<f32>(col, clamp(alpha, 0.0, 1.0));\n}\n\nfn fxRain(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let n = (60.0 * dens + 4.0) * scl;\n    let gx = floor(p.x * n);\n    let h = hash1(gx);\n    let speed = 0.8 + h;\n    let yFrac = fract(p.y * 8.0 - time * speed);\n    let dropY = abs(yFrac - 0.5);\n    let reveal = step(0.35, yFrac);\n    let st = smoothstep(0.18, 0.02, dropY);\n    let d = st * reveal;\n    let g = smoothstep(0.18, 0.02, abs(fract(p.x * n) + h * 0.2 - 0.5));\n    let a = d * g * inten;\n    let col = mix(cA, cB, h);\n    return vec4<f32>(col, clamp(a, 0.0, 1.0));\n}\n\nfn fxSnow(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let n = (50.0 * dens + 6.0) * scl;\n    let cell = floor(p * n);\n    let f = fract(p * n);\n    let h = hash21(cell);\n    let center = vec2<f32>(0.5, 0.5) + 0.3 * hash21(cell + 7.0);\n    let sway = 0.1 * sin(time * 1.2 + cell.y * 3.0);\n    // Fall downward (toward p.y=0, the bottom): subtract an advancing phase.\n    let fall = fract(time * (0.25 + 0.45 * h.y) + h.x);\n    let pos = vec2<f32>(f.x - center.x - sway, f.y - center.y) - vec2<f32>(0.0, fall);\n    let d = length(pos);\n    let size = 0.05 + 0.07 * h.x;\n    let a = smoothstep(size, size * 0.4, d) * inten;\n    let col = mix(cA, cB, h.x);\n    return vec4<f32>(col, clamp(a, 0.0, 1.0));\n}\n\nfn fxDust(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let n = (90.0 * dens + 6.0) * scl;\n    let cell = floor(p * n);\n    let f = fract(p * n);\n    let h = hash21(cell);\n    let center = h;\n    let drift = fract(time * 0.05 * (0.5 + h.y) + cell.x * 0.01);\n    let pos = vec2<f32>(f.x - center.x, f.y - center.y) + vec2<f32>((drift - 0.5) * 0.03, 0.0);\n    let d = length(pos);\n    let a = smoothstep(0.12, 0.0, d) * smoothstep(0.0, 0.3, dens) * inten * 0.6;\n    let col = mix(cA, cB, h.y);\n    return vec4<f32>(col, clamp(a, 0.0, 1.0));\n}\n\nfn fxEmbers(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let n = (50.0 * dens + 4.0) * scl;\n    let cell = floor(p * n);\n    let f = fract(p * n);\n    let h = hash21(cell);\n    let sway = 0.12 * sin(time * 2.0 + cell.y * 2.0);\n    let rise = fract(time * 0.18 * (0.7 + h.y) + cell.y * 0.12);\n    // Rising: as rise grows, move toward p.y=1 (top).\n    let pos = vec2<f32>(f.x - 0.5 - sway, f.y + rise * 1.2);\n    let d = length(pos);\n    let a = smoothstep(0.12, 0.0, d) * (1.0 - rise) * inten;\n    let col = mix(cA, cB, clamp(rise, 0.0, 1.0));\n    return vec4<f32>(col, clamp(a, 0.0, 1.0));\n}\n\nfn fxSparks(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    // Burst radiating from a low-center source; travel grows over time so it expands outward.\n    let src = vec2<f32>(0.5, 0.15);\n    let dir = p - src;\n    let dist = length(dir);\n    let ang = atan2(dir.y, dir.x);\n    let n = (20.0 * dens + 5.0) * scl;\n    let seg = floor(ang * n);\n    let tFrame = floor(time * 3.0);\n    let timeVal = tFrame - 10000.0 * floor(tFrame / 10000.0);\n    let h = hash1(seg + timeVal * 97.0);\n    let launch = fract(0.5 + h + time * 0.5);\n    let travel = launch * 0.8;\n    let trail = smoothstep(0.9, 0.4, dist - travel);\n    let w = 0.02 + 0.02 * h;\n    let blast = smoothstep(0.0, w * 2.0, dist - travel) * trail;\n    let streak = smoothstep(w, 0.0, abs(dist - travel)) * trail;\n    let a = clamp(max(streak, blast * 0.4), 0.0, 1.0) * inten;\n    let col = mix(cA, cB, clamp(h, 0.0, 1.0));\n    return vec4<f32>(col, clamp(a, 0.0, 1.0));\n}\n\nfn fxMagic(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let center = vec2<f32>(0.5, 0.5);\n    let dv = p - center;\n    let r = length(dv);\n    let ang = atan2(dv.y, dv.x);\n    let swirl = fbm(vec2<f32>(r * 8.0 * scl + time * 0.5, ang * 3.0 + time * 0.8), 4);\n    let halo = smoothstep(0.5, 0.1, r) * 0.4 * dens;\n    let wisp = smoothstep(1.0 - dens * 0.8, 1.5 - dens * 0.8, swirl) * (0.5 + 0.5 * sin(r * 20.0 * scl - time * 3.0));\n    let a = clamp((halo + wisp * 0.8) * inten, 0.0, 1.0);\n    let col = mix(cA, cB, clamp(swirl, 0.0, 1.0));\n    return vec4<f32>(col * 0.8 + vec3<f32>(1.0) * halo * 0.4, a);\n}\n\nfn fxLensFlare(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let center = vec2<f32>(0.5, 0.5);\n    let dv = p - center;\n    let r = length(dv) * scl;\n    let ang = atan2(dv.y, dv.x);\n    // Radial streak\n    let streakCount = 2.0 * floor(1.0 + dens * 3.0);\n    let streak = smoothstep(0.35, 0.6, fract(ang / 3.14159 * streakCount + 0.5)) * pow(1.0 - r, 3.0);\n    // Concentric halos / chromatic rings\n    let rings = (0.5 + 0.5 * sin(r * 40.0 - time * 2.0)) * dens;\n    let core = smoothstep(0.25, 0.0, r);\n    let chroma = mix(cA, cB, 0.5 + 0.5 * cos(ang * 3.0 + r * 30.0));\n    let a = clamp((core * 0.9 + streak * 0.5 * dens + rings * 0.15 * (1.0 - r)) * inten, 0.0, 1.0);\n    return vec4<f32>(chroma, a);\n}\n\nfn fxLightning(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    // Periodic bolt striking vertically, flickering briefly\n    let period = mix(4.0, 0.6, clamp(dens, 0.0, 1.0));\n    let cycle = fract(time / period);\n    let flashWindow = mix(0.05, 0.35, clamp(dens, 0.0, 1.0));\n    let flash = smoothstep(flashWindow, 0.0, cycle);\n    \n    let tFlicker = floor(time * 60.0);\n    let flickerVal = tFlicker - 10000.0 * floor(tFlicker / 10000.0);\n    let flicker = step(hash1(flickerVal * 1.7), 0.8); // rapid on/off shimmer\n\n    // Jitter a vertical bolt with per-row hashes and interpolate between rows\n    let rows = 18.0 * scl;\n    let rg = p.y * rows;\n    let row = floor(rg);\n    let fr = fract(rg);\n    \n    let tLightning = floor(time * 24.0);\n    let lightningVal = tLightning - 10000.0 * floor(tLightning / 10000.0);\n    let x0 = 0.3 + 0.4 * hash1(row * 13.7 + lightningVal * 3.1);\n    let x1 = 0.3 + 0.4 * hash1((row + 1.0) * 13.7 + lightningVal * 3.1);\n    let boltX = mix(x0, x1, fr);\n\n    // Secondary tiny forks\n    let forkDrift = (hash1(row * 7.3) - 0.5) * 0.12 * smoothstep(0.0, 0.6, 1.0 - p.y);\n    let boltDist = abs(p.x - (boltX + forkDrift)) * scl;\n    let core = smoothstep(0.012, 0.0, boltDist);\n    let glow = smoothstep(0.07, 0.0, boltDist) * 0.5;\n    let a = clamp((core + glow) * flash * flicker * inten, 0.0, 1.0);\n    let col = mix(cA, cB, clamp(boltDist * 8.0, 0.0, 1.0) + 0.3 * flash);\n    // Soft ambient flash behind the bolt\n    let amb = smoothstep(0.35, 0.0, length(p - vec2<f32>(boltX, p.y)) * scl) * flash * 0.15;\n    return vec4<f32>(col * (1.0 + amb), clamp(a + amb, 0.0, 1.0));\n}\n\nfn fxEnergyBeam(p: vec2<f32>, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    let src = vec2<f32>(0.15, 0.5);\n    let dirv = vec2<f32>(1.0, 0.0);\n    let w = p - src;\n    let along = dot(w, dirv) * scl;\n    let perp = dot(w, vec2<f32>(-dirv.y, dirv.x)) * scl;\n    let beamWidth = 0.01 + 0.03 * dens;\n    let glowWidth = 0.05 + 0.1 * dens;\n    let core = smoothstep(beamWidth, 0.0, abs(perp));\n    let glow = smoothstep(glowWidth, 0.0, abs(perp)) * 0.4 * dens;\n    let falloff = smoothstep(0.0, 1.0, along);\n    let pulse = 0.7 + 0.3 * sin(along * 30.0 - time * 10.0);\n    let a = clamp((core + glow) * falloff * pulse * inten, 0.0, 1.0);\n    let col = mix(cA, cB, clamp(along, 0.0, 1.0));\n    return vec4<f32>(col * (1.0 + glow * 2.0), a);\n}\n\nfn fxAurora(p: vec2<f32>, seedOff: f32, time: f32, scl: f32, dens: f32, inten: f32, cA: vec3<f32>, cB: vec3<f32>) -> vec4<f32> {\n    // Northern lights: curtains hanging from a wavy band across the upper sky,\n    // rippling sideways, with fine vertical rays. cA at the base, cB at the top.\n    var acc = vec3<f32>(0.0);\n    var keep = 1.0;\n    for (var k = 0; k < 3; k++) {\n        let fk = f32(k);\n        let x = p.x * (1.0 + fk * 0.35) * scl * 1.5 + seedOff * 13.0 + fk * 3.1;\n        // Curtain base line, a slow wave across the frame.\n        let base = 0.42 + fk * 0.06 + 0.12 * (fbm(vec2<f32>(x * 1.3, time * 0.05 + fk), 3) - 0.5)\n            + 0.05 * sin(x * 4.0 + time * 0.3 + fk);\n        let h = 0.38 + 0.2 * fbm(vec2<f32>(x * 2.0 + 7.0, time * 0.04), 3);\n        let d = base - p.y; // 0 at the base, rising upward\n        let body = smoothstep(-0.06, 0.035, d) * pow(1.0 - smoothstep(0.0, h, d), 1.5);\n        // Vertical rays drifting sideways.\n        let rn = fbm(vec2<f32>(x * 40.0 + time * 0.3, d * 2.0 - time * 0.1), 3);\n        let rays = 0.25 + 1.2 * rn * rn;\n        let fold = 0.6 + 0.4 * sin(x * 9.0 + time * 0.5 + fbm(vec2<f32>(x * 3.0, time * 0.1), 2) * 6.0);\n        let a = body * rays * fold * (1.0 - fk * 0.25);\n        let col = mix(cA, cB, clamp(d / max(h, 1e-3), 0.0, 1.0));\n        acc += col * a;\n        keep *= 1.0 - clamp(a, 0.0, 1.0);\n    }\n    let alpha = 1.0 - keep;\n    let a = clamp(alpha * (0.35 + 0.65 * dens) * inten * 1.4, 0.0, 1.0);\n    return vec4<f32>(acc / max(alpha, 1e-3) * min(alpha * 2.0, 1.0), a);\n}\n\n// ---- main dispatch ---------------------------------------------------------\n@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {\n    let density   = get_field(u.density,   u.hasSigDensity,   densityTex,   signalSamp);\n    let scale     = get_field(u.scale,     u.hasSigScale,     scaleTex,     signalSamp);\n    let speed     = get_field(u.speed,     u.hasSigSpeed,     speedTex,     signalSamp);\n    let intensity = get_field(u.intensity, u.hasSigIntensity, intensityTex, signalSamp);\n    let seed      = get_field(u.seed,      u.hasSigSeed,      seedTex,      signalSamp);\n\n    let isVideo = u.outputType > 0.5;\n    let time = select(0.0, u.time * max(speed, 1e-4), isVideo);\n    let seedOff = fract(seed * 1.618033);\n\n    // Aspect correction\n    let uv = in.uv;\n    let p = vec2<f32>(uv.x, uv.y);\n\n    // Move to a seed-scrambled space so different seeds look different\n    let sp = p + vec2<f32>(seedOff * 17.0, seedOff * 31.0);\n\n    var eff = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n    let cA = u.colorStart.rgb;\n    let cB = u.colorEnd.rgb;\n    let scl = max(scale, 1e-4);\n    let factor = scl * 100.0;\n\n    if (u.effectType < 0.5) {\n        eff = fxSmoke(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 1.5) {\n        eff = fxFire(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 2.5) {\n        eff = fxRain(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 3.5) {\n        eff = fxSparks(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 4.5) {\n        eff = fxSnow(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 5.5) {\n        eff = fxDust(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 6.5) {\n        eff = fxLightning(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 7.5) {\n        eff = fxMagic(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 8.5) {\n        eff = fxLensFlare(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 9.5) {\n        eff = fxEmbers(sp, time, factor, density, intensity, cA, cB);\n    } else if (u.effectType < 10.5) {\n        eff = fxEnergyBeam(sp, time, factor, density, intensity, cA, cB);\n    } else {\n        eff = fxAurora(p, seedOff, time, factor, density, intensity, cA, cB);\n    }\n\n    // Straight alpha is fine for compositing onto a transparent canvas.\n    let a = clamp(eff.a, 0.0, 1.0);\n    return vec4<f32>(clamp(eff.rgb, vec3<f32>(0.0), vec3<f32>(1.0)) * a, a);\n}\n`;\nconst vfxUniformData = new Float32Array(24);\nconst getDeviceLayouts = perDevice((device) => ({\n\tuniformLayout: fragmentBindGroupLayout(device, [\"uniform\"]),\n\tsignalsLayout: texturesLayout(device, 5),\n\tpipelineCache: /* @__PURE__ */ new Map()\n}));\nfunction getVFXResources(device, format) {\n\tconst layouts = getDeviceLayouts(device);\n\tconst cacheKey = `procedural_vfx_${format}`;\n\tlet pipeline = layouts.pipelineCache.get(cacheKey);\n\tif (!pipeline) {\n\t\tconst vfxModule = device.createShaderModule({\n\t\t\tlabel: `procedural_vfx_${format}.wgsl`,\n\t\t\tcode: VFX_SHADER\n\t\t});\n\t\tpipeline = createFullscreenPipeline(device, {\n\t\t\tlabel: `ProceduralVFXPipeline_${format}`,\n\t\t\tmodule: vfxModule,\n\t\t\tlayouts: [layouts.uniformLayout, layouts.signalsLayout],\n\t\t\tformat\n\t\t});\n\t\tlayouts.pipelineCache.set(cacheKey, pipeline);\n\t}\n\treturn {\n\t\tvfxPipeline: pipeline,\n\t\tuniformLayout: layouts.uniformLayout,\n\t\tsignalsLayout: layouts.signalsLayout\n\t};\n}\nfunction hexToRgba(hex) {\n\tlet h = hex.replace(\"#\", \"\");\n\tif (h.length === 3 || h.length === 4) h = h.split(\"\").map((c) => c + c).join(\"\");\n\tconst r = parseInt(h.substring(0, 2), 16) / 255;\n\tconst g = parseInt(h.substring(2, 4), 16) / 255;\n\tconst b = parseInt(h.substring(4, 6), 16) / 255;\n\tlet a = 1;\n\tif (h.length === 8) a = parseInt(h.substring(6, 8), 16) / 255;\n\treturn [\n\t\tr,\n\t\tg,\n\t\tb,\n\t\ta\n\t];\n}\nconst VFX_EFFECT_INDEX = {\n\tSmoke: 0,\n\tFire: 1,\n\tRain: 2,\n\tSparks: 3,\n\tSnow: 4,\n\tDust: 5,\n\tLightning: 6,\n\tMagic: 7,\n\tLensFlare: 8,\n\tEmbers: 9,\n\tEnergyBeam: 10,\n\tAurora: 11\n};\nconst ProceduralVFXWebGPURenderer = async (args) => {\n\tconst { ctx, encoder, pass, targetWidth, targetHeight, props } = args;\n\tconst op = props.virtualMedia?.operation;\n\tif (op?.op !== \"ProceduralVFX\" || !op) return;\n\tconst { vfxPipeline: pipeline, uniformLayout: uLayout, signalsLayout: sigLayout } = getVFXResources(ctx.device, ctx.renderer.format);\n\tconst frame = props.frame ?? 0;\n\tconst fps = props.fps || 30;\n\tconst densityInfo = resolveSignalField(op, \"density\", .6);\n\tconst scaleInfo = resolveSignalField(op, \"scale\", .01);\n\tconst speedInfo = resolveSignalField(op, \"speed\", 1);\n\tconst intensityInfo = resolveSignalField(op, \"intensity\", .8);\n\tconst seedInfo = resolveSignalField(op, \"seed\", 1234);\n\tconst effectIndex = VFX_EFFECT_INDEX[op.effectType ?? \"Smoke\"] ?? 0;\n\tconst outputTypeVal = op.outputType === \"Video\" ? 1 : 0;\n\tconst { elapsedSeconds, durationSeconds } = signalTiming(props, frame, fps);\n\tconst colorStartVal = hexToRgba(op.colorStart ?? \"#ffffff\");\n\tconst colorEndVal = hexToRgba(op.colorEnd ?? \"#ff5500\");\n\tvfxUniformData[0] = effectIndex;\n\tvfxUniformData[1] = outputTypeVal;\n\tvfxUniformData[2] = elapsedSeconds;\n\tvfxUniformData[3] = 0;\n\tvfxUniformData[4] = densityInfo.value;\n\tvfxUniformData[5] = scaleInfo.value;\n\tvfxUniformData[6] = speedInfo.value;\n\tvfxUniformData[7] = intensityInfo.value;\n\tvfxUniformData[8] = seedInfo.value;\n\tvfxUniformData[9] = densityInfo.hasSignal ? 1 : 0;\n\tvfxUniformData[10] = scaleInfo.hasSignal ? 1 : 0;\n\tvfxUniformData[11] = speedInfo.hasSignal ? 1 : 0;\n\tvfxUniformData[12] = intensityInfo.hasSignal ? 1 : 0;\n\tvfxUniformData[13] = seedInfo.hasSignal ? 1 : 0;\n\tvfxUniformData[14] = 0;\n\tvfxUniformData[15] = 0;\n\tvfxUniformData[16] = colorStartVal[0];\n\tvfxUniformData[17] = colorStartVal[1];\n\tvfxUniformData[18] = colorStartVal[2];\n\tvfxUniformData[19] = colorStartVal[3];\n\tvfxUniformData[20] = colorEndVal[0];\n\tvfxUniformData[21] = colorEndVal[1];\n\tvfxUniformData[22] = colorEndVal[2];\n\tvfxUniformData[23] = colorEndVal[3];\n\tconst uniformBuffer = ctx.renderer.getTemporaryBuffer(vfxUniformData);\n\tconst signalFields = [\n\t\t{\n\t\t\tname: \"density\",\n\t\t\tinfo: densityInfo\n\t\t},\n\t\t{\n\t\t\tname: \"scale\",\n\t\t\tinfo: scaleInfo\n\t\t},\n\t\t{\n\t\t\tname: \"speed\",\n\t\t\tinfo: speedInfo\n\t\t},\n\t\t{\n\t\t\tname: \"intensity\",\n\t\t\tinfo: intensityInfo\n\t\t},\n\t\t{\n\t\t\tname: \"seed\",\n\t\t\tinfo: seedInfo\n\t\t}\n\t];\n\tconst signalViews = [];\n\tconst sampler = ctx.renderer.samplerCache.getSampler(ctx.device);\n\tfor (const f of signalFields) if (!!(f.info.hasSignal && f.info.sd)) {\n\t\tconst view = signalRegistry.getOrCreate2DTextureView(ctx.device, encoder, f.info.sd?.nodeId ?? `procedural_vfx_${f.name}_sig`, elapsedSeconds, durationSeconds, f.info.sd, targetWidth, targetHeight, props.renderId, frame, fps);\n\t\tsignalViews.push(view);\n\t} else signalViews.push(signalRegistry.getDummy1x1TextureView(ctx.device));\n\tpass.setPipeline(pipeline);\n\tpass.setBindGroup(0, ctx.device.createBindGroup({\n\t\tlayout: uLayout,\n\t\tentries: [{\n\t\t\tbinding: 0,\n\t\t\tresource: { buffer: uniformBuffer }\n\t\t}]\n\t}));\n\tpass.setBindGroup(1, ctx.device.createBindGroup({\n\t\tlayout: sigLayout,\n\t\tentries: [\n\t\t\t{\n\t\t\t\tbinding: 0,\n\t\t\t\tresource: signalViews[0]\n\t\t\t},\n\t\t\t{\n\t\t\t\tbinding: 1,\n\t\t\t\tresource: signalViews[1]\n\t\t\t},\n\t\t\t{\n\t\t\t\tbinding: 2,\n\t\t\t\tresource: signalViews[2]\n\t\t\t},\n\t\t\t{\n\t\t\t\tbinding: 3,\n\t\t\t\tresource: signalViews[3]\n\t\t\t},\n\t\t\t{\n\t\t\t\tbinding: 4,\n\t\t\t\tresource: signalViews[4]\n\t\t\t},\n\t\t\t{\n\t\t\t\tbinding: 5,\n\t\t\t\tresource: sampler\n\t\t\t}\n\t\t]\n\t}));\n\tpass.draw(4);\n};\n\n//#endregion\n//#region src/renderers/index.ts\nvar renderers_default = defineRenderer({ WebGPURenderer: ProceduralVFXWebGPURenderer });\n\n//#endregion\nexport { ProceduralVFXWebGPURenderer as n, renderers_default as t };\n//# sourceMappingURL=renderers-DiW7Lt7Y.mjs.map"],"mappings":";;;;;;AAMA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCjB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyUvB,MAAM,iBAAiB,IAAI,aAAa,GAAG;AAC3C,MAAM,mBAAmB,WAAW,YAAY;CAC/C,eAAe,wBAAwB,QAAQ,CAAC,UAAU,CAAC;CAC3D,eAAe,eAAe,QAAQ,EAAE;CACxC,+BAA+B,IAAI,KAAK;CACxC,EAAE;AACH,SAAS,gBAAgB,QAAQ,QAAQ;CACxC,MAAM,UAAU,iBAAiB,OAAO;CACxC,MAAM,WAAW,kBAAkB;CACnC,IAAI,WAAW,QAAQ,cAAc,IAAI,SAAS;AAClD,KAAI,CAAC,UAAU;EACd,MAAM,YAAY,OAAO,mBAAmB;GAC3C,OAAO,kBAAkB,OAAO;GAChC,MAAM;GACN,CAAC;AACF,aAAW,yBAAyB,QAAQ;GAC3C,OAAO,yBAAyB;GAChC,QAAQ;GACR,SAAS,CAAC,QAAQ,eAAe,QAAQ,cAAc;GACvD;GACA,CAAC;AACF,UAAQ,cAAc,IAAI,UAAU,SAAS;;AAE9C,QAAO;EACN,aAAa;EACb,eAAe,QAAQ;EACvB,eAAe,QAAQ;EACvB;;AAEF,SAAS,UAAU,KAAK;CACvB,IAAI,IAAI,IAAI,QAAQ,KAAK,GAAG;AAC5B,KAAI,EAAE,WAAW,KAAK,EAAE,WAAW,EAAG,KAAI,EAAE,MAAM,GAAG,CAAC,KAAK,MAAM,IAAI,EAAE,CAAC,KAAK,GAAG;CAChF,MAAM,IAAI,SAAS,EAAE,UAAU,GAAG,EAAE,EAAE,GAAG,GAAG;CAC5C,MAAM,IAAI,SAAS,EAAE,UAAU,GAAG,EAAE,EAAE,GAAG,GAAG;CAC5C,MAAM,IAAI,SAAS,EAAE,UAAU,GAAG,EAAE,EAAE,GAAG,GAAG;CAC5C,IAAI,IAAI;AACR,KAAI,EAAE,WAAW,EAAG,KAAI,SAAS,EAAE,UAAU,GAAG,EAAE,EAAE,GAAG,GAAG;AAC1D,QAAO;EACN;EACA;EACA;EACA;EACA;;AAEF,MAAM,mBAAmB;CACxB,OAAO;CACP,MAAM;CACN,MAAM;CACN,QAAQ;CACR,MAAM;CACN,MAAM;CACN,WAAW;CACX,OAAO;CACP,WAAW;CACX,QAAQ;CACR,YAAY;CACZ,QAAQ;CACR;AACD,MAAM,8BAA8B,OAAO,SAAS;CACnD,MAAM,EAAE,KAAK,SAAS,MAAM,aAAa,cAAc,UAAU;CACjE,MAAM,KAAK,MAAM,cAAc;AAC/B,KAAI,IAAI,OAAO,mBAAmB,CAAC,GAAI;CACvC,MAAM,EAAE,aAAa,UAAU,eAAe,SAAS,eAAe,cAAc,gBAAgB,IAAI,QAAQ,IAAI,SAAS,OAAO;CACpI,MAAM,QAAQ,MAAM,SAAS;CAC7B,MAAM,MAAM,MAAM,OAAO;CACzB,MAAM,cAAc,mBAAmB,IAAI,WAAW,GAAG;CACzD,MAAM,YAAY,mBAAmB,IAAI,SAAS,IAAI;CACtD,MAAM,YAAY,mBAAmB,IAAI,SAAS,EAAE;CACpD,MAAM,gBAAgB,mBAAmB,IAAI,aAAa,GAAG;CAC7D,MAAM,WAAW,mBAAmB,IAAI,QAAQ,KAAK;CACrD,MAAM,cAAc,iBAAiB,GAAG,cAAc,YAAY;CAClE,MAAM,gBAAgB,GAAG,eAAe,UAAU,IAAI;CACtD,MAAM,EAAE,gBAAgB,oBAAoB,aAAa,OAAO,OAAO,IAAI;CAC3E,MAAM,gBAAgB,UAAU,GAAG,cAAc,UAAU;CAC3D,MAAM,cAAc,UAAU,GAAG,YAAY,UAAU;AACvD,gBAAe,KAAK;AACpB,gBAAe,KAAK;AACpB,gBAAe,KAAK;AACpB,gBAAe,KAAK;AACpB,gBAAe,KAAK,YAAY;AAChC,gBAAe,KAAK,UAAU;AAC9B,gBAAe,KAAK,UAAU;AAC9B,gBAAe,KAAK,cAAc;AAClC,gBAAe,KAAK,SAAS;AAC7B,gBAAe,KAAK,YAAY,YAAY,IAAI;AAChD,gBAAe,MAAM,UAAU,YAAY,IAAI;AAC/C,gBAAe,MAAM,UAAU,YAAY,IAAI;AAC/C,gBAAe,MAAM,cAAc,YAAY,IAAI;AACnD,gBAAe,MAAM,SAAS,YAAY,IAAI;AAC9C,gBAAe,MAAM;AACrB,gBAAe,MAAM;AACrB,gBAAe,MAAM,cAAc;AACnC,gBAAe,MAAM,cAAc;AACnC,gBAAe,MAAM,cAAc;AACnC,gBAAe,MAAM,cAAc;AACnC,gBAAe,MAAM,YAAY;AACjC,gBAAe,MAAM,YAAY;AACjC,gBAAe,MAAM,YAAY;AACjC,gBAAe,MAAM,YAAY;CACjC,MAAM,gBAAgB,IAAI,SAAS,mBAAmB,eAAe;CACrE,MAAM,eAAe;EACpB;GACC,MAAM;GACN,MAAM;GACN;EACD;GACC,MAAM;GACN,MAAM;GACN;EACD;GACC,MAAM;GACN,MAAM;GACN;EACD;GACC,MAAM;GACN,MAAM;GACN;EACD;GACC,MAAM;GACN,MAAM;GACN;EACD;CACD,MAAM,cAAc,EAAE;CACtB,MAAM,UAAU,IAAI,SAAS,aAAa,WAAW,IAAI,OAAO;AAChE,MAAK,MAAM,KAAK,aAAc,KAAI,CAAC,EAAE,EAAE,KAAK,aAAa,EAAE,KAAK,KAAK;EACpE,MAAM,OAAO,eAAe,yBAAyB,IAAI,QAAQ,SAAS,EAAE,KAAK,IAAI,UAAU,kBAAkB,EAAE,KAAK,OAAO,gBAAgB,iBAAiB,EAAE,KAAK,IAAI,aAAa,cAAc,MAAM,UAAU,OAAO,IAAI;AACjO,cAAY,KAAK,KAAK;OAChB,aAAY,KAAK,eAAe,uBAAuB,IAAI,OAAO,CAAC;AAC1E,MAAK,YAAY,SAAS;AAC1B,MAAK,aAAa,GAAG,IAAI,OAAO,gBAAgB;EAC/C,QAAQ;EACR,SAAS,CAAC;GACT,SAAS;GACT,UAAU,EAAE,QAAQ,eAAe;GACnC,CAAC;EACF,CAAC,CAAC;AACH,MAAK,aAAa,GAAG,IAAI,OAAO,gBAAgB;EAC/C,QAAQ;EACR,SAAS;GACR;IACC,SAAS;IACT,UAAU,YAAY;IACtB;GACD;IACC,SAAS;IACT,UAAU,YAAY;IACtB;GACD;IACC,SAAS;IACT,UAAU,YAAY;IACtB;GACD;IACC,SAAS;IACT,UAAU,YAAY;IACtB;GACD;IACC,SAAS;IACT,UAAU,YAAY;IACtB;GACD;IACC,SAAS;IACT,UAAU;IACV;GACD;EACD,CAAC,CAAC;AACH,MAAK,KAAK,EAAE;;AAKb,IAAI,oBAAoB,eAAe,EAAE,gBAAgB,6BAA6B,CAAC"}