framefields 2.2.0-beta.4 → 2.3.0

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

@@ -0,0 +1,44 @@
+import{a as x,d as g,f as T,h as v,j as U,m as P}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as h}from"./chunk-63SFBHEH.mjs";import{e as p}from"./chunk-BVF64D6H.mjs";p();p();var w="rgba16float",k=`
+struct U { a : vec4<f32>, b : vec4<f32> };
+@group(0) @binding(0) var<uniform> u : U;
+@group(0) @binding(1) var historyTex : texture_2d<f32>;
+@group(0) @binding(2) var currentTex : texture_2d<f32>;
+@group(0) @binding(3) var samp : sampler;
+${x}
+
+// Hue rotation in YIQ: linear, so it works on premultiplied color.
+fn hueRotate(c : vec3<f32>, angle : f32) -> vec3<f32> {
+	let yiq = mat3x3<f32>(0.299, 0.596, 0.211, 0.587, -0.274, -0.523, 0.114, -0.322, 0.312) * c;
+	let cs = cos(angle);
+	let sn = sin(angle);
+	let rot = vec3<f32>(yiq.x, yiq.y * cs - yiq.z * sn, yiq.y * sn + yiq.z * cs);
+	return mat3x3<f32>(1.0, 1.0, 1.0, 0.956, -0.272, -1.106, 0.621, -0.647, 1.703) * rot;
+}
+
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let decay = u.a.x;
+	let mode = u.a.y;
+	let zoom = max(u.a.z, 1e-3);
+	let angle = u.a.w;
+	let offset = u.b.xy;
+	let hue = u.b.z;
+	let fresh = u.b.w;
+	let cur = textureSampleLevel(currentTex, samp, in.uv, 0.0);
+	if (fresh > 0.5) { return cur; }
+	let c = in.uv - 0.5;
+	let cs = cos(-angle);
+	let sn = sin(-angle);
+	let src = vec2<f32>(c.x * cs - c.y * sn, c.x * sn + c.y * cs) / zoom + 0.5 - offset;
+	var hist = vec4<f32>(0.0);
+	if (all(src >= vec2<f32>(0.0)) && all(src <= vec2<f32>(1.0))) {
+		hist = textureSampleLevel(historyTex, samp, src, 0.0);
+	}
+	if (hue != 0.0) { hist = vec4<f32>(max(hueRotate(hist.rgb, hue), vec3<f32>(0.0)), hist.a); }
+	hist *= decay;
+	if (mode < 0.5) { return cur + hist * (1.0 - cur.a); }
+	if (mode < 1.5) { return vec4<f32>(cur.rgb + hist.rgb, min(cur.a + hist.a, 1.0)); }
+	if (mode < 2.5) { return max(cur, hist); }
+	// blend: a running average, so opaque footage shows its own echoes.
+	return mix(cur, hist / max(decay, 1e-4), decay);
+}
+`,S=T(e=>{let r=g(e,["uniform","texture","texture","sampler"],"trails_layout"),t=e.createShaderModule({code:k,label:"trails.wgsl"});return{layout:r,pipeline:e.createRenderPipeline({label:"trails",layout:e.createPipelineLayout({bindGroupLayouts:[r]}),vertex:{module:t,entryPoint:"vs"},fragment:{module:t,entryPoint:"fs",targets:[{format:w}]},primitive:{topology:"triangle-strip"}}),sampler:e.createSampler({magFilter:"linear",minFilter:"linear"})}});function F(e,r,t,n){let o=e.feedbackHistory;if(o&&o.device===r&&o.width===t&&o.height===n)return o;o?.front.destroy(),o?.back.destroy();let a=c=>r.createTexture({label:c,size:[t,n],format:w,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST}),i={device:r,width:t,height:n,front:a("trails_front"),back:a("trails_back"),frame:-1};return e.feedbackHistory=i,i}async function H(e,r,t,n){let o=e.props.virtualMedia?.children?.[0];return o?v(e,o,{exclude:[n.front,n.back],props:{...e.props,virtualMedia:o,frame:r,compositionFrame:t+r}}):null}function _(e){let r=e.front;e.front=e.back,e.back=r}async function z(e,r,t,n,o,a){let i=await H(e,n,o,r);if(!i)return;let c=S(e.ctx.device),s=new Float32Array([t.decay,{over:0,add:1,max:2,blend:3}[t.mode]??0,t.zoom,t.rotation*Math.PI/180,t.offsetX/r.width,t.offsetY/r.height,t.hueShift*Math.PI/180,a?1:0]);P(e.encoder,r.back.createView(),c.pipeline,[e.ctx.device.createBindGroup({layout:c.layout,entries:[{binding:0,resource:{buffer:e.ctx.renderer.getTemporaryBuffer(s)}},{binding:1,resource:r.front.createView()},{binding:2,resource:i.view},{binding:3,resource:c.sampler}]})]),_(r),r.frame=n}function f(e,r){return typeof e=="number"&&Number.isFinite(e)?e:r}var G=async e=>{let{ctx:r,pass:t,targetWidth:n,targetHeight:o,props:a}=e,i=a.virtualMedia?.operation;if(i?.op!=="Trails"||!i.effect?.resolveUniforms||!a.virtualMedia?.children?.[0])return;t.end();let c=a.fps||30,s=Math.max(0,Math.round(a.frame??0)),b=Math.round(a.compositionFrame??s),M=b-s,u=i.effect.resolveUniforms({frame:b,fps:c,time:b/c}),l=F(i.effect,r.device,n,o);{let m={decay:Math.min(1,Math.max(0,f(u.decay,.9))),mode:u.mode??"blend",zoom:f(u.zoom,1),rotation:f(u.rotation,0),offsetX:f(u.offsetX,0),offsetY:f(u.offsetY,0),hueShift:f(u.hueShift,0),warmup:Math.max(0,Math.round(f(u.warmup,60)))};if(l.frame!==s){let y=s;if(l.frame===s-1)y=s;else{let d=m.decay>0&&m.decay<1?Math.ceil(Math.log(.005)/Math.log(m.decay)):m.warmup;y=Math.max(0,s-Math.min(m.warmup,d)),l.frame=-1}for(let d=y;d<=s;d++)await z(e,l,m,d,M,l.frame<0)}}U(e,l.front)};var D=h({WebGPURenderer:G});export{G as TrailsWebGPURenderer,D as default};

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

