framefields 2.2.0 → 2.3.1

package/dist/preview-engine/renderers-6ODPWZ2R.mjs

@@ -0,0 +1,96 @@
+import{a as k,d as U,f as R,h as S,j as G,m as w}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as P}from"./chunk-63SFBHEH.mjs";import{e as f}from"./chunk-BVF64D6H.mjs";f();f();var p="Painterly",_=12,W=[`struct U { v : array<vec4<f32>, 3> };
+@group(0) @binding(0) var<uniform> u : U;
+@group(0) @binding(1) var src : texture_2d<f32>;
+@group(0) @binding(2) var prev : texture_2d<f32>;
+@group(0) @binding(3) var samp : sampler;
+${k}
+
+fn straight(c : vec4<f32>) -> vec4<f32> {
+	if (c.a <= 0.0001) { return vec4<f32>(0.0); }
+	return vec4<f32>(c.rgb / c.a, c.a);
+}
+fn premul(c : vec4<f32>) -> vec4<f32> { return vec4<f32>(c.rgb * c.a, c.a); }
+fn res() -> vec2<f32> { return vec2<f32>(textureDimensions(src)); }
+/** Straight-alpha color of the layer at a uv (filtered). */
+fn sampleS(uv : vec2<f32>) -> vec4<f32> { return straight(textureSampleLevel(src, samp, uv, 0.0)); }
+/** Premultiplied color of the layer at a uv (filtered). */
+fn sampleP(uv : vec2<f32>) -> vec4<f32> { return textureSampleLevel(src, samp, uv, 0.0); }
+/** Straight-alpha color of the layer's texel at a pixel position (nearest). */
+fn texelS(p : vec2<f32>) -> vec4<f32> {
+	let d = vec2<i32>(textureDimensions(src));
+	let q = clamp(vec2<i32>(floor(p)), vec2<i32>(0), d - vec2<i32>(1));
+	return straight(textureLoad(src, q, 0));
+}
+fn luma(c : vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+fn hash12(p : vec2<f32>) -> f32 {
+	var p3 = fract(vec3<f32>(p.xyx) * 0.1031);
+	p3 += dot(p3, p3.yzx + 33.33);
+	return fract((p3.x + p3.y) * p3.z);
+}
+fn vnoise(p : vec2<f32>) -> f32 {
+	let i = floor(p);
+	let f = fract(p);
+	let u = f * f * (3.0 - 2.0 * f);
+	return mix(mix(hash12(i), hash12(i + vec2<f32>(1.0, 0.0)), u.x),
+		mix(hash12(i + vec2<f32>(0.0, 1.0)), hash12(i + vec2<f32>(1.0, 1.0)), u.x), u.y);
+}
+/** 8x8 ordered-dither threshold, 0..1. */
+fn bayer8(p : vec2<f32>) -> f32 {
+	let x = u32(p.x) & 7u;
+	let y = u32(p.y) & 7u;
+	var v = 0u;
+	for (var k = 0u; k < 3u; k++) {
+		let bx = (x >> k) & 1u;
+		let by = (y >> k) & 1u;
+		let m = ((bx ^ by) << 1u) | by;
+		v += m * (1u << (2u * (2u - k)));
+	}
+	return (f32(v) + 0.5) / 64.0;
+}
+fn rot2(a : f32) -> mat2x2<f32> { let c = cos(a); let s = sin(a); return mat2x2<f32>(c, s, -s, c); }
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let time = u.v[0].x;
+	let frame = u.v[0].y;
+	let style = u32(u.v[1].x + 0.5);
+	let radius = u.v[1].y;
+	let edgeDarkening = u.v[1].z;
+	let paper = u.v[1].w;
+	let saturation = u.v[2].x;
+
+	let R = res();
+	let r = i32(radius);
+	var mean = array<vec3<f32>, 4>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));
+	var sq = array<vec3<f32>, 4>(vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0), vec3<f32>(0.0));
+	var a = 0.0;
+	for (var j = -r; j <= r; j++) {
+		for (var i = -r; i <= r; i++) {
+			let c = sampleS(in.uv + vec2<f32>(f32(i), f32(j)) / R);
+			a += c.a;
+			let q = select(select(3, 2, i <= 0), select(1, 0, i <= 0), j <= 0);
+			mean[q] += c.rgb;
+			sq[q] += c.rgb * c.rgb;
+		}
+	}
+	let n = f32((r + 1) * (r + 1));
+	var best = vec3<f32>(0.0);
+	var bestV = 1e9;
+	for (var k = 0; k < 4; k++) {
+		let m = mean[k] / n;
+		let v = sq[k] / n - m * m;
+		let vs = v.r + v.g + v.b;
+		if (vs < bestV) { bestV = vs; best = m; }
+	}
+	var rgb = best;
+	let grain = vnoise(in.uv * R / 3.0) * 0.6 + vnoise(in.uv * R / 11.0) * 0.4;
+	if (style == 1u) {
+		rgb = mix(rgb, vec3<f32>(1.0), 0.06);
+		rgb *= 1.0 - edgeDarkening * 0.45 * smoothstep(0.004, 0.05, sqrt(max(bestV, 0.0)));
+		rgb *= 1.0 - paper * 0.18 * (grain - 0.5);
+	} else {
+		rgb *= 1.0 - paper * 0.1 * (grain - 0.5);
+	}
+	rgb = clamp(mix(vec3<f32>(luma(rgb)), rgb, saturation), vec3<f32>(0.0), vec3<f32>(1.0));
+	let alpha = a / f32((2 * r + 1) * (2 * r + 1));
+	return premul(vec4<f32>(rgb, alpha));
+}
+`],T=R(e=>({layout:U(e,["uniform","texture","texture","sampler"],`${p}_layout`),pipelines:new Map,sampler:e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"})}));function N(e,r){let t=T(e),n=t.pipelines.get(r);return n||(n=W.map((v,a)=>{let o=e.createShaderModule({code:v,label:`${p}_${a}.wgsl`});return e.createRenderPipeline({label:`${p}_${a}`,layout:e.createPipelineLayout({bindGroupLayouts:[t.layout]}),vertex:{module:o,entryPoint:"vs"},fragment:{module:o,entryPoint:"fs",targets:[{format:r}]},primitive:{topology:"triangle-strip"}})}),t.pipelines.set(r,n)),n}function l(e,r){let t=typeof e=="number"?e:Number(e);return Number.isFinite(t)?t:r}function $(e,r,t,n){r.fill(0),r[0]=t,r[1]=n,r[4]=Math.max(0,["oil","watercolor"].indexOf(String(e.style??"oil"))),r[5]=l(e.radius,5),r[6]=l(e.edgeDarkening,.5),r[7]=l(e.paper,.3),r[8]=l(e.saturation,1.05)}var F=async e=>{let{ctx:r,encoder:t,pass:n,targetTexture:v,targetWidth:a,targetHeight:o,props:i}=e,c=i.virtualMedia?.operation;if(c?.op!==p)return;let b=i.virtualMedia?.children?.[0];if(!b)return;n.end();let m=i.fps||30,s=Math.round(i.compositionFrame??i.frame??0),L=c.effect?.resolveUniforms?c.effect.resolveUniforms({frame:s,fps:m,time:s/m}):c,x=new Float32Array(_);$(L,x,s/m,s);let{texture:d}=await S(e,b),g=r.device,y=T(g),q=N(g,r.renderer.format),D=r.renderer.getTemporaryBuffer(x),u=d;for(let M of q){let h=r.renderer.getTemporaryTexture(a,o,[d,u,v,...i.excludeTextures||[]]);w(t,h.createView(),M,[g.createBindGroup({layout:y.layout,entries:[{binding:0,resource:{buffer:D}},{binding:1,resource:d.createView()},{binding:2,resource:u.createView()},{binding:3,resource:y.sampler}]})]),u=h}G(e,u)};var E=P({WebGPURenderer:F});export{F as PainterlyWebGPURenderer,E as default};

package/dist/preview-engine/renderers-7NCG6BYS.mjs

@@ -0,0 +1,94 @@
+import{a as P,d as R,f as U,h as S,j as T,m as G}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as k}from"./chunk-63SFBHEH.mjs";import{e as f}from"./chunk-BVF64D6H.mjs";f();f();var v="CRT",D=16,N=[`struct U { v : array<vec4<f32>, 4> };
+@group(0) @binding(0) var<uniform> u : U;
+@group(0) @binding(1) var src : texture_2d<f32>;
+@group(0) @binding(2) var prev : texture_2d<f32>;
+@group(0) @binding(3) var samp : sampler;
+${P}
+
+fn straight(c : vec4<f32>) -> vec4<f32> {
+	if (c.a <= 0.0001) { return vec4<f32>(0.0); }
+	return vec4<f32>(c.rgb / c.a, c.a);
+}
+fn premul(c : vec4<f32>) -> vec4<f32> { return vec4<f32>(c.rgb * c.a, c.a); }
+fn res() -> vec2<f32> { return vec2<f32>(textureDimensions(src)); }
+/** Straight-alpha color of the layer at a uv (filtered). */
+fn sampleS(uv : vec2<f32>) -> vec4<f32> { return straight(textureSampleLevel(src, samp, uv, 0.0)); }
+/** Premultiplied color of the layer at a uv (filtered). */
+fn sampleP(uv : vec2<f32>) -> vec4<f32> { return textureSampleLevel(src, samp, uv, 0.0); }
+/** Straight-alpha color of the layer's texel at a pixel position (nearest). */
+fn texelS(p : vec2<f32>) -> vec4<f32> {
+	let d = vec2<i32>(textureDimensions(src));
+	let q = clamp(vec2<i32>(floor(p)), vec2<i32>(0), d - vec2<i32>(1));
+	return straight(textureLoad(src, q, 0));
+}
+fn luma(c : vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+fn hash12(p : vec2<f32>) -> f32 {
+	var p3 = fract(vec3<f32>(p.xyx) * 0.1031);
+	p3 += dot(p3, p3.yzx + 33.33);
+	return fract((p3.x + p3.y) * p3.z);
+}
+fn vnoise(p : vec2<f32>) -> f32 {
+	let i = floor(p);
+	let f = fract(p);
+	let u = f * f * (3.0 - 2.0 * f);
+	return mix(mix(hash12(i), hash12(i + vec2<f32>(1.0, 0.0)), u.x),
+		mix(hash12(i + vec2<f32>(0.0, 1.0)), hash12(i + vec2<f32>(1.0, 1.0)), u.x), u.y);
+}
+/** 8x8 ordered-dither threshold, 0..1. */
+fn bayer8(p : vec2<f32>) -> f32 {
+	let x = u32(p.x) & 7u;
+	let y = u32(p.y) & 7u;
+	var v = 0u;
+	for (var k = 0u; k < 3u; k++) {
+		let bx = (x >> k) & 1u;
+		let by = (y >> k) & 1u;
+		let m = ((bx ^ by) << 1u) | by;
+		v += m * (1u << (2u * (2u - k)));
+	}
+	return (f32(v) + 0.5) / 64.0;
+}
+fn rot2(a : f32) -> mat2x2<f32> { let c = cos(a); let s = sin(a); return mat2x2<f32>(c, s, -s, c); }
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let time = u.v[0].x;
+	let frame = u.v[0].y;
+	let scanlines = u.v[1].x;
+	let lineCount = u.v[1].y;
+	let curvature = u.v[1].z;
+	let mask = u.v[1].w;
+	let vignette = u.v[2].x;
+	let noise = u.v[2].y;
+	let flicker = u.v[2].z;
+	let tracking = u.v[2].w;
+	let chroma = u.v[3].x;
+
+	let R = res();
+	let t = time;
+	let cc = in.uv * 2.0 - 1.0;
+	var uv = (cc * (1.0 + curvature * 0.25 * dot(cc, cc))) * 0.5 + 0.5;
+	if (uv.x < 0.0 || uv.y < 0.0 || uv.x > 1.0 || uv.y > 1.0) { return vec4<f32>(0.0, 0.0, 0.0, 1.0); }
+	let line = floor(uv.y * lineCount);
+	let jitter = (hash12(vec2<f32>(line, floor(t * 30.0))) - 0.5) * tracking * 0.006;
+	let bandY = fract(t * 0.13);
+	let band = smoothstep(0.07, 0.0, abs(uv.y - bandY)) * tracking;
+	uv.x += jitter + band * 0.015 * sin(uv.y * 400.0 + t * 20.0);
+	let base = sampleS(uv);
+	var rgb = base.rgb;
+	if (chroma > 0.0) {
+		let off = chroma / R.x;
+		let avg = (sampleS(uv - vec2<f32>(off, 0.0)).rgb + base.rgb + sampleS(uv + vec2<f32>(off * 2.0, 0.0)).rgb) / 3.0;
+		let y = luma(base.rgb);
+		rgb = vec3<f32>(y) + (avg - vec3<f32>(luma(avg)));
+	}
+	let sl = 0.5 + 0.5 * cos(uv.y * lineCount * 6.2831853);
+	rgb *= 1.0 - scanlines * (1.0 - sl) * 0.7;
+	let tri = u32(floor(in.uv.x * R.x)) % 3u;
+	var m = vec3<f32>(0.75);
+	if (tri == 0u) { m.r = 1.25; } else if (tri == 1u) { m.g = 1.25; } else { m.b = 1.25; }
+	rgb *= mix(vec3<f32>(1.0), m, mask);
+	rgb += (hash12(in.uv * R + vec2<f32>(t * 61.0, t * 17.0)) - 0.5) * noise * 0.3;
+	rgb *= 1.0 - flicker * hash12(vec2<f32>(floor(t * 24.0), 3.0));
+	rgb *= 1.0 - vignette * dot(cc, cc) * 0.35;
+	rgb += band * 0.12;
+	return vec4<f32>(clamp(rgb, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+}
+`],F=U(e=>({layout:R(e,["uniform","texture","texture","sampler"],`${v}_layout`),pipelines:new Map,sampler:e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"})}));function $(e,r){let t=F(e),i=t.pipelines.get(r);return i||(i=N.map((p,c)=>{let u=e.createShaderModule({code:p,label:`${v}_${c}.wgsl`});return e.createRenderPipeline({label:`${v}_${c}`,layout:e.createPipelineLayout({bindGroupLayouts:[t.layout]}),vertex:{module:u,entryPoint:"vs"},fragment:{module:u,entryPoint:"fs",targets:[{format:r}]},primitive:{topology:"triangle-strip"}})}),t.pipelines.set(r,i)),i}function n(e,r){let t=typeof e=="number"?e:Number(e);return Number.isFinite(t)?t:r}function A(e,r,t,i){r.fill(0),r[0]=t,r[1]=i,r[4]=n(e.scanlines,.45),r[5]=n(e.lineCount,540),r[6]=n(e.curvature,.12),r[7]=n(e.mask,.25),r[8]=n(e.vignette,.35),r[9]=n(e.noise,.08),r[10]=n(e.flicker,.03),r[11]=n(e.tracking,0),r[12]=n(e.chroma,0)}var w=async e=>{let{ctx:r,encoder:t,pass:i,targetTexture:p,targetWidth:c,targetHeight:u,props:o}=e,l=o.virtualMedia?.operation;if(l?.op!==v)return;let b=o.virtualMedia?.children?.[0];if(!b)return;i.end();let m=o.fps||30,a=Math.round(o.compositionFrame??o.frame??0),L=l.effect?.resolveUniforms?l.effect.resolveUniforms({frame:a,fps:m,time:a/m}):l,x=new Float32Array(D);A(L,x,a/m,a);let{texture:d}=await S(e,b),g=r.device,y=F(g),C=$(g,r.renderer.format),M=r.renderer.getTemporaryBuffer(x),s=d;for(let _ of C){let h=r.renderer.getTemporaryTexture(c,u,[d,s,p,...o.excludeTextures||[]]);G(t,h.createView(),_,[g.createBindGroup({layout:y.layout,entries:[{binding:0,resource:{buffer:M}},{binding:1,resource:d.createView()},{binding:2,resource:s.createView()},{binding:3,resource:y.sampler}]})]),s=h}T(e,s)};var j=k({WebGPURenderer:w});export{w as CRTWebGPURenderer,j as default};

package/dist/preview-engine/renderers-BGGRPAVV.mjs

@@ -0,0 +1,363 @@
+import{a as k,d as F,e as V,f as T,g as D,k as L}from"./chunk-ENKKLU7B.mjs";import{d as b}from"./chunk-6YJP57MZ.mjs";import{x as o,z as A}from"./chunk-63SFBHEH.mjs";import{e as u}from"./chunk-BVF64D6H.mjs";u();u();var z=`
+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;
+${k}
+
+// ---- 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);
+}
+`,e=new Float32Array(24),N=T(l=>({uniformLayout:F(l,["uniform"]),signalsLayout:V(l,5),pipelineCache:new Map}));function q(l,t){let s=N(l),i=`procedural_vfx_${t}`,a=s.pipelineCache.get(i);if(!a){let c=l.createShaderModule({label:`procedural_vfx_${t}.wgsl`,code:z});a=D(l,{label:`ProceduralVFXPipeline_${t}`,module:c,layouts:[s.uniformLayout,s.signalsLayout],format:t}),s.pipelineCache.set(i,a)}return{vfxPipeline:a,uniformLayout:s.uniformLayout,signalsLayout:s.signalsLayout}}function _(l){let t=l.replace("#","");(t.length===3||t.length===4)&&(t=t.split("").map(r=>r+r).join(""));let s=parseInt(t.substring(0,2),16)/255,i=parseInt(t.substring(2,4),16)/255,a=parseInt(t.substring(4,6),16)/255,c=1;return t.length===8&&(c=parseInt(t.substring(6,8),16)/255),[s,i,a,c]}var $={Smoke:0,Fire:1,Rain:2,Sparks:3,Snow:4,Dust:5,Lightning:6,Magic:7,LensFlare:8,Embers:9,EnergyBeam:10,Aurora:11},I=async l=>{let{ctx:t,encoder:s,pass:i,targetWidth:a,targetHeight:c,props:r}=l,n=r.virtualMedia?.operation;if(n?.op!=="ProceduralVFX"||!n)return;let{vfxPipeline:P,uniformLayout:X,signalsLayout:R}=q(t.device,t.renderer.format),w=r.frame??0,S=r.fps||30,g=o(n,"density",.6),h=o(n,"scale",.01),v=o(n,"speed",1),y=o(n,"intensity",.8),x=o(n,"seed",1234),G=$[n.effectType??"Smoke"]??0,E=n.outputType==="Video"?1:0,{elapsedSeconds:B,durationSeconds:U}=L(r,w,S),d=_(n.colorStart??"#ffffff"),m=_(n.colorEnd??"#ff5500");e[0]=G,e[1]=E,e[2]=B,e[3]=0,e[4]=g.value,e[5]=h.value,e[6]=v.value,e[7]=y.value,e[8]=x.value,e[9]=g.hasSignal?1:0,e[10]=h.hasSignal?1:0,e[11]=v.hasSignal?1:0,e[12]=y.hasSignal?1:0,e[13]=x.hasSignal?1:0,e[14]=0,e[15]=0,e[16]=d[0],e[17]=d[1],e[18]=d[2],e[19]=d[3],e[20]=m[0],e[21]=m[1],e[22]=m[2],e[23]=m[3];let W=t.renderer.getTemporaryBuffer(e),C=[{name:"density",info:g},{name:"scale",info:h},{name:"speed",info:v},{name:"intensity",info:y},{name:"seed",info:x}],f=[],M=t.renderer.samplerCache.getSampler(t.device);for(let p of C)if(!!(p.info.hasSignal&&p.info.sd)){let O=b.getOrCreate2DTextureView(t.device,s,p.info.sd?.nodeId??`procedural_vfx_${p.name}_sig`,B,U,p.info.sd,a,c,r.renderId,w,S);f.push(O)}else f.push(b.getDummy1x1TextureView(t.device));i.setPipeline(P),i.setBindGroup(0,t.device.createBindGroup({layout:X,entries:[{binding:0,resource:{buffer:W}}]})),i.setBindGroup(1,t.device.createBindGroup({layout:R,entries:[{binding:0,resource:f[0]},{binding:1,resource:f[1]},{binding:2,resource:f[2]},{binding:3,resource:f[3]},{binding:4,resource:f[4]},{binding:5,resource:M}]})),i.draw(4)};var ne=A({WebGPURenderer:I});export{I as ProceduralVFXWebGPURenderer,ne as default};

package/dist/preview-engine/renderers-DN2GF3I7.mjs

@@ -0,0 +1,82 @@
+import{a as P,d as T,f as U,h as R,j as k,m as G}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as S}from"./chunk-63SFBHEH.mjs";import{e as s}from"./chunk-BVF64D6H.mjs";s();s();var p="Toon",D=12,$=[`struct U { v : array<vec4<f32>, 3> };
+@group(0) @binding(0) var<uniform> u : U;
+@group(0) @binding(1) var src : texture_2d<f32>;
+@group(0) @binding(2) var prev : texture_2d<f32>;
+@group(0) @binding(3) var samp : sampler;
+${P}
+
+fn straight(c : vec4<f32>) -> vec4<f32> {
+	if (c.a <= 0.0001) { return vec4<f32>(0.0); }
+	return vec4<f32>(c.rgb / c.a, c.a);
+}
+fn premul(c : vec4<f32>) -> vec4<f32> { return vec4<f32>(c.rgb * c.a, c.a); }
+fn res() -> vec2<f32> { return vec2<f32>(textureDimensions(src)); }
+/** Straight-alpha color of the layer at a uv (filtered). */
+fn sampleS(uv : vec2<f32>) -> vec4<f32> { return straight(textureSampleLevel(src, samp, uv, 0.0)); }
+/** Premultiplied color of the layer at a uv (filtered). */
+fn sampleP(uv : vec2<f32>) -> vec4<f32> { return textureSampleLevel(src, samp, uv, 0.0); }
+/** Straight-alpha color of the layer's texel at a pixel position (nearest). */
+fn texelS(p : vec2<f32>) -> vec4<f32> {
+	let d = vec2<i32>(textureDimensions(src));
+	let q = clamp(vec2<i32>(floor(p)), vec2<i32>(0), d - vec2<i32>(1));
+	return straight(textureLoad(src, q, 0));
+}
+fn luma(c : vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+fn hash12(p : vec2<f32>) -> f32 {
+	var p3 = fract(vec3<f32>(p.xyx) * 0.1031);
+	p3 += dot(p3, p3.yzx + 33.33);
+	return fract((p3.x + p3.y) * p3.z);
+}
+fn vnoise(p : vec2<f32>) -> f32 {
+	let i = floor(p);
+	let f = fract(p);
+	let u = f * f * (3.0 - 2.0 * f);
+	return mix(mix(hash12(i), hash12(i + vec2<f32>(1.0, 0.0)), u.x),
+		mix(hash12(i + vec2<f32>(0.0, 1.0)), hash12(i + vec2<f32>(1.0, 1.0)), u.x), u.y);
+}
+/** 8x8 ordered-dither threshold, 0..1. */
+fn bayer8(p : vec2<f32>) -> f32 {
+	let x = u32(p.x) & 7u;
+	let y = u32(p.y) & 7u;
+	var v = 0u;
+	for (var k = 0u; k < 3u; k++) {
+		let bx = (x >> k) & 1u;
+		let by = (y >> k) & 1u;
+		let m = ((bx ^ by) << 1u) | by;
+		v += m * (1u << (2u * (2u - k)));
+	}
+	return (f32(v) + 0.5) / 64.0;
+}
+fn rot2(a : f32) -> mat2x2<f32> { let c = cos(a); let s = sin(a); return mat2x2<f32>(c, s, -s, c); }
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let time = u.v[0].x;
+	let frame = u.v[0].y;
+	let levels = u.v[1].x;
+	let edgeThreshold = u.v[1].y;
+	let edgeWidth = u.v[1].z;
+	let edgeColor = u.v[2];
+	let saturation = u.v[1].w;
+
+	let R = res();
+	let o = edgeWidth / R;
+	let c = sampleS(in.uv);
+	let tl = luma(sampleS(in.uv + vec2<f32>(-o.x, -o.y)).rgb);
+	let t = luma(sampleS(in.uv + vec2<f32>(0.0, -o.y)).rgb);
+	let tr = luma(sampleS(in.uv + vec2<f32>(o.x, -o.y)).rgb);
+	let l = luma(sampleS(in.uv + vec2<f32>(-o.x, 0.0)).rgb);
+	let r = luma(sampleS(in.uv + vec2<f32>(o.x, 0.0)).rgb);
+	let bl = luma(sampleS(in.uv + vec2<f32>(-o.x, o.y)).rgb);
+	let b = luma(sampleS(in.uv + vec2<f32>(0.0, o.y)).rgb);
+	let br = luma(sampleS(in.uv + vec2<f32>(o.x, o.y)).rgb);
+	let gx = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
+	let gy = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
+	let edge = length(vec2<f32>(gx, gy));
+	let ink = smoothstep(edgeThreshold, edgeThreshold * 1.5 + 0.03, edge);
+	let lum = luma(c.rgb);
+	let band = (floor(lum * levels) + 0.5) / levels;
+	var rgb = c.rgb * (band / max(lum, 0.001));
+	rgb = clamp(mix(vec3<f32>(luma(rgb)), rgb, saturation), vec3<f32>(0.0), vec3<f32>(1.0));
+	rgb = mix(rgb, edgeColor.rgb, ink);
+	return premul(vec4<f32>(rgb, max(c.a, ink * c.a)));
+}
+`],w=U(r=>({layout:T(r,["uniform","texture","texture","sampler"],`${p}_layout`),pipelines:new Map,sampler:r.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"})}));function A(r,e){let t=w(r),n=t.pipelines.get(e);return n||(n=$.map((m,l)=>{let i=r.createShaderModule({code:m,label:`${p}_${l}.wgsl`});return r.createRenderPipeline({label:`${p}_${l}`,layout:r.createPipelineLayout({bindGroupLayouts:[t.layout]}),vertex:{module:i,entryPoint:"vs"},fragment:{module:i,entryPoint:"fs",targets:[{format:e}]},primitive:{topology:"triangle-strip"}})}),t.pipelines.set(e,n)),n}function f(r,e){let t=typeof r=="number"?r:Number(r);return Number.isFinite(t)?t:e}function C(r){let e=r.trim().replace("#","");(e.length===3||e.length===4)&&(e=[...e].map(n=>n+n).join(""));let t=n=>Number.parseInt(e.slice(n,n+2),16)/255;return[t(0),t(2),t(4),e.length>=8?t(6):1]}function V(r,e,t,n){e.fill(0),e[0]=t,e[1]=n,e[4]=f(r.levels,4),e[5]=f(r.edgeThreshold,.2),e[6]=f(r.edgeWidth,1),e.set(C(String(r.edgeColor??"#111111")),8),e[7]=f(r.saturation,1.15)}var F=async r=>{let{ctx:e,encoder:t,pass:n,targetTexture:m,targetWidth:l,targetHeight:i,props:o}=r,u=o.virtualMedia?.operation;if(u?.op!==p)return;let b=o.virtualMedia?.children?.[0];if(!b)return;n.end();let v=o.fps||30,a=Math.round(o.compositionFrame??o.frame??0),L=u.effect?.resolveUniforms?u.effect.resolveUniforms({frame:a,fps:v,time:a/v}):u,x=new Float32Array(D);V(L,x,a/v,a);let{texture:d}=await R(r,b),g=e.device,h=w(g),W=A(g,e.renderer.format),M=e.renderer.getTemporaryBuffer(x),c=d;for(let _ of W){let y=e.renderer.getTemporaryTexture(l,i,[d,c,m,...o.excludeTextures||[]]);G(t,y.createView(),_,[g.createBindGroup({layout:h.layout,entries:[{binding:0,resource:{buffer:M}},{binding:1,resource:d.createView()},{binding:2,resource:c.createView()},{binding:3,resource:h.sampler}]})]),c=y}k(r,c)};var I=S({WebGPURenderer:F});export{F as ToonWebGPURenderer,I as default};