framefields 2.0.2

package/dist/preview-engine/chunk-U446SQP3.mjs

@@ -0,0 +1,292 @@
+import{a as oe}from"./chunk-XOEEGC4Z.mjs";import{b as le,c as se}from"./chunk-IYVN2QEL.mjs";import{a as u}from"./chunk-NQZKBFC6.mjs";import{a as ne}from"./chunk-YSTLMWCG.mjs";import{d as L}from"./chunk-6YJP57MZ.mjs";import{e as s}from"./chunk-BVF64D6H.mjs";s();s();s();s();var O=0,F=1,B=.5,W=50,H=0,z=100,X=0,k=50,$=-100,Y=100,Ee=u.enum(["Alpha","Luminance","Red","Green","Blue"]),Te=u.enum(["Composite","MatteOnly","DecontaminatedRGB"]),Ce=oe().field("decontaminateAmount",u.number().multipleOf(.01).min(O).max(F).default(.7),{bindable:!0,dataTypes:["Number","Signal"],label:"Decontaminate Colors",description:"Amount of edge color spill decontamination/defringing (0.0\u20131.0)."}).field("radius",u.number().multipleOf(.1).min(B).max(W).default(2),{bindable:!0,dataTypes:["Number","Signal"],label:"Edge Detection Radius (px)",description:"Radius in pixels around alpha transitions to refine and decontaminate."}).field("smooth",u.number().min(H).max(z).default(5),{bindable:!0,dataTypes:["Number","Signal"],label:"Smoothness",description:"Matte edge smoothing curve intensity (0\u2013100)."}).field("feather",u.number().multipleOf(.1).min(X).max(k).default(.5),{bindable:!0,dataTypes:["Number","Signal"],label:"Feather (px)",description:"Sub-pixel gaussian softness along the matte boundary."}).field("shiftEdge",u.number().min($).max(Y).default(0),{bindable:!0,dataTypes:["Number","Signal"],label:"Shift Edge (%)",description:"Contract (<0) or expand (>0) the edge boundary (-100% to +100%)."}).field("matteChannel",Ee.default("Alpha"),{label:"Matte Channel",description:"Channel to extract matte from (Alpha, Luminance, Red, Green, Blue)."}).field("outputMode",Te.default("Composite"),{label:"Output Mode",description:"Composite (decontaminated RGB + refined alpha), MatteOnly (grayscale mask), DecontaminatedRGB (clean RGB with full alpha)."}).build(),_e=Ce.schema,Ve=u.union([le,se]);s();var Ge={Alpha:0,Luminance:1,Red:2,Green:3,Blue:4},Ie={Composite:0,MatteOnly:1,DecontaminatedRGB:2},we=`
+struct RefineEdgeUniforms {
+	dirX                : f32,
+	dirY                : f32,
+	decontaminateAmount : f32,
+	radius              : f32,
+
+	smoothness          : f32,
+	feather             : f32,
+	shiftEdge           : f32,
+	matteChannel        : f32,
+
+	outputMode          : f32,
+	hasMatte            : f32,
+	hasDecontamSig      : f32,
+	hasRadiusSig        : f32,
+
+	hasSmoothSig        : f32,
+	hasFeatherSig       : f32,
+	hasShiftEdgeSig     : f32,
+	isSecondPass        : f32,
+
+	pad0                : f32,
+	pad1                : f32,
+	pad2                : f32,
+	pad3                : f32,
+};
+
+@group(0) @binding(0) var<uniform> u          : RefineEdgeUniforms;
+
+@group(1) @binding(0) var texInput            : texture_2d<f32>;
+@group(1) @binding(1) var texMatte            : texture_2d<f32>;
+@group(1) @binding(2) var origTex             : texture_2d<f32>;
+@group(1) @binding(3) var samp                : sampler;
+
+@group(2) @binding(0) var decontamSigTex      : texture_2d<f32>;
+@group(2) @binding(1) var radiusSigTex        : texture_2d<f32>;
+@group(2) @binding(2) var smoothSigTex        : texture_2d<f32>;
+@group(2) @binding(3) var featherSigTex       : texture_2d<f32>;
+@group(2) @binding(4) var shiftEdgeSigTex     : texture_2d<f32>;
+@group(2) @binding(5) var signalSamp          : sampler;
+
+struct VSOut {
+	@builtin(position) pos : vec4<f32>,
+	@location(0) uv        : vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> VSOut {
+	var pos = array<vec2<f32>, 4>(
+		vec2<f32>(-1.0, 1.0),
+		vec2<f32>(1.0, 1.0),
+		vec2<f32>(-1.0, -1.0),
+		vec2<f32>(1.0, -1.0)
+	);
+	var uv = array<vec2<f32>, 4>(
+		vec2<f32>(0.0, 0.0),
+		vec2<f32>(1.0, 0.0),
+		vec2<f32>(0.0, 1.0),
+		vec2<f32>(1.0, 1.0)
+	);
+	return VSOut(vec4<f32>(pos[vi], 0.0, 1.0), uv[vi]);
+}
+
+fn extractChannel(color : vec4<f32>, chCode : f32) -> f32 {
+	if (chCode < 0.5) {
+		// Alpha
+		return color.a;
+	} else if (chCode < 1.5) {
+		// Luminance
+		let luma = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+		if (color.a > 1e-4) {
+			return min(1.0, luma / color.a);
+		}
+		return luma;
+	} else if (chCode < 2.5) {
+		// Red
+		if (color.a > 1e-4) {
+			return min(1.0, color.r / color.a);
+		}
+		return color.r;
+	} else if (chCode < 3.5) {
+		// Green
+		if (color.a > 1e-4) {
+			return min(1.0, color.g / color.a);
+		}
+		return color.g;
+	} else {
+		// Blue
+		if (color.a > 1e-4) {
+			return min(1.0, color.b / color.a);
+		}
+		return color.b;
+	}
+}
+
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+	let dimensions = vec2<f32>(textureDimensions(texInput));
+	let texelSize = 1.0 / max(dimensions, vec2<f32>(1.0, 1.0));
+
+	var decontam = u.decontaminateAmount;
+	if (u.hasDecontamSig > 0.5) {
+		decontam = clamp(textureSampleLevel(decontamSigTex, signalSamp, vec2<f32>(0.5, 0.5), 0.0).r, 0.0, 1.0);
+	}
+	var radius = u.radius;
+	if (u.hasRadiusSig > 0.5) {
+		radius = clamp(textureSampleLevel(radiusSigTex, signalSamp, vec2<f32>(0.5, 0.5), 0.0).r, 0.5, 50.0);
+	}
+	var smoothVal = u.smoothness;
+	if (u.hasSmoothSig > 0.5) {
+		smoothVal = clamp(textureSampleLevel(smoothSigTex, signalSamp, vec2<f32>(0.5, 0.5), 0.0).r, 0.0, 100.0);
+	}
+	var featherVal = u.feather;
+	if (u.hasFeatherSig > 0.5) {
+		featherVal = clamp(textureSampleLevel(featherSigTex, signalSamp, vec2<f32>(0.5, 0.5), 0.0).r, 0.0, 50.0);
+	}
+	var shiftEdgeVal = u.shiftEdge;
+	if (u.hasShiftEdgeSig > 0.5) {
+		shiftEdgeVal = clamp(textureSampleLevel(shiftEdgeSigTex, signalSamp, vec2<f32>(0.5, 0.5), 0.0).r, -100.0, 100.0);
+	}
+
+	let direction = vec2<f32>(u.dirX, u.dirY);
+
+	// Combined sigma for smoothing & feathering
+	let smoothSigma = max(0.0, smoothVal * 0.15);
+	let featherSigma = max(0.0, featherVal);
+	let totalSigma = max(0.1, sqrt(smoothSigma * smoothSigma + featherSigma * featherSigma));
+
+	if (u.isSecondPass <= 0.5) {
+		// =============================================================
+		// PASS 1: Horizontal Pass (Alpha filter + FG color sampling)
+		// =============================================================
+		let centerInput = textureSampleLevel(texInput, samp, in.uv, 0.0);
+		let centerMatte = textureSampleLevel(texMatte, samp, in.uv, 0.0);
+
+		var centerRawAlpha = centerInput.a;
+		if (u.hasMatte > 0.5) {
+			centerRawAlpha = extractChannel(centerMatte, u.matteChannel);
+		}
+
+		// 1. Horizontal Alpha Blur / Filter
+		var alphaAccum = 0.0;
+		var alphaWeightSum = 0.0;
+
+		let stepScale = max(1.0, totalSigma / 15.0);
+		let effectiveSigma = totalSigma / stepScale;
+		let sampleRadius = min(i32(ceil(3.0 * effectiveSigma)), 32);
+
+		for (var i = -sampleRadius; i <= sampleRadius; i++) {
+			let offset = vec2<f32>(f32(i) * stepScale) * direction * texelSize;
+			let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+			let sampleInput = textureSampleLevel(texInput, samp, sampleUv, 0.0);
+			var sAlpha = sampleInput.a;
+			if (u.hasMatte > 0.5) {
+				let sMatte = textureSampleLevel(texMatte, samp, sampleUv, 0.0);
+				sAlpha = extractChannel(sMatte, u.matteChannel);
+			}
+
+			let dist = f32(i) * stepScale;
+			let weight = exp(-0.5 * (dist / totalSigma) * (dist / totalSigma));
+			alphaAccum += sAlpha * weight;
+			alphaWeightSum += weight;
+		}
+
+		let smoothedAlpha = alphaAccum / max(alphaWeightSum, 1e-5);
+
+		// 2. Horizontal Foreground Color Sampling for Defringing
+		var fgColorAccum = vec3<f32>(0.0);
+		var fgWeightSum = 0.0;
+
+		let rStepScale = max(1.0, radius / 15.0);
+		let rSampleCount = min(i32(ceil(radius / rStepScale)), 32);
+
+		for (var i = -rSampleCount; i <= rSampleCount; i++) {
+			let offset = vec2<f32>(f32(i) * rStepScale) * direction * texelSize;
+			let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+			let sampleCol = textureSampleLevel(texInput, samp, sampleUv, 0.0);
+			var sampleA = sampleCol.a;
+			if (u.hasMatte > 0.5) {
+				let sm = textureSampleLevel(texMatte, samp, sampleUv, 0.0);
+				sampleA = extractChannel(sm, u.matteChannel);
+			}
+
+			let sampleRgb = select(sampleCol.rgb, sampleCol.rgb / max(sampleCol.a, 1e-4), sampleCol.a > 1e-4);
+			let spatialDist = f32(i) * rStepScale;
+			let spatialWeight = exp(-0.5 * (spatialDist / max(radius, 0.5)) * (spatialDist / max(radius, 0.5)));
+			// Weight foreground pixels by alpha confidence
+			let fgConfidence = clamp((sampleA - 0.2) / 0.8, 0.0, 1.0);
+			let weight = fgConfidence * spatialWeight;
+
+			fgColorAccum += sampleRgb * weight;
+			fgWeightSum += weight;
+		}
+
+		let centerUnpremult = select(centerInput.rgb, centerInput.rgb / max(centerInput.a, 1e-4), centerInput.a > 1e-4);
+		let fgColor = select(centerUnpremult, fgColorAccum / max(fgWeightSum, 1e-5), fgWeightSum > 1e-4);
+
+		return vec4<f32>(fgColor, smoothedAlpha);
+	}
+
+	// =============================================================
+	// PASS 2: Vertical Pass & Final Defringe/Composite
+	// =============================================================
+	let pass1Sample = textureSampleLevel(texInput, samp, in.uv, 0.0);
+	let origSample = textureSampleLevel(origTex, samp, in.uv, 0.0);
+
+	var rawMatteAlpha = origSample.a;
+	if (u.hasMatte > 0.5) {
+		let rawMatteSample = textureSampleLevel(texMatte, samp, in.uv, 0.0);
+		rawMatteAlpha = extractChannel(rawMatteSample, u.matteChannel);
+	}
+
+	// 1. Vertical Alpha Blur / Filter
+	var alphaAccum = 0.0;
+	var alphaWeightSum = 0.0;
+
+	let stepScale = max(1.0, totalSigma / 15.0);
+	let effectiveSigma = totalSigma / stepScale;
+	let sampleRadius = min(i32(ceil(3.0 * effectiveSigma)), 32);
+
+	for (var i = -sampleRadius; i <= sampleRadius; i++) {
+		let offset = vec2<f32>(f32(i) * stepScale) * direction * texelSize;
+		let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+		let sPass1 = textureSampleLevel(texInput, samp, sampleUv, 0.0);
+		let sAlpha = sPass1.a;
+
+		let dist = f32(i) * stepScale;
+		let weight = exp(-0.5 * (dist / totalSigma) * (dist / totalSigma));
+		alphaAccum += sAlpha * weight;
+		alphaWeightSum += weight;
+	}
+
+	var refinedAlpha = alphaAccum / max(alphaWeightSum, 1e-5);
+
+	// 2. Shift Edge (Choke < 0 or Expand > 0)
+	if (abs(shiftEdgeVal) > 0.01) {
+		let shiftNorm = shiftEdgeVal / 100.0;
+		if (shiftNorm < 0.0) {
+			// Contract / Choke
+			let chokeLimit = abs(shiftNorm);
+			refinedAlpha = clamp((refinedAlpha - chokeLimit) / max(1.0 - chokeLimit, 1e-4), 0.0, 1.0);
+		} else {
+			// Expand / Dilate
+			refinedAlpha = clamp(refinedAlpha / max(1.0 - shiftNorm, 1e-4), 0.0, 1.0);
+		}
+	}
+
+	// 3. Vertical Foreground Color Sampling for Defringing
+	var fgColorAccum = vec3<f32>(0.0);
+	var fgWeightSum = 0.0;
+
+	let rStepScale = max(1.0, radius / 15.0);
+	let rSampleCount = min(i32(ceil(radius / rStepScale)), 32);
+
+	for (var i = -rSampleCount; i <= rSampleCount; i++) {
+		let offset = vec2<f32>(f32(i) * rStepScale) * direction * texelSize;
+		let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+		let sPass1 = textureSampleLevel(texInput, samp, sampleUv, 0.0);
+		let sRgb = sPass1.rgb;
+		let sA = sPass1.a;
+
+		let spatialDist = f32(i) * rStepScale;
+		let spatialWeight = exp(-0.5 * (spatialDist / max(radius, 0.5)) * (spatialDist / max(radius, 0.5)));
+		let fgConfidence = clamp((sA - 0.2) / 0.8, 0.0, 1.0);
+		let weight = fgConfidence * spatialWeight;
+
+		fgColorAccum += sRgb * weight;
+		fgWeightSum += weight;
+	}
+
+	let origUnpremult = select(origSample.rgb, origSample.rgb / max(origSample.a, 1e-4), origSample.a > 1e-4);
+	let fgColor = select(origUnpremult, fgColorAccum / max(fgWeightSum, 1e-5), fgWeightSum > 1e-4);
+
+	// Edge zone detection: transitions between foreground and background
+	let edgeWeight = clamp(4.0 * rawMatteAlpha * (1.0 - rawMatteAlpha), 0.0, 1.0);
+	let decontamFactor = clamp(decontam * max(edgeWeight, (1.0 - refinedAlpha) * 0.8), 0.0, 1.0);
+
+	let decontaminatedColor = mix(origUnpremult, fgColor, decontamFactor);
+
+	// Format Output
+	let mode = u.outputMode;
+	if (mode < 0.5) {
+		// Composite: Decontaminated RGB with refined alpha (premultiplied)
+		return vec4<f32>(decontaminatedColor * refinedAlpha, refinedAlpha);
+	} else if (mode < 1.5) {
+		// MatteOnly: Grayscale refined alpha mask
+		return vec4<f32>(refinedAlpha, refinedAlpha, refinedAlpha, 1.0);
+	} else {
+		// DecontaminatedRGB: Clean defringed RGB with full alpha
+		return vec4<f32>(decontaminatedColor, 1.0);
+	}
+}
+`,de=new WeakMap;function Pe(r,e){let d=de.get(r);if(d)return d;let E=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}}]}),T=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:3,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]}),p=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:4,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:5,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]}),f=r.createShaderModule({code:we}),v=r.createPipelineLayout({bindGroupLayouts:[E,T,p]}),t=r.createRenderPipeline({layout:v,vertex:{module:f,entryPoint:"vs"},fragment:{module:f,entryPoint:"fs",targets:[{format:e}]},primitive:{topology:"triangle-strip"}}),b={uniformLayout:E,textureLayout:T,signalTextureLayout:p,pipeline:t};return de.set(r,b),b}var ue=async r=>{let{ctx:e,encoder:d,pass:E,targetView:T,targetTexture:p,targetWidth:f,targetHeight:v,props:t,drawChild:b}=r,a=t.virtualMedia?.operation;if(a?.op!=="RefineEdge"||!a)return;let I=t.virtualMedia?.children?.[0];if(!I)return;E.end();let j=t.frame??0,q=t.fps||30,n=f,o=v,M=(i,x,C=0,re=1e3)=>{if(i&&a.inputs?.[i]?.connectionValid){let c=a.inputs[i].outputItem;if(c?.type==="Number"){let Ae=typeof c.data=="number"?c.data:c.data?.value??x;return{val:Math.max(C,Math.min(re,Ae)),hasStaticSig:!1,sd:null,handleId:i}}if(c?.type==="Signal"&&c.data)return{val:x,hasStaticSig:!0,sd:c.data,handleId:i}}return{val:Math.max(C,Math.min(re,x)),hasStaticSig:!1,sd:null,handleId:i}},w=M(a.decontaminateAmountHandleId,Number(a.decontaminateAmount??.7),O,F),P=M(a.radiusHandleId,Number(a.radius??2),B,W),D=M(a.smoothHandleId,Number(a.smooth??5),H,z),N=M(a.featherHandleId,Number(a.feather??.5),X,k),U=M(a.shiftEdgeHandleId,Number(a.shiftEdge??0),$,Y),m=e.renderer.getTemporaryTexture(n,o,[...t.excludeTextures||[],p]),g=m.createView();e.renderer.beginFrame(d,g,{r:0,g:0,b:0,a:0},n,o,"clear").end(),e.renderer.pushScissor({x:0,y:0,width:n,height:o}),e.renderer.pushIdentity(),await b(I,{...t,virtualMedia:I,renderId:`${t.renderId}-input`,excludeTextures:[...t.excludeTextures||[],m]},g,m,n,o),e.renderer.popTransform(),e.renderer.popScissor();let l=null;if(a.matteMedia){l=e.renderer.getTemporaryTexture(n,o,[...t.excludeTextures||[],p,m]);let i=l.createView();e.renderer.beginFrame(d,i,{r:0,g:0,b:0,a:0},n,o,"clear").end(),e.renderer.pushScissor({x:0,y:0,width:n,height:o}),e.renderer.pushIdentity(),await b(a.matteMedia,{...t,virtualMedia:a.matteMedia,renderId:`${t.renderId}-matte`,excludeTextures:[...t.excludeTextures||[],m,l]},i,l,n,o),e.renderer.popTransform(),e.renderer.popScissor()}let{pipeline:J,uniformLayout:K,textureLayout:Q,signalTextureLayout:pe}=Pe(e.device,e.renderer.format),_=e.renderer.samplerCache.getSampler(e.device),me=t.elapsedMs!==void 0?t.elapsedMs/1e3:j/q,ce=t.virtualMedia?.metadata?.durationMs?t.virtualMedia.metadata.durationMs/1e3:t.durationMs!==void 0?t.durationMs/1e3:0,y=(i,x)=>{if(i.hasStaticSig&&i.sd){let C=i.sd.nodeId??i.handleId??`${t.renderId??"refineedge"}_${x}`;return L.getOrCreate2DTextureView(e.device,d,C,me,ce,i.sd,n,o,t.renderId,j,q)}return L.getDummy1x1TextureView(e.device)},fe=y(w,"decontam_sig"),ge=y(P,"radius_sig"),he=y(D,"smooth_sig"),Se=y(N,"feather_sig"),xe=y(U,"shiftEdge_sig"),Z=e.device.createBindGroup({layout:pe,entries:[{binding:0,resource:fe},{binding:1,resource:ge},{binding:2,resource:he},{binding:3,resource:Se},{binding:4,resource:xe},{binding:5,resource:_}]}),ve=Ge[a.matteChannel??"Alpha"]??0,be=Ie[a.outputMode??"Composite"]??0,ee=l?l.createView():g,R=new Float32Array(20),A=new Float32Array(20),te=[0,0,w.val,P.val,D.val,N.val,U.val,ve,be,l?1:0,w.hasStaticSig?1:0,P.hasStaticSig?1:0,D.hasStaticSig?1:0,N.hasStaticSig?1:0,U.hasStaticSig?1:0,0,0,0,0,0];R.set(te),R[0]=1,R[1]=0,R[15]=0,A.set(te),A[0]=0,A[1]=1,A[15]=1;let V=e.renderer.getTemporaryTexture(n,o,[m,...l?[l]:[],p,...t.excludeTextures||[]]),ae=e.renderer.getTemporaryTexture(n,o,[m,...l?[l]:[],V,p,...t.excludeTextures||[]]),Me=e.renderer.getTemporaryBuffer(R),h=d.beginRenderPass({colorAttachments:[{view:V.createView(),loadOp:"clear",storeOp:"store",clearValue:{r:0,g:0,b:0,a:0}}]});h.setPipeline(J),h.setBindGroup(0,e.device.createBindGroup({layout:K,entries:[{binding:0,resource:{buffer:Me}}]})),h.setBindGroup(1,e.device.createBindGroup({layout:Q,entries:[{binding:0,resource:g},{binding:1,resource:ee},{binding:2,resource:g},{binding:3,resource:_}]})),h.setBindGroup(2,Z),h.draw(4),h.end();let ye=e.renderer.getTemporaryBuffer(A),S=d.beginRenderPass({colorAttachments:[{view:ae.createView(),loadOp:"clear",storeOp:"store",clearValue:{r:0,g:0,b:0,a:0}}]});S.setPipeline(J),S.setBindGroup(0,e.device.createBindGroup({layout:K,entries:[{binding:0,resource:{buffer:ye}}]})),S.setBindGroup(1,e.device.createBindGroup({layout:Q,entries:[{binding:0,resource:V.createView()},{binding:1,resource:ee},{binding:2,resource:g},{binding:3,resource:_}]})),S.setBindGroup(2,Z),S.draw(4),S.end();let ie=e.renderer.beginFrame(d,T,{r:0,g:0,b:0,a:0},f,v,"load"),Re=t.opacity??a.opacity??1;e.renderer.drawTexture(ie,ae,{x:0,y:0,width:f,height:v},{opacity:Re}),r.pass=ie};var Je=ne({WebGPURenderer:ue});export{ue as a,Je as b};