@@ -0,0 +1,275 @@
+import{z as B}from"./chunk-63SFBHEH.mjs";import{e as h}from"./chunk-BVF64D6H.mjs";h();h();h();function M(r){return typeof r=="object"&&r!==null&&"particleStatic"in r&&typeof r.particleFrame=="function"}var w=32,S=32,R=8,L=8,T=24,E=64,_=64,F=`
+struct Particle {
+	pos : vec2<f32>,
+	vel : vec2<f32>,
+	age : f32,
+	life : f32,
+	jitter : f32,
+	_pad : f32,
+};
+
+struct Params { v : array<vec4<f32>, ${S}> };
+`,Y=`
+${F}
+@group(0) @binding(0) var<uniform> P : Params;
+@group(0) @binding(1) var<storage, read_write> particles : array<Particle>;
+@group(0) @binding(2) var<storage, read> mask : array<f32>;
+
+fn pcg(v : u32) -> u32 {
+	let state = v * 747796405u + 2891336453u;
+	let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+	return (word >> 22u) ^ word;
+}
+fn rnd(idx : u32, channel : u32, seed : u32) -> f32 {
+	return f32(pcg(idx * 16u + channel + pcg(seed))) / 4294967295.0;
+}
+
+fn hash2(p : vec2<f32>) -> f32 {
+	let q = fract(p * vec2<f32>(0.1031, 0.1030));
+	let r = q + dot(q, q.yx + 33.33);
+	return fract((r.x + r.y) * r.x);
+}
+fn vnoise(p : vec2<f32>) -> f32 {
+	let i = floor(p);
+	let f = fract(p);
+	let u = f * f * (3.0 - 2.0 * f);
+	let a = hash2(i);
+	let b = hash2(i + vec2<f32>(1.0, 0.0));
+	let c = hash2(i + vec2<f32>(0.0, 1.0));
+	let d = hash2(i + vec2<f32>(1.0, 1.0));
+	return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+fn fbm(p : vec2<f32>) -> f32 {
+	return vnoise(p) * 0.6 + vnoise(p * 2.03 + 17.0) * 0.3 + vnoise(p * 4.01 + 41.0) * 0.1;
+}
+// Divergence-free flow: the curl of a scalar noise field.
+fn curl(p : vec2<f32>) -> vec2<f32> {
+	let e = 0.02;
+	let dx = fbm(p + vec2<f32>(e, 0.0)) - fbm(p - vec2<f32>(e, 0.0));
+	let dy = fbm(p + vec2<f32>(0.0, e)) - fbm(p - vec2<f32>(0.0, e));
+	return vec2<f32>(dy, -dx) / (2.0 * e);
+}
+
+fn maskAt(cell : vec2<f32>, offset : u32) -> f32 {
+	let w = i32(P.v[18].x);
+	let h = i32(P.v[18].y);
+	let c0 = vec2<i32>(floor(cell));
+	let t = cell - floor(cell);
+	var s = 0.0;
+	for (var k = 0; k < 4; k++) {
+		let o = vec2<i32>(k & 1, k >> 1);
+		let c = c0 + o;
+		var v = 0.0;
+		if (c.x >= 0 && c.y >= 0 && c.x < w && c.y < h) {
+			v = mask[offset + u32(c.y * w + c.x)];
+		}
+		let wx = select(1.0 - t.x, t.x, o.x == 1);
+		let wy = select(1.0 - t.y, t.y, o.y == 1);
+		s += v * wx * wy;
+	}
+	return s;
+}
+
+fn spawn(i : u32, idx : u32, birthFrac : f32) {
+	let birthAge = birthFrac * P.v[1].z;
+	let seed = u32(P.v[1].y);
+	let shape = u32(P.v[4].x);
+	let ex = P.v[4].y; let ey = P.v[4].z; let ew = P.v[4].w;
+	let eh = P.v[5].x; let er = P.v[5].y;
+	let r0 = rnd(idx, 0u, seed); let r1 = rnd(idx, 1u, seed);
+	var pos = vec2<f32>(ex, ey);
+	var center = vec2<f32>(ex, ey);
+	if (shape == 1u) { pos = vec2<f32>(ex + ew * r0, ey + eh * r0); center = vec2<f32>(ex + ew * 0.5, ey + eh * 0.5); }
+	else if (shape == 2u) { pos = vec2<f32>(ex + ew * r0, ey + eh * r1); center = vec2<f32>(ex + ew * 0.5, ey + eh * 0.5); }
+	else if (shape == 3u) {
+		let a = r0 * 6.2831853; let rr = er * sqrt(r1);
+		pos = vec2<f32>(ex + cos(a) * rr, ey + sin(a) * rr);
+	} else if (shape == 4u) {
+		let a = r0 * 6.2831853;
+		pos = vec2<f32>(ex + cos(a) * er, ey + sin(a) * er);
+	}
+	let radial = P.v[1].w > 0.5;
+	var dir = P.v[6].x + (rnd(idx, 2u, seed) - 0.5) * P.v[6].y;
+	if (radial) {
+		let d = pos - center;
+		if (dot(d, d) > 1e-6) { dir = atan2(d.y, d.x) + (rnd(idx, 2u, seed) - 0.5) * P.v[6].y; }
+	}
+	// A moving emitter: older births of the frame start nearer last frame's spot.
+	if (P.v[30].z > 0.5) { pos += (P.v[30].xy - vec2<f32>(ex, ey)) * birthFrac; }
+	let speed = mix(P.v[5].z, P.v[5].w, rnd(idx, 3u, seed));
+	let vel = vec2<f32>(cos(dir), sin(dir)) * speed;
+	var p : Particle;
+	p.vel = vel;
+	p.pos = pos + vel * birthAge;
+	p.age = birthAge;
+	p.life = mix(P.v[6].z, P.v[6].w, rnd(idx, 4u, seed));
+	p.jitter = 1.0 - P.v[16].w * rnd(idx, 5u, seed);
+	p._pad = 0.0;
+	particles[i] = p;
+}
+
+@compute @workgroup_size(${_})
+fn simulate(@builtin(global_invocation_id) gid : vec3<u32>) {
+	let i = gid.x;
+	let maxN = u32(P.v[1].x);
+	if (i >= maxN) { return; }
+	let dt = P.v[0].x;
+	let time = P.v[0].y;
+	let emitStart = u32(P.v[0].z);
+	let emitCount = u32(P.v[0].w);
+	let frameDt = P.v[1].z;
+
+	if (emitCount > 0u) {
+		let k = (i + maxN - (emitStart % maxN)) % maxN;
+		if (k < emitCount) {
+			// Births spread over the frame, oldest first.
+			spawn(i, emitStart + k, 1.0 - (f32(k) + 0.5) / f32(emitCount));
+			return;
+		}
+	}
+
+	var p = particles[i];
+	if (p.life <= 0.0) { return; }
+	p.age += dt;
+	if (p.age >= p.life) { p.life = 0.0; particles[i] = p; return; }
+
+	var acc = vec2<f32>(P.v[2].z, P.v[2].w);
+	let ns = P.v[3].y;
+	if (ns != 0.0) {
+		let sc = max(P.v[3].z, 1.0);
+		acc += curl(p.pos / sc + vec2<f32>(time * P.v[3].w, time * P.v[3].w * 0.7)) * ns;
+	}
+	let nAttr = u32(P.v[7].w);
+	for (var a = 0u; a < nAttr; a++) {
+		let at = P.v[8u + a];
+		let d = at.xy - p.pos;
+		let dist = length(d) + 1e-3;
+		let fall = exp(-(dist * dist) / max(at.w * at.w, 1.0));
+		acc += d / dist * at.z * fall;
+	}
+	if (P.v[16].x > 0.5) {
+		// Silhouette push: out along the gradient, harder where it just arrived.
+		let comp = p.pos + P.v[18].zw;
+		let cell = (comp - P.v[17].xy) / P.v[17].zw - 0.5;
+		let cellCount = u32(P.v[18].x * P.v[18].y);
+		let a0 = maskAt(cell, 0u);
+		if (a0 > 0.02) {
+			let gx = maskAt(cell + vec2<f32>(1.0, 0.0), 0u) - maskAt(cell - vec2<f32>(1.0, 0.0), 0u);
+			let gy = maskAt(cell + vec2<f32>(0.0, 1.0), 0u) - maskAt(cell - vec2<f32>(0.0, 1.0), 0u);
+			let g = vec2<f32>(gx, gy);
+			let gl = length(g);
+			if (gl > 1e-5) {
+				let before = maskAt(cell, cellCount);
+				let k = a0 * P.v[16].y + max(0.0, a0 - before) * P.v[16].z;
+				acc -= g / gl * k;
+			}
+		}
+	}
+
+	p.vel += acc * dt;
+	p.vel *= exp(-P.v[3].x * dt);
+	p.pos += p.vel * dt;
+
+	let w = P.v[2].x; let h = P.v[2].y;
+	let floorY = P.v[7].y;
+	let bounce = P.v[7].z;
+	if (floorY >= 0.0 && p.pos.y > floorY) { p.pos.y = floorY; p.vel.y = -abs(p.vel.y) * bounce; p.vel.x *= 0.9; }
+	let mode = u32(P.v[7].x);
+	if (mode == 1u) {
+		if (p.pos.x < 0.0 || p.pos.y < 0.0 || p.pos.x > w || p.pos.y > h) { p.life = 0.0; }
+	} else if (mode == 2u) {
+		if (p.pos.x < 0.0) { p.pos.x = 0.0; p.vel.x = abs(p.vel.x) * bounce; }
+		if (p.pos.x > w) { p.pos.x = w; p.vel.x = -abs(p.vel.x) * bounce; }
+		if (p.pos.y < 0.0) { p.pos.y = 0.0; p.vel.y = abs(p.vel.y) * bounce; }
+		if (p.pos.y > h) { p.pos.y = h; p.vel.y = -abs(p.vel.y) * bounce; }
+	} else if (mode == 3u) {
+		p.pos = vec2<f32>(p.pos.x - floor(p.pos.x / w) * w, p.pos.y - floor(p.pos.y / h) * h);
+	}
+	particles[i] = p;
+}
+`,X=`
+${F}
+@group(0) @binding(0) var<uniform> P : Params;
+@group(0) @binding(1) var<storage, read> particles : array<Particle>;
+
+struct VOut {
+	@builtin(position) pos : vec4<f32>,
+	@location(0) uv : vec2<f32>,
+	@location(1) color : vec4<f32>,
+	@location(2) aspect : f32,
+};
+
+fn gradient(t : f32) -> vec4<f32> {
+	let n = i32(P.v[21].x);
+	if (n <= 1) { return P.v[22]; }
+	let x = clamp(t, 0.0, 1.0) * f32(n - 1);
+	let i = min(i32(floor(x)), n - 2);
+	return mix(P.v[22 + i], P.v[23 + i], x - f32(i));
+}
+
+@vertex
+fn vs(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> VOut {
+	var out : VOut;
+	let p = particles[ii];
+	if (p.life <= 0.0) {
+		out.pos = vec4<f32>(2.0, 2.0, 0.0, 1.0);
+		out.color = vec4<f32>(0.0);
+		return out;
+	}
+	let t = p.age / p.life;
+	let size = mix(P.v[19].x, P.v[19].y, t) * p.jitter;
+	var corner = vec2<f32>(0.0);
+	switch (vi) {
+		case 0u: { corner = vec2<f32>(-1.0, -1.0); }
+		case 1u: { corner = vec2<f32>(1.0, -1.0); }
+		case 2u: { corner = vec2<f32>(-1.0, 1.0); }
+		case 3u: { corner = vec2<f32>(-1.0, 1.0); }
+		case 4u: { corner = vec2<f32>(1.0, -1.0); }
+		default: { corner = vec2<f32>(1.0, 1.0); }
+	}
+	let speed = length(p.vel);
+	var axisX = vec2<f32>(1.0, 0.0);
+	var halfLen = size * 0.5;
+	let shape = u32(P.v[20].x);
+	if (shape == 3u && speed > 1e-3) {
+		axisX = p.vel / speed;
+		halfLen = size * 0.5 + speed * P.v[20].y * 0.5;
+	}
+	let axisY = vec2<f32>(-axisX.y, axisX.x);
+	let local = axisX * corner.x * halfLen + axisY * corner.y * size * 0.5;
+	let px = (p.pos + local) * P.v[21].yz;
+	let tsize = P.v[2].xy * P.v[21].yz;
+	out.pos = vec4<f32>(px.x / tsize.x * 2.0 - 1.0, 1.0 - px.y / tsize.y * 2.0, 0.0, 1.0);
+	out.uv = corner;
+	out.aspect = halfLen / max(size * 0.5, 1e-3);
+
+	var c = gradient(t);
+	if (P.v[20].z > 0.5) { c = gradient(speed / max(P.v[20].w, 1e-3)); }
+	let fadeIn = max(P.v[19].z, 1e-4);
+	let fadeOut = max(P.v[19].w, 1e-4);
+	let a = c.a * smoothstep(0.0, fadeIn, t) * (1.0 - smoothstep(1.0 - fadeOut, 1.0, t)) * P.v[21].w;
+	out.color = vec4<f32>(c.rgb * a, a);
+	return out;
+}
+
+@fragment
+fn fs(in : VOut) -> @location(0) vec4<f32> {
+	let shape = u32(P.v[20].x);
+	var m = 1.0;
+	if (shape == 0u) {
+		let d = length(in.uv);
+		let e = max(fwidth(d), 1e-3);
+		m = 1.0 - smoothstep(1.0 - e, 1.0, d);
+	} else if (shape == 1u) {
+		let d = length(in.uv);
+		m = exp(-3.5 * d * d) * (1.0 - smoothstep(0.9, 1.0, d));
+	} else if (shape == 3u) {
+		// A capsule along the motion, soft at the sides.
+		let ax = abs(in.uv.x) * in.aspect;
+		let ex = max(ax - (in.aspect - 1.0), 0.0);
+		let d = length(vec2<f32>(ex, in.uv.y));
+		m = 1.0 - smoothstep(0.5, 1.0, d);
+	}
+	return in.color * m;
+}
+`,z=new WeakMap;function k(r){let e=z.get(r);if(e)return e;let i=r.createBindGroupLayout({label:"particles_sim_layout",entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.COMPUTE,buffer:{type:"storage"}},{binding:2,visibility:GPUShaderStage.COMPUTE,buffer:{type:"read-only-storage"}}]}),n=r.createComputePipeline({label:"particles_sim",layout:r.createPipelineLayout({bindGroupLayouts:[i]}),compute:{module:r.createShaderModule({label:"particles_sim.wgsl",code:Y}),entryPoint:"simulate"}}),s=r.createBindGroupLayout({label:"particles_draw_layout",entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.VERTEX,buffer:{type:"read-only-storage"}}]});return e={simLayout:i,sim:n,drawLayout:s,draw:new Map,drawModule:r.createShaderModule({label:"particles_draw.wgsl",code:X})},z.set(r,e),e}var D={normal:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}},add:{color:{srcFactor:"one",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"add"}},screen:{color:{srcFactor:"one",dstFactor:"one-minus-src",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}};function N(r,e,i){let n=k(r),s=`${e}|${i}`,t=n.draw.get(s);return t||(t=r.createRenderPipeline({label:`particles_draw_${i}`,layout:r.createPipelineLayout({bindGroupLayouts:[n.drawLayout]}),vertex:{module:n.drawModule,entryPoint:"vs"},fragment:{module:n.drawModule,entryPoint:"fs",targets:[{format:e,blend:D[i]}]},primitive:{topology:"triangle-list"}}),n.draw.set(s,t)),t}var W={circle:0,soft:1,square:2,spark:3},q={point:0,line:1,rect:2,circle:3,ring:4},V={none:0,kill:1,bounce:2,wrap:3};function A(r,e,i,n,s){i.fill(0);let t=(p,a,d,b,v)=>i.set([a,d,b,v],p*4),c=Math.PI/180;t(0,n.dt,n.time,n.emitStart,n.emitCount),t(1,r.max,r.seed,n.frameDt,r.emitter.radial?1:0),t(2,r.layer.width,r.layer.height,e.gravity[0],e.gravity[1]),t(3,e.drag,e.noise.strength,e.noise.scale,e.noise.speed);let l=r.emitter,P=e.emitter?.x??l.x,m=e.emitter?.y??l.y;t(4,q[l.shape],P,m,l.width),e.emitter&&t(30,e.emitter.previousX,e.emitter.previousY,1,0),t(5,l.height,l.radius,r.speed[0],r.speed[1]),t(6,r.direction*c,r.spread*c,r.lifetime[0],r.lifetime[1]);let f=e.attractors.slice(0,R);t(7,V[r.bounds],r.floor??-1,r.bounce,f.length);for(let[p,a]of f.entries())t(8+p,a.x,a.y,a.strength,a.radius);let u=e.push?.mask;t(16,u?1:0,e.push?.strength??0,e.push?.sweep??0,r.sizeJitter),t(17,u?.originX??0,u?.originY??0,u?.scaleX??1,u?.scaleY??1),t(18,u?.width??0,u?.height??0,r.layer.x,r.layer.y),t(19,r.size[0],r.size[1],r.fade[0],r.fade[1]),t(20,W[r.shape],r.stretch,r.colorBySpeed!==null?1:0,r.colorBySpeed??1);let o=r.colors.slice(0,L);t(21,o.length,s.scaleX,s.scaleY,r.opacity);for(let[p,a]of o.entries())t(22+p,a[0],a[1],a[2],a[3])}function $(r,e){let i=r.particleState;if(i&&i.device===e)return i;let n=r.particleStatic,s={device:e,particles:e.createBuffer({label:"particles",size:n.max*w,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC|GPUBufferUsage.COPY_DST}),frame:-1,emitted:0,carry:0,snapshots:new Map,maskBuffer:null,maskSize:0,ubo:e.createBuffer({label:"particles_params",size:S*16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST})};return r.particleState=s,s}function I(r,e){let i=e.push?.mask,n=i?i.width*i.height:0,s=Math.max(16,n*2*4);if((!r.maskBuffer||r.maskSize<s)&&(r.maskBuffer?.destroy(),r.maskBuffer=r.device.createBuffer({label:"particles_mask",size:s,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST}),r.maskSize=s),i){let t=new Float32Array(n*2);t.set(i.data.subarray(0,n)),t.set((e.push?.previous??i).data.subarray(0,n),n),r.device.queue.writeBuffer(r.maskBuffer,0,t)}return r.maskBuffer}function j(r,e,i,n,s){let{device:t}=e,c=r.particleStatic;if(i<e.frame||e.frame<0){let o=-1;for(let a of e.snapshots.keys())a<=i&&a>o&&(o=a);let p=t.createCommandEncoder({label:"particles_restore"});if(o>=0){let a=e.snapshots.get(o);p.copyBufferToBuffer(a.buffer,0,e.particles,0,c.max*w),e.emitted=a.emitted,e.carry=a.carry,e.frame=o}else p.clearBuffer(e.particles),e.emitted=0,e.carry=0,e.frame=-1;t.queue.submit([p.finish()])}let l=k(t),P=new Float32Array(S*4),m=Math.max(1,Math.round(c.substeps)),f=1/s,u=Math.round(c.prewarm*s);for(let o=e.frame+1;o<=i;o++){let p=o===0?u+1:1;for(let a=0;a<p;a++){let d=o===0?a-u:o,b=r.particleFrame(n+Math.max(0,d),s);e.carry+=Math.max(0,b.rate)*f;let v=Math.floor(e.carry);e.carry-=v,v+=Math.max(0,Math.round(b.burst)),v=Math.min(v,c.max);let y=I(e,b),O=t.createBindGroup({layout:l.simLayout,entries:[{binding:0,resource:{buffer:e.ubo}},{binding:1,resource:{buffer:e.particles}},{binding:2,resource:{buffer:y}}]});for(let x=0;x<m;x++){A(c,b,P,{dt:f/m,time:(d+x/m)*f,emitStart:e.emitted,emitCount:x===0?v:0,frameDt:f},{scaleX:1,scaleY:1}),t.queue.writeBuffer(e.ubo,0,P);let G=t.createCommandEncoder({label:"particles_step"}),g=G.beginComputePass({label:"particles_sim"});g.setPipeline(l.sim),g.setBindGroup(0,O),g.dispatchWorkgroups(Math.ceil(c.max/_)),g.end(),t.queue.submit([G.finish()])}e.emitted+=v}if(e.frame=o,o%T===0&&!e.snapshots.has(o)&&e.snapshots.size<E){let a=t.createBuffer({label:`particles_snapshot_${o}`,size:c.max*w,usage:GPUBufferUsage.COPY_SRC|GPUBufferUsage.COPY_DST}),d=t.createCommandEncoder({label:"particles_snapshot"});d.copyBufferToBuffer(e.particles,0,a,0,c.max*w),t.queue.submit([d.finish()]),e.snapshots.set(o,{buffer:a,emitted:e.emitted,carry:e.carry})}}}var C=async r=>{let{ctx:e,encoder:i,pass:n,targetView:s,targetWidth:t,targetHeight:c,props:l}=r,P=l.virtualMedia?.operation;if(P?.op!=="Particles"||!M(P.effect))return;let m=P.effect,f=m.particleStatic,u=l.fps||30,o=Math.max(0,Math.round(l.frame??0)),p=Math.round(l.compositionFrame??o),a=p-o,d=$(m,e.device);j(m,d,o,a,u),n.end();let b=new Float32Array(S*4);A(f,m.particleFrame(p,u),b,{dt:0,time:0,emitStart:0,emitCount:0,frameDt:1/u},{scaleX:t/f.layer.width,scaleY:c/f.layer.height});let v=e.renderer.getTemporaryBuffer(b),y=e.renderer.beginFrame(i,s,{r:0,g:0,b:0,a:0},t,c,"load");y.setPipeline(N(e.device,e.renderer.format,f.blend)),y.setBindGroup(0,e.device.createBindGroup({layout:k(e.device).drawLayout,entries:[{binding:0,resource:{buffer:v}},{binding:1,resource:{buffer:d.particles}}]})),y.draw(6,f.max),y.end()};var te=B({WebGPURenderer:C});export{C as ParticlesWebGPURenderer,te as default};

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

@@ -0,0 +1,203 @@
+import{a as l,d as P,f as w,h as U,j as L,m as G}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as S}from"./chunk-63SFBHEH.mjs";import{e as o}from"./chunk-BVF64D6H.mjs";o();o();var v="Gooey",$=8,V=[`struct U { v : array<vec4<f32>, 2> };
+@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;
+${l}
+
+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 radius = u.v[1].x;
+	let threshold = u.v[1].y;
+	let softness = u.v[1].z;
+
+	let R = res();
+	let rr = max(radius, 0.5);
+	let stepPx = max(1.0, rr / 16.0);
+	let sigma = rr * 0.5;
+	var acc = vec4<f32>(0.0);
+	var wsum = 0.0;
+	for (var k = -rr; k <= rr; k += stepPx) {
+		let w = exp(-(k * k) / (2.0 * sigma * sigma));
+		acc += textureSampleLevel(prev, samp, in.uv + vec2<f32>(1.0, 0.0) * k / R, 0.0) * w;
+		wsum += w;
+	}
+	return acc / wsum;
+}
+`,`struct U { v : array<vec4<f32>, 2> };
+@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;
+${l}
+
+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 radius = u.v[1].x;
+	let threshold = u.v[1].y;
+	let softness = u.v[1].z;
+
+	let R = res();
+	let rr = max(radius, 0.5);
+	let stepPx = max(1.0, rr / 16.0);
+	let sigma = rr * 0.5;
+	var acc = vec4<f32>(0.0);
+	var wsum = 0.0;
+	for (var k = -rr; k <= rr; k += stepPx) {
+		let w = exp(-(k * k) / (2.0 * sigma * sigma));
+		acc += textureSampleLevel(prev, samp, in.uv + vec2<f32>(0.0, 1.0) * k / R, 0.0) * w;
+		wsum += w;
+	}
+	return acc / wsum;
+}
+`,`struct U { v : array<vec4<f32>, 2> };
+@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;
+${l}
+
+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 radius = u.v[1].x;
+	let threshold = u.v[1].y;
+	let softness = u.v[1].z;
+
+	let b = textureSampleLevel(prev, samp, in.uv, 0.0);
+	let a = smoothstep(threshold - softness, threshold + softness, b.a);
+	if (b.a <= 0.0001) { return vec4<f32>(0.0); }
+	return vec4<f32>(b.rgb / b.a * a, a);
+}
+`],R=w(e=>({layout:P(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 W(e,r){let t=R(e),a=t.pipelines.get(r);return a||(a=V.map((p,f)=>{let u=e.createShaderModule({code:p,label:`${v}_${f}.wgsl`});return e.createRenderPipeline({label:`${v}_${f}`,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,a)),a}function h(e,r){let t=typeof e=="number"?e:Number(e);return Number.isFinite(t)?t:r}function q(e,r,t,a){r.fill(0),r[0]=t,r[1]=a,r[4]=h(e.radius,12),r[5]=h(e.threshold,.5),r[6]=h(e.softness,.04)}var T=async e=>{let{ctx:r,encoder:t,pass:a,targetTexture:p,targetWidth:f,targetHeight:u,props:n}=e,c=n.virtualMedia?.operation;if(c?.op!==v)return;let g=n.virtualMedia?.children?.[0];if(!g)return;a.end();let m=n.fps||30,i=Math.round(n.compositionFrame??n.frame??0),F=c.effect?.resolveUniforms?c.effect.resolveUniforms({frame:i,fps:m,time:i/m}):c,y=new Float32Array($);q(F,y,i/m,i);let{texture:x}=await U(e,g),d=r.device,b=R(d),_=W(d,r.renderer.format),D=r.renderer.getTemporaryBuffer(y),s=x;for(let z of _){let k=r.renderer.getTemporaryTexture(f,u,[x,s,p,...n.excludeTextures||[]]);G(t,k.createView(),z,[d.createBindGroup({layout:b.layout,entries:[{binding:0,resource:{buffer:D}},{binding:1,resource:x.createView()},{binding:2,resource:s.createView()},{binding:3,resource:b.sampler}]})]),s=k}L(e,s)};var C=S({WebGPURenderer:T});export{T as GooeyWebGPURenderer,C as default};

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

@@ -0,0 +1,81 @@
+import{a as P,d as S,f as U,h as R,j as G,m as T}from"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import{z as h}from"./chunk-63SFBHEH.mjs";import{e as s}from"./chunk-BVF64D6H.mjs";s();s();var a="Ascii",z=16,D=[`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); }
+const GLYPH_BITS = array<u32, 10>(0u, 4194304u, 131200u, 14336u, 459200u, 145536u, 332096u, 11512810u, 27070835u, 15652782u);
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let time = u.v[0].x;
+	let frame = u.v[0].y;
+	let cellSize = u.v[1].x;
+	let colorMode = u32(u.v[1].y + 0.5);
+	let fg = u.v[2];
+	let bg = u.v[3];
+	let contrast = u.v[1].z;
+	let invert = u.v[1].w;
+
+	let R = res();
+	let cs = max(cellSize, 2.0);
+	let cp = floor(in.uv * R / cs);
+	let col = sampleS((cp + 0.5) * cs / R);
+	var l = clamp((luma(col.rgb) - 0.5) * contrast + 0.5, 0.0, 1.0) * col.a;
+	if (invert > 0.5) { l = 1.0 - l; }
+	let idx = min(u32(l * 9.999), 9u);
+	let f = in.uv * R / cs - cp;
+	let gx = i32(floor(f.x * 6.0));
+	let gy = i32(floor(f.y * 6.0));
+	var on = 0.0;
+	if (gx < 5 && gy < 5) {
+		on = f32((GLYPH_BITS[idx] >> u32(gy * 5 + gx)) & 1u);
+	}
+	var fgc = fg.rgb;
+	if (colorMode == 1u) { fgc = col.rgb * 1.25; }
+	if (colorMode == 2u) { fgc = vec3<f32>(0.25, 1.0, 0.45) * (0.4 + 0.6 * l); }
+	return vec4<f32>(mix(bg.rgb, fgc, on), 1.0);
+}
+`],M=U(r=>({layout:S(r,["uniform","texture","texture","sampler"],`${a}_layout`),pipelines:new Map,sampler:r.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"})}));function $(r,e){let t=M(r),n=t.pipelines.get(e);return n||(n=D.map((p,i)=>{let u=r.createShaderModule({code:p,label:`${a}_${i}.wgsl`});return r.createRenderPipeline({label:`${a}_${i}`,layout:r.createPipelineLayout({bindGroupLayouts:[t.layout]}),vertex:{module:u,entryPoint:"vs"},fragment:{module:u,entryPoint:"fs",targets:[{format:e}]},primitive:{topology:"triangle-strip"}})}),t.pipelines.set(e,n)),n}function k(r,e){let t=typeof r=="number"?r:Number(r);return Number.isFinite(t)?t:e}function F(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 B(r,e,t,n){e.fill(0),e[0]=t,e[1]=n,e[4]=k(r.cellSize,10),e[5]=Math.max(0,["mono","source","green"].indexOf(String(r.colorMode??"mono"))),e.set(F(String(r.fg??"#e8e8e8")),8),e.set(F(String(r.bg??"#0b0b0b")),12),e[6]=k(r.contrast,1.2),e[7]=r.invert===void 0?0:r.invert?1:0}var L=async r=>{let{ctx:e,encoder:t,pass:n,targetTexture:p,targetWidth:i,targetHeight:u,props:o}=r,c=o.virtualMedia?.operation;if(c?.op!==a)return;let g=o.virtualMedia?.children?.[0];if(!g)return;n.end();let m=o.fps||30,l=Math.round(o.compositionFrame??o.frame??0),w=c.effect?.resolveUniforms?c.effect.resolveUniforms({frame:l,fps:m,time:l/m}):c,x=new Float32Array(z);B(w,x,l/m,l);let{texture:v}=await R(r,g),d=e.device,b=M(d),_=$(d,e.renderer.format),A=e.renderer.getTemporaryBuffer(x),f=v;for(let N of _){let y=e.renderer.getTemporaryTexture(i,u,[v,f,p,...o.excludeTextures||[]]);T(t,y.createView(),N,[d.createBindGroup({layout:b.layout,entries:[{binding:0,resource:{buffer:A}},{binding:1,resource:v.createView()},{binding:2,resource:f.createView()},{binding:3,resource:b.sampler}]})]),f=y}G(r,f)};var q=h({WebGPURenderer:L});export{L as AsciiWebGPURenderer,q as default};

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

@@ -0,0 +1 @@
+import{a}from"./chunk-BSOJR4JU.mjs";import"./chunk-2JKXYG6J.mjs";import"./chunk-7I7PKKDL.mjs";import"./chunk-ENKKLU7B.mjs";import"./chunk-6YJP57MZ.mjs";import"./chunk-63SFBHEH.mjs";import"./chunk-BVF64D6H.mjs";export{a as default};