package/dist/preview-engine/chunk-UDNCEHUI.mjs

@@ -0,0 +1,141 @@
+import{a as V}from"./chunk-YSTLMWCG.mjs";import{d as P}from"./chunk-6YJP57MZ.mjs";import{e as x}from"./chunk-BVF64D6H.mjs";x();x();var Y=`
+struct FilmUniforms {
+    strength    : f32,
+    size        : f32,
+    monochrome  : f32,
+    animated    : f32,
+
+    frameIndex  : f32, // discrete per-output-frame counter (speed-scaled), NOT continuous time
+    shadows     : f32,
+    midtones    : f32,
+    highlights  : f32,
+
+    hasSignal   : f32,
+    _pad0       : f32,
+    _pad1       : f32,
+    _pad2       : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : FilmUniforms;
+@group(1) @binding(0) var tex        : texture_2d<f32>;
+@group(1) @binding(1) var samp       : sampler;
+@group(2) @binding(0) var signalTex  : texture_2d<f32>;
+@group(2) @binding(1) var signalSamp : sampler;
+
+struct VSOut {
+    @builtin(position) pos : vec4<f32>,
+    @location(0) uv        : vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> VSOut {
+    var pos = array<vec2<f32>, 4>(
+        vec2<f32>(-1.0, 1.0),
+        vec2<f32>(1.0, 1.0),
+        vec2<f32>(-1.0, -1.0),
+        vec2<f32>(1.0, -1.0)
+    );
+    var uv = array<vec2<f32>, 4>(
+        vec2<f32>(0.0, 0.0),
+        vec2<f32>(1.0, 0.0),
+        vec2<f32>(0.0, 1.0),
+        vec2<f32>(1.0, 1.0)
+    );
+    return VSOut(vec4<f32>(pos[vi], 0.0, 1.0), uv[vi]);
+}
+
+fn hash2D(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 smoothNoise(p: vec2<f32>) -> f32 {
+    let pi = floor(p);
+    let pf = fract(p);
+
+    // Quintic interpolation
+    let w = pf * pf * pf * (pf * (pf * 6.0 - 15.0) + 10.0);
+
+    let h00 = hash2D(pi + vec2<f32>(0.0, 0.0));
+    let h10 = hash2D(pi + vec2<f32>(1.0, 0.0));
+    let h01 = hash2D(pi + vec2<f32>(0.0, 1.0));
+    let h11 = hash2D(pi + vec2<f32>(1.0, 1.0));
+
+    let n0 = mix(h00, h10, w.x);
+    let n1 = mix(h01, h11, w.x);
+
+    return mix(n0, n1, w.y);
+}
+
+// Produces a pseudo-random, NON-directional offset that changes once per
+// output frame. This replaces the old time * constant translation, which
+// smoothly scrolled the noise lattice in a fixed direction (17.31, 43.19)
+// every frame -- that's why grain visibly drifted instead of flickering.
+//
+// The frame index is wrapped into a bounded range before hashing so the
+// pattern stays high quality over long renders (f32 precision degrades on
+// very large hash inputs); the wrap period is long enough that any repeat
+// is imperceptible in grain.
+fn frameJitter(frameIndex: f32) -> vec2<f32> {
+    let raw = floor(frameIndex);
+    let n = raw - floor(raw / 4096.0) * 4096.0;
+    let hx = hash2D(vec2<f32>(n, n * 1.6180339887));
+    let hy = hash2D(vec2<f32>(n * 3.14159265, n + 91.7));
+    return vec2<f32>(hx, hy) * 1024.0;
+}
+
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+    var color = textureSampleLevel(tex, samp, in.uv, 0.0);
+
+    var strength = u.strength;
+    if (u.hasSignal > 0.5) {
+        let sigVal = textureSampleLevel(signalTex, signalSamp, in.uv, 0.0).r;
+        strength = sigVal;
+    }
+
+    if (strength <= 0.0) {
+        return color;
+    }
+
+    let dimensions = vec2<f32>(textureDimensions(tex));
+    let grainCoord = (in.uv * dimensions) / u.size;
+
+    let jitter = select(vec2<f32>(0.0), frameJitter(u.frameIndex), u.animated > 0.5);
+
+    let luminance = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+
+    // Luminance response curve logic
+    let shadowFactor = exp(-luminance * luminance / 0.1);
+    let highlightFactor = exp(-(1.0 - luminance) * (1.0 - luminance) / 0.1);
+    let midtoneFactor = max(0.0, 1.0 - shadowFactor - highlightFactor);
+
+    let response = (u.shadows * shadowFactor) + (u.midtones * midtoneFactor) + (u.highlights * highlightFactor);
+    let finalGrainStrength = (strength / 100.0) * response * 0.15; // Normalized scale
+
+    if (u.monochrome > 0.5) {
+        let seed = grainCoord + jitter;
+        let noiseVal = smoothNoise(seed);
+        let grain = (noiseVal - 0.5) * finalGrainStrength;
+        color.r += grain;
+        color.g += grain;
+        color.b += grain;
+    } else {
+        // Fixed per-channel spatial offsets (unrelated to time) keep the
+        // R/G/B lattices decorrelated from each other; temporal variation
+        // comes entirely from jitter now.
+        let seedR = grainCoord + jitter;
+        let seedG = grainCoord + jitter + vec2<f32>(173.3, 281.9);
+        let seedB = grainCoord + jitter + vec2<f32>(391.7, 127.1);
+
+        let noiseR = smoothNoise(seedR);
+        let noiseG = smoothNoise(seedG);
+        let noiseB = smoothNoise(seedB);
+
+        color.r += (noiseR - 0.5) * finalGrainStrength;
+        color.g += (noiseG - 0.5) * finalGrainStrength;
+        color.b += (noiseB - 0.5) * finalGrainStrength;
+    }
+
+    return clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+}
+`,B=new WeakMap,o=new Float32Array(12);function Z(r){let e=B.get(r);if(e)return e;let t=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}}]}),c=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]}),s=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]});return e={filmUniformLayout:t,singleTextureLayout:c,signalTextureLayout:s,pipelineCache:new Map},B.set(r,e),e}function ee(r,e){let t=Z(r),c=`filmgrain_${e}`,s=t.pipelineCache.get(c);if(!s){let m=r.createShaderModule({label:`filmgrain_${e}.wgsl`,code:Y});s=r.createRenderPipeline({label:`FilmGrainPipeline_${e}`,layout:r.createPipelineLayout({bindGroupLayouts:[t.filmUniformLayout,t.singleTextureLayout,t.signalTextureLayout]}),vertex:{module:m,entryPoint:"vs"},fragment:{module:m,entryPoint:"fs",targets:[{format:e}]},primitive:{topology:"triangle-strip"}}),t.pipelineCache.set(c,s)}return{filmPipeline:s,filmUniformLayout:t.filmUniformLayout,singleTextureLayout:t.singleTextureLayout,signalTextureLayout:t.signalTextureLayout}}var C=async r=>{let{ctx:e,encoder:t,pass:c,targetView:s,targetTexture:m,targetWidth:b,targetHeight:G,props:i,drawChild:_}=r,h=i.frame??0,w=i.fps||30,n=i.virtualMedia?.operation;if(n?.op!=="FilmGrain"||!n)return;let S=i.virtualMedia.children?.[0];if(!S)return;c.end();let u=b,p=G,O=i.containerWidth??e.surface.width/(typeof window<"u"?window.devicePixelRatio:1),A=u/O,l=n.strengthHandleId?n.inputs?.[n.strengthHandleId]:null,L=!!(l?.connectionValid&&(l.outputItem?.type==="Signal"||l.outputItem?.type==="Numeric")),g=L&&l?.outputItem?.data?l.outputItem.data:null,d=(a,N)=>{if(a==null)return N;typeof a=="object"&&"value"in a?a=a.value:typeof a=="function"&&(a=a(h,w));let I=Number(a);return Number.isFinite(I)?I:N},y=0,T=!1;L?g&&(y=Math.max(0,Number(g.offset??0)),T=!0):l?.connectionValid&&l.outputItem?.type==="Number"?y=Math.max(0,Number(l.outputItem.data??0)):y=Math.max(0,d(n.strength,15));let v=e.renderer.getTemporaryTexture(u,p,[...i.excludeTextures||[],m]),R=v.createView();e.renderer.beginFrame(t,R,{r:0,g:0,b:0,a:0},u,p,"clear").end(),e.renderer.pushScissor({x:0,y:0,width:u,height:p}),e.renderer.pushIdentity(),await _(S,{...i,virtualMedia:S},R,v,u,p),e.renderer.popTransform(),e.renderer.popScissor(),r.pass.end();let{filmPipeline:W,filmUniformLayout:k,singleTextureLayout:z,signalTextureLayout:j}=ee(e.device,e.renderer.format),U=e.renderer.samplerCache.getSampler(e.device),F,E=i.elapsedMs!==void 0?i.elapsedMs/1e3:h/w,H=i.virtualMedia?.metadata?.durationMs?i.virtualMedia.metadata.durationMs/1e3:i.durationMs!==void 0?i.durationMs/1e3:0;T&&g?F=P.getOrCreate2DTextureView(e.device,t,g.nodeId??"filmgrain_strength_sig",E,H,g,u,p,i.renderId,h,w):F=P.getDummy1x1TextureView(e.device);let $=Math.max(.5,d(n.size,1.5))*A,J=n.animated??!0,q=d(n.speed,50),K=h*(q/50);o[0]=y,o[1]=$,o[2]=n.monochrome??!0?1:0,o[3]=J?1:0,o[4]=K,o[5]=d(n.shadows,.2),o[6]=d(n.midtones,1),o[7]=d(n.highlights,.2),o[8]=T?1:0;let Q=e.renderer.getTemporaryBuffer(o),M=e.renderer.getTemporaryTexture(u,p,[v,m,...i.excludeTextures||[]]),f=t.beginRenderPass({colorAttachments:[{view:M.createView(),loadOp:"clear",storeOp:"store",clearValue:{r:0,g:0,b:0,a:0}}]});f.setPipeline(W),f.setBindGroup(0,e.device.createBindGroup({layout:k,entries:[{binding:0,resource:{buffer:Q}}]})),f.setBindGroup(1,e.renderer.bindGroupCache.getBindGroup(e.device,z,v,U)),f.setBindGroup(2,e.device.createBindGroup({layout:j,entries:[{binding:0,resource:F},{binding:1,resource:U}]})),f.draw(4),f.end();let D=e.renderer.beginFrame(t,s,{r:0,g:0,b:0,a:0},b,G,"load");e.renderer.drawTexture(D,M,{x:0,y:0,width:b,height:G},{opacity:d(n.opacity,1)}),r.pass=D};var se=V({WebGPURenderer:C});export{se as a};