shaders 3.0.449 → 3.0.451

package/dist/core/LensDistortion-DG4VHEXV.js

@@ -0,0 +1,435 @@
+import { N as unpremultiplyAlpha, b as Expr, d as ZERO, g as expr, p as call, x as formatFloat } from "./edges-BZUKQxSE.js";
+import { t as isMobileGpuViewport } from "./device-BODv_4aH.js";
+import { c as transformPosition, r as transformAngle } from "./transformations-CsPUHppB.js";
+var MAX_SAMPLES = 50;
+var MAX_TAPS = isMobileGpuViewport() ? 24 : MAX_SAMPLES;
+const componentDefinition = {
+	name: "LensDistortion",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Split content into shifting chromatic layers with barrel or pincushion lens warp. Powered by Paper Shaders.",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the lens effect — the focus zone, lens warp, circle crop and swirl all pivot around it",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		spread: {
+			default: .6,
+			description: "Strength of the color split; how far the color layers are pushed apart (0 is off)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Spread",
+				group: "Spread"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Direction of the spread in degrees",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Spread"
+			}
+		},
+		perspective: {
+			default: .1,
+			description: "Shapes the spread direction from a straight line (0) to a radial burst out from the centre (1)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Perspective",
+				group: "Spread"
+			}
+		},
+		bias: {
+			default: 1,
+			description: "Shifts the colors toward one end of the spread; 0 spaces them evenly",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Bias",
+				group: "Spread"
+			}
+		},
+		count: {
+			default: 35,
+			description: "Number of sampled color layers along the spread; higher is smoother and costlier",
+			ui: {
+				type: ["range", "map"],
+				min: 2,
+				max: MAX_SAMPLES,
+				step: 1,
+				label: "Count",
+				group: "Spread"
+			}
+		},
+		dispersion: {
+			default: 1,
+			description: "Overall amount of color dispersion; 1 gives each layer its own color from the spectrum, 0 keeps the original color",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Dispersion",
+				group: "Dispersion"
+			}
+		},
+		dispersionShift: {
+			default: 0,
+			description: "Balance of the dispersion between a soft circular zone at the centre and the rest; -1 keeps it in the centre only, 1 at the edges only",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Shift",
+				group: "Dispersion"
+			}
+		},
+		dispersionColor: {
+			default: .6,
+			description: "Rotates the dispersion colors around the hue wheel, 0 to 1 for a full turn",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Hue",
+				group: "Dispersion"
+			}
+		},
+		focusCenter: {
+			default: .8,
+			description: "Reduces the spread in a circular zone at the centre; 0 keeps it full to the centre",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Focus Center",
+				group: "Focus"
+			}
+		},
+		focusEdges: {
+			default: 1,
+			description: "Reduces the spread toward the edges; 1 restores the original image there",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Focus Edges",
+				group: "Focus"
+			}
+		},
+		lensBulge: {
+			default: 0,
+			description: "Radial lens warp; positive bulges out like a fisheye, negative pinches in like a pincushion",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Bulge",
+				group: "Lens"
+			}
+		},
+		lensCircle: {
+			default: 0,
+			description: "Squeezes pixels outside the inscribed circle inward so the outline becomes a circle",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Circle",
+				group: "Lens"
+			}
+		},
+		swirl: {
+			default: .35,
+			description: "Rotates the color layers around the centre by an angle growing along the spread; 0 is off",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Swirl",
+				group: "Lens"
+			}
+		},
+		noise: {
+			default: 0,
+			description: "Scatters the spread direction with noise; 0 is off",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Noise",
+				group: "Noise"
+			}
+		},
+		noiseFrequency: {
+			default: .25,
+			description: "Frequency of the direction noise; higher is finer (no effect with noise at 0)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Frequency",
+				group: "Noise"
+			}
+		},
+		noiseOffset: {
+			default: 0,
+			description: "Offsets the noise pattern for a different seed (no effect with noise at 0)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Seed",
+				group: "Noise"
+			}
+		},
+		grainMixer: {
+			default: 0,
+			description: "Scatters the spread with grain noise, breaking up the edges of the color layers",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Grain Mixer",
+				group: "Grain"
+			}
+		},
+		grainOverlay: {
+			default: 0,
+			description: "Post-processing black/white grain overlay",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Grain Overlay",
+				group: "Grain"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { uniforms, childNode, ctx, convertToTexture } = params;
+		if (!childNode) return ZERO;
+		const texKey = convertToTexture(childNode).key;
+		const PI = Math.PI;
+		return new Expr((ec) => {
+			const U = (name) => uniforms[name]._emit(ec);
+			const L = (n) => formatFloat(n);
+			const p = ec.freshLocal("lens");
+			const stmts = [];
+			let noiseIdx = 0;
+			const emitValueNoise = (lines, inputExpr, outName) => {
+				const n = `${p}_vn${noiseIdx++}`;
+				lines.push(`let ${n}_st = ${inputExpr};`);
+				lines.push(`let ${n}_fi = floor(${n}_st);`);
+				lines.push(`let ${n}_ff = fract(${n}_st);`);
+				for (const [k, off] of [
+					["a", "vec2f(0.0, 0.0)"],
+					["b", "vec2f(1.0, 0.0)"],
+					["c", "vec2f(0.0, 1.0)"],
+					["d", "vec2f(1.0, 1.0)"]
+				]) {
+					lines.push(`var ${n}_q${k} = fract((${n}_fi + ${off}) * vec2f(0.3183099, 0.3678794)) + vec2f(0.1);`);
+					lines.push(`${n}_q${k} = ${n}_q${k} + vec2f(dot(${n}_q${k}, ${n}_q${k} + vec2f(19.19)));`);
+					lines.push(`let ${n}_h${k} = fract(${n}_q${k}.x * ${n}_q${k}.y);`);
+				}
+				lines.push(`let ${n}_u = ${n}_ff * ${n}_ff * (vec2f(3.0) - 2.0 * ${n}_ff);`);
+				lines.push(`let ${outName} = mix(mix(${n}_ha, ${n}_hb, ${n}_u.x), mix(${n}_hc, ${n}_hd, ${n}_u.x), ${n}_u.y);`);
+			};
+			stmts.push(`let ${p}_uv = ${ctx.uv._emit(ec)};`);
+			stmts.push(`let ${p}_aspect = ${ctx.aspect._emit(ec)};`);
+			stmts.push(`let ${p}_invAspect = 1.0 / ${p}_aspect;`);
+			stmts.push(`let ${p}_inradius = 0.5 * min(${p}_aspect, 1.0);`);
+			stmts.push(`let ${p}_outradius = 0.5 * length(vec2f(${p}_aspect, 1.0));`);
+			stmts.push(`let ${p}_spread = ${U("spread")};`);
+			stmts.push(`let ${p}_reach = 0.7 * pow(${p}_spread, 1.3 + 2.7 * ${p}_spread);`);
+			stmts.push(`let ${p}_centerU = ${U("center")};`);
+			stmts.push(`let ${p}_c = vec2f(${p}_centerU.x, 1.0 - ${p}_centerU.y);`);
+			stmts.push(`let ${p}_fromCenter = vec2f((${p}_uv.x - ${p}_c.x) * ${p}_aspect, ${p}_uv.y - ${p}_c.y);`);
+			stmts.push(`let ${p}_radius = length(${p}_fromCenter);`);
+			stmts.push(`let ${p}_lensBulge = ${U("lensBulge")};`);
+			stmts.push(`let ${p}_lensCircle = ${U("lensCircle")};`);
+			stmts.push(`var ${p}_bulgeFade = 1.0;`);
+			stmts.push(`var ${p}_warped = ${p}_fromCenter;`);
+			stmts.push(`let ${p}_rSafe = max(${p}_radius, 1e-5);`);
+			stmts.push(`if (${p}_lensBulge != 0.0) {`);
+			stmts.push(`  let ${p}_rn = ${p}_rSafe / ${p}_inradius;`);
+			stmts.push(`  let ${p}_bulgeAmt = abs(${p}_lensBulge) * select(1.2, 1.4, ${p}_lensBulge > 0.0);`);
+			stmts.push(`  ${p}_bulgeFade = select(1.0, 1.0 - smoothstep(1.45, 1.53, ${p}_rn * ${p}_bulgeAmt), ${p}_lensBulge > 0.0);`);
+			stmts.push(`  let ${p}_mapPos = tan(min(${p}_rn * ${p}_bulgeAmt, 1.53)) / tan(${p}_bulgeAmt);`);
+			stmts.push(`  let ${p}_mapNeg = atan(${p}_rn * tan(${p}_bulgeAmt)) / ${p}_bulgeAmt;`);
+			stmts.push(`  let ${p}_bulgeScale = select(${p}_mapNeg, ${p}_mapPos, ${p}_lensBulge > 0.0) / ${p}_rn;`);
+			stmts.push(`  ${p}_warped = ${p}_warped * ${p}_bulgeScale;`);
+			stmts.push(`}`);
+			stmts.push(`if (${p}_lensCircle > 0.0) {`);
+			stmts.push(`  let ${p}_wr = length(${p}_warped);`);
+			stmts.push(`  let ${p}_dir = ${p}_warped / max(${p}_wr, 1e-5);`);
+			stmts.push(`  let ${p}_halfBox = vec2f(${p}_aspect, 1.0) * 0.5;`);
+			stmts.push(`  let ${p}_boxOff = vec2f((${p}_c.x - 0.5) * ${p}_aspect, ${p}_c.y - 0.5);`);
+			stmts.push(`  let ${p}_rBox = min((${p}_halfBox.x - sign(${p}_dir.x) * ${p}_boxOff.x) / max(abs(${p}_dir.x), 1e-4), (${p}_halfBox.y - sign(${p}_dir.y) * ${p}_boxOff.y) / max(abs(${p}_dir.y), 1e-4));`);
+			stmts.push(`  let ${p}_band = ${p}_inradius * mix(0.03, 0.2, 0.5 * (${p}_lensBulge + 1.0));`);
+			stmts.push(`  let ${p}_over = smoothstep(0.0, 1.0, (${p}_wr - (${p}_inradius - ${p}_band)) / ${p}_band);`);
+			stmts.push(`  let ${p}_g = ${p}_wr + (${p}_rBox - ${p}_inradius) * pow(${p}_over, 14.0);`);
+			stmts.push(`  ${p}_warped = ${p}_dir * mix(${p}_wr, ${p}_g, ${p}_lensCircle);`);
+			stmts.push(`}`);
+			stmts.push(`let ${p}_baseUV = vec2f(${p}_warped.x * ${p}_invAspect, ${p}_warped.y) + ${p}_c;`);
+			stmts.push(`let ${p}_baseDeriv = fwidth(${p}_baseUV);`);
+			stmts.push(`let ${p}_edgeAA = clamp(2.0 * max(${p}_baseDeriv.x, ${p}_baseDeriv.y), 0.001, 0.02);`);
+			stmts.push(`let ${p}_frameInvAA = 1.0 / clamp(${p}_baseDeriv, vec2f(1e-5), vec2f(0.02));`);
+			stmts.push(`let ${p}_grainUV = (${p}_uv - vec2f(0.5)) * (0.8 / vec2f(length(dpdx(${p}_uv)), length(dpdy(${p}_uv)))) + vec2f(0.5);`);
+			stmts.push(`let ${p}_angleRad = radians(${U("angle")});`);
+			stmts.push(`let ${p}_uniformDir = vec2f(cos(${p}_angleRad), sin(${p}_angleRad));`);
+			stmts.push(`let ${p}_invInradius = 1.0 / ${p}_inradius;`);
+			stmts.push(`let ${p}_maxLen = (${p}_outradius + ${p}_reach) * ${p}_invInradius;`);
+			stmts.push(`let ${p}_radialLen = ${p}_radius * ${p}_invInradius;`);
+			stmts.push(`let ${p}_radialDir = ${p}_fromCenter * ${p}_invInradius * min(1.0, ${p}_maxLen / max(${p}_radialLen, 1e-6));`);
+			stmts.push(`let ${p}_bandProximity = smoothstep(${p}_inradius * 0.8, ${p}_inradius, ${p}_radius);`);
+			stmts.push(`let ${p}_circleMaxing = ${p}_bandProximity * ${p}_lensCircle * ${p}_lensCircle * ${p}_lensCircle;`);
+			stmts.push(`let ${p}_spreadDir = mix(mix(${p}_uniformDir, ${p}_radialDir, ${U("perspective")}), ${p}_radialDir, ${p}_circleMaxing);`);
+			stmts.push(`let ${p}_warpedAbs = abs(${p}_baseUV - vec2f(0.5));`);
+			stmts.push(`let ${p}_focusCenter = ${U("focusCenter")};`);
+			stmts.push(`let ${p}_inner = mix(1.0, smoothstep(0.0, mix(${p}_inradius, ${p}_outradius, ${p}_focusCenter), ${p}_radius), ${p}_focusCenter);`);
+			stmts.push(`let ${p}_boxDist = max(${p}_warpedAbs.x, ${p}_warpedAbs.y) * 2.0;`);
+			stmts.push(`let ${p}_outer = mix(1.0, 1.0 - min(${p}_boxDist, 1.0), ${U("focusEdges")});`);
+			stmts.push(`var ${p}_strength = ${p}_inner * ${p}_outer * mix(1.0, mix(0.15, 0.03, max(-${p}_lensBulge, 0.0)), ${p}_circleMaxing);`);
+			stmts.push(`let ${p}_outside = max(${p}_warpedAbs - vec2f(0.5), vec2f(0.0));`);
+			stmts.push(`let ${p}_margin = max(${p}_reach * length(${p}_spreadDir) * (1.0 - ${p}_lensCircle), ${p}_edgeAA);`);
+			stmts.push(`${p}_strength = ${p}_strength * (1.0 - smoothstep(0.0, ${p}_margin, length(${p}_outside)));`);
+			stmts.push(`var ${p}_axis = ${p}_spreadDir * (${p}_reach * ${p}_strength);`);
+			stmts.push(`let ${p}_noise = ${U("noise")};`);
+			stmts.push(`if (${p}_noise > 0.0) {`);
+			{
+				const lines = [];
+				emitValueNoise(lines, `${p}_fromCenter * (${U("noiseFrequency")} * 18.0) + vec2f(${U("noiseOffset")} * 30.0)`, `${p}_turnNoise`);
+				for (const l of lines) stmts.push(`  ${l}`);
+			}
+			stmts.push(`  let ${p}_turn = (${p}_turnNoise - 0.5) * 2.0 * ${p}_noise;`);
+			stmts.push(`  let ${p}_tc = cos(${p}_turn);`);
+			stmts.push(`  let ${p}_ts = sin(${p}_turn);`);
+			stmts.push(`  ${p}_axis = vec2f(${p}_tc * ${p}_axis.x + ${p}_ts * ${p}_axis.y, -${p}_ts * ${p}_axis.x + ${p}_tc * ${p}_axis.y);`);
+			stmts.push(`}`);
+			stmts.push(`${p}_axis = vec2f(${p}_axis.x * ${p}_invAspect, ${p}_axis.y);`);
+			stmts.push(`let ${p}_grainMixer = ${U("grainMixer")};`);
+			stmts.push(`if (${p}_grainMixer > 0.0) {`);
+			{
+				const lines = [];
+				emitValueNoise(lines, `${p}_grainUV`, `${p}_grainSeed`);
+				for (const l of lines) stmts.push(`  ${l}`);
+			}
+			stmts.push(`  let ${p}_jit = fract(${p}_grainSeed * vec2f(157.31, 113.57)) * 2.0 - vec2f(1.0);`);
+			stmts.push(`  ${p}_axis = ${p}_axis + ${p}_jit * (0.3 * ${p}_grainMixer * length(${p}_axis));`);
+			stmts.push(`}`);
+			stmts.push(`let ${p}_countF = clamp(floor(${U("count")}), 2.0, ${L(MAX_TAPS)});`);
+			stmts.push(`let ${p}_hueBase = ${U("dispersionColor")} + 0.5;`);
+			stmts.push(`let ${p}_bias = ${U("bias")};`);
+			stmts.push(`let ${p}_biasPower = 1.0 + 2.0 * abs(${p}_bias);`);
+			stmts.push(`let ${p}_biasNeg = ${p}_bias < 0.0;`);
+			stmts.push(`let ${p}_dispShift = ${U("dispersionShift")};`);
+			stmts.push(`let ${p}_icMask = 1.0 - smoothstep(0.5 * ${p}_inradius, 1.1 * ${p}_inradius, ${p}_radius);`);
+			stmts.push(`let ${p}_dispAmt = ${U("dispersion")} * mix(clamp(1.0 + ${p}_dispShift, 0.0, 1.0), clamp(1.0 - ${p}_dispShift, 0.0, 1.0), ${p}_icMask);`);
+			stmts.push(`let ${p}_dispPower = pow(${p}_dispAmt, 0.8);`);
+			stmts.push(`let ${p}_warpedRadius = length(${p}_warped);`);
+			stmts.push(`let ${p}_swirlAngle = ${U("swirl")} * ${L(.4 * PI)} * ${p}_strength * ${p}_spread * min(1.0, ${p}_inradius / max(${p}_warpedRadius, 1e-4));`);
+			stmts.push(`let ${p}_texel = max((${p}_baseDeriv.x + ${p}_baseDeriv.y) * 0.5, 1e-6);`);
+			stmts.push(`let ${p}_fanPx = (2.0 * length(${p}_axis) + abs(${p}_swirlAngle) * ${p}_warpedRadius) / ${p}_texel;`);
+			stmts.push(`let ${p}_tapsF = clamp(ceil(${p}_fanPx * ${p}_biasPower) + 1.0, 2.0, ${p}_countF);`);
+			stmts.push(`let ${p}_invCount = 1.0 / ${p}_tapsF;`);
+			stmts.push(`let ${p}_invSpan = 1.0 / max(${p}_tapsF - 1.0, 1.0);`);
+			stmts.push(`var ${p}_colorSum = vec3f(0.0);`);
+			stmts.push(`var ${p}_weightSum = vec3f(0.0);`);
+			stmts.push(`var ${p}_coverSum = 0.0;`);
+			const body = [];
+			body.push(`let ${p}_layer = f32(${p}_i);`);
+			body.push(`let ${p}_hue = ${p}_hueBase + ${p}_layer * ${p}_invCount;`);
+			body.push(`let ${p}_t0 = ${p}_layer * ${p}_invSpan;`);
+			body.push(`let ${p}_curved = pow(select(${p}_t0, 1.0 - ${p}_t0, ${p}_biasNeg), ${p}_biasPower);`);
+			body.push(`let ${p}_spreadT = select(${p}_curved, 1.0 - ${p}_curved, ${p}_biasNeg);`);
+			body.push(`let ${p}_fanPos = 1.0 - 2.0 * ${p}_spreadT;`);
+			body.push(`let ${p}_tap0 = ${p}_baseUV + ${p}_axis * ${p}_fanPos - ${p}_c;`);
+			body.push(`let ${p}_sa = ${p}_swirlAngle * ${p}_fanPos;`);
+			body.push(`let ${p}_sc = cos(${p}_sa);`);
+			body.push(`let ${p}_ss = sin(${p}_sa);`);
+			body.push(`let ${p}_tx = ${p}_tap0.x * ${p}_aspect;`);
+			body.push(`let ${p}_sampleUV = vec2f((${p}_sc * ${p}_tx - ${p}_ss * ${p}_tap0.y) * ${p}_invAspect, ${p}_ss * ${p}_tx + ${p}_sc * ${p}_tap0.y) + ${p}_c;`);
+			body.push(`let ${p}_lo = clamp(${p}_sampleUV * ${p}_frameInvAA + vec2f(0.5), vec2f(0.0), vec2f(1.0));`);
+			body.push(`let ${p}_hi = clamp((vec2f(1.0) - ${p}_sampleUV) * ${p}_frameInvAA + vec2f(0.5), vec2f(0.0), vec2f(1.0));`);
+			body.push(`let ${p}_frame = ${p}_lo.x * ${p}_hi.x * ${p}_lo.y * ${p}_hi.y;`);
+			body.push(`let ${p}_tapC = textureSampleLevel(tex.$.${texKey}, samp.$.linearClamp, ${p}_sampleUV, 0.0);`);
+			body.push(`let ${p}_cover = ${p}_tapC.a * ${p}_frame;`);
+			body.push(`let ${p}_overWhite = vec3f(1.0 - ${p}_cover) + ${p}_tapC.rgb * ${p}_frame;`);
+			body.push(`let ${p}_hraw = ${p}_hue * 6.0 + vec3f(0.0, 4.0, 2.0);`);
+			body.push(`let ${p}_hmod = ${p}_hraw - 6.0 * floor(${p}_hraw / 6.0);`);
+			body.push(`let ${p}_hclamped = clamp(abs(${p}_hmod - vec3f(3.0)) - vec3f(1.0), vec3f(0.0), vec3f(1.0));`);
+			body.push(`let ${p}_hrgb = ${p}_hclamped * ${p}_hclamped * (vec3f(3.0) - 2.0 * ${p}_hclamped);`);
+			body.push(`let ${p}_weight = vec3f(1.0) - ${p}_dispPower * ${p}_hrgb;`);
+			body.push(`${p}_colorSum = ${p}_colorSum + ${p}_overWhite * ${p}_weight;`);
+			body.push(`${p}_weightSum = ${p}_weightSum + ${p}_weight;`);
+			body.push(`${p}_coverSum = ${p}_coverSum + ${p}_cover;`);
+			stmts.push(`for (var ${p}_i = 0u; ${p}_i < u32(${p}_tapsF); ${p}_i++) {`);
+			for (const b of body) stmts.push(`  ${b}`);
+			stmts.push(`}`);
+			stmts.push(`let ${p}_color = ${p}_colorSum / max(${p}_weightSum, vec3f(1e-4));`);
+			stmts.push(`let ${p}_coverAvg = ${p}_coverSum * ${p}_invCount;`);
+			stmts.push(`let ${p}_ground = min(${p}_color.r, min(${p}_color.g, ${p}_color.b));`);
+			stmts.push(`let ${p}_alpha = max(${p}_coverAvg, 1.0 - ${p}_ground);`);
+			stmts.push(`let ${p}_premul = max(${p}_color - vec3f(1.0 - ${p}_alpha), vec3f(0.0));`);
+			stmts.push(`var ${p}_out = vec4f(${p}_premul, ${p}_alpha) * ${p}_bulgeFade;`);
+			stmts.push(`let ${p}_grainOverlay = ${U("grainOverlay")};`);
+			stmts.push(`if (${p}_grainOverlay > 0.0) {`);
+			{
+				const lines = [];
+				const c1 = L(Math.cos(1)), s1 = L(Math.sin(1));
+				const c2 = L(Math.cos(2)), s2 = L(Math.sin(2));
+				lines.push(`let ${p}_gr1 = vec2f(${c1} * ${p}_grainUV.x - ${s1} * ${p}_grainUV.y, ${s1} * ${p}_grainUV.x + ${c1} * ${p}_grainUV.y) + vec2f(3.0);`);
+				lines.push(`let ${p}_gr2 = vec2f(${c2} * ${p}_grainUV.x - ${s2} * ${p}_grainUV.y, ${s2} * ${p}_grainUV.x + ${c2} * ${p}_grainUV.y) + vec2f(-1.0);`);
+				emitValueNoise(lines, `${p}_gr1`, `${p}_gn1`);
+				emitValueNoise(lines, `${p}_gr2`, `${p}_gn2`);
+				lines.push(`let ${p}_grain = pow(mix(${p}_gn1, ${p}_gn2, 0.5), 1.3);`);
+				lines.push(`let ${p}_grainV = ${p}_grain * 2.0 - 1.0;`);
+				lines.push(`let ${p}_grainStrength = pow(${p}_grainOverlay * abs(${p}_grainV), 0.8) * ${p}_out.a;`);
+				lines.push(`${p}_out = vec4f(mix(${p}_out.rgb, vec3f(step(0.0, ${p}_grainV)) * ${p}_out.a, 0.35 * ${p}_grainStrength), ${p}_out.a);`);
+				for (const l of lines) stmts.push(`  ${l}`);
+			}
+			stmts.push(`}`);
+			for (const s of stmts) ec.statement(s);
+			return call(unpremultiplyAlpha, "unpremultiplyAlpha", [expr(`${p}_out`)])._emit(ec);
+		});
+	}
+};
+var LensDistortion_default = componentDefinition;
+export { componentDefinition as n, LensDistortion_default as t };

package/dist/core/{LensFlare-ChQK_hJN.js → LensFlare-DO5lm--6.js}

@@ -1,5 +1,5 @@
-import { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _t as clamp, an as f32, bt as dot, et as src_default, gt as atan2, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
-import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { At as mix, Ct as exp, Dt as length, Mt as pow, Ot as max, Rt as sin, St as dot, Ut as data_exports, _t as atan2, bt as cos, et as src_default, ht as abs, in as vec3f, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
 import { c as transformPosition } from "./transformations-CsPUHppB.js";
 var TAU = 6.2831853;
 var lensFlareSpectral = src_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {

package/dist/core/{LightEdge-Rg-zMpGb.js → LightEdge-CxWsQwpZ.js}

@@ -1,9 +1,9 @@
-import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Ot as mix, U as mixColorsVariants, Ut as arrayOf, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, et as src_default, gt as atan2, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
-import { h as colorStopsPropConfig, m as MAX_COLOR_STOPS, t as animatedTime } from "./porters-DBK1Aipq.js";
-import { c as hash22, p as noise_exports, y as value12 } from "./noise-wTSHXgFz.js";
-import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
-import { d as VOLUMETRIC_FIELD_EXTRA_FIELDS$1, f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
-import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { At as mix, Et as fract, Gt as arrayOf, H as mixColorsLinear, Mt as pow, Ot as max, Qt as struct, Rt as sin, Tt as floor, U as mixColorsVariants, Ut as data_exports, _ as floatE, _t as atan2, bt as cos, cn as i32, et as src_default, ht as abs, in as vec3f, kt as min, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { h as colorStopsPropConfig, m as MAX_COLOR_STOPS, t as animatedTime } from "./porters-DogLzpKT.js";
+import { c as hash22, p as noise_exports, y as value12 } from "./noise-Cq0KUOSC.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { d as VOLUMETRIC_FIELD_EXTRA_FIELDS$1, f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;

package/dist/core/{LightLeak-D1CxVo9A.js → LightLeak-tGJW6l2_.js}

@@ -1,6 +1,6 @@
-import { $t as vec2f, Et as max, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, xt as exp } from "./edges-BXNBKxSN.js";
-import { t as animatedTime } from "./porters-DBK1Aipq.js";
-import { p as noise_exports, s as hash12, y as value12 } from "./noise-wTSHXgFz.js";
+import { At as mix, Ct as exp, Dt as length, Ot as max, St as dot, Ut as data_exports, d as ZERO, et as src_default, in as vec3f, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { p as noise_exports, s as hash12, y as value12 } from "./noise-Cq0KUOSC.js";
 import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 const lightLeakRamp = src_default.fn([
 	f32,

package/dist/core/{LinearBlur-DJBkHfs8.js → LinearBlur-OmZcUden.js}

@@ -1,4 +1,4 @@
-import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, _ as floatE, an as f32, d as ZERO, et as src_default, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { N as unpremultiplyAlpha, Rt as sin, Ut as data_exports, _ as floatE, bt as cos, d as ZERO, et as src_default, nt as std_exports, p as call, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
 import { r as transformAngle } from "./transformations-CsPUHppB.js";
 var rawWeights = Array.from({ length: 32 }, (_, i) => {
 	const t = (i / 31 - .5) * 2;

package/dist/core/{LinearGradient-DCRYBS4Q.js → LinearGradient-DDqFujWC.js}

@@ -1,5 +1,5 @@
-import { $t as vec2f, Et as max, F as colorMixing_exports, It as sin, Tt as length, Vt as data_exports, _t as clamp, an as f32, bt as dot, et as src_default, kt as normalize, mt as abs, nt as std_exports, p as call, pt as select, qt as mod, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
-import { S as mixColorStopsRuntime, h as colorStopsPropConfig, x as gradientStopsInSpace$1 } from "./porters-DBK1Aipq.js";
+import { Dt as length, Et as fract, F as colorMixing_exports, Ot as max, Rt as sin, St as dot, Ut as data_exports, Yt as mod, bt as cos, et as src_default, ht as abs, jt as normalize, mt as select, nt as std_exports, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp } from "./edges-BZUKQxSE.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, x as gradientStopsInSpace$1 } from "./porters-DogLzpKT.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, r as transformAngle, s as transformEdges, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 const gradientStopsInSpace = gradientStopsInSpace$1;
 var DEG_TO_RAD = .017453292519943295;

package/dist/core/{LinearWipe-Cxfs1tIO.js → LinearWipe-BzthBFNb.js}

@@ -1,4 +1,4 @@
-import { $t as vec2f, Et as max, It as sin, Lt as smoothstep, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, mt as abs, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { Ot as max, Rt as sin, St as dot, Ut as data_exports, bt as cos, d as ZERO, et as src_default, ht as abs, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, zt as smoothstep } from "./edges-BZUKQxSE.js";
 import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 const linearWipeMask = src_default.fn([

package/dist/core/{LiquidMetal-oscNnbsr.js → LiquidMetal-DpRAJ5Ne.js}

@@ -1,9 +1,9 @@
-import { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Mt as reflect, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, _t as clamp, an as f32, et as src_default, in as vec4f, kt as normalize, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
-import { t as animatedTime } from "./porters-DBK1Aipq.js";
-import { h as perlin12d, p as noise_exports } from "./noise-wTSHXgFz.js";
-import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
-import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
-import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { At as mix, Dt as length, Mt as pow, Ot as max, Pt as reflect, Rt as sin, Ut as data_exports, _ as floatE, bt as cos, et as src_default, in as vec3f, jt as normalize, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { h as perlin12d, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.js";
 import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;

package/dist/core/{Liquify-CJwl6Wef.js → Liquify-BVzmuY6D.js}

@@ -1,5 +1,5 @@
-import { $t as vec2f, Gt as textureStorage2d, N as unpremultiplyAlpha, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, c as sampleRemappedExpr, d as ZERO, et as src_default, g as expr, in as vec4f, n as composeEdgeRemapExpr, nt as std_exports, p as call, pt as select, sn as u32, tn as vec2u, xt as exp } from "./edges-BXNBKxSN.js";
-import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { Ct as exp, Gt as arrayOf, N as unpremultiplyAlpha, Qt as struct, Ut as data_exports, c as sampleRemappedExpr, d as ZERO, et as src_default, g as expr, ln as u32, mt as select, n as composeEdgeRemapExpr, nt as std_exports, on as vec4f, ot as textureStore, p as call, qt as textureStorage2d, rn as vec2u, sn as f32, tn as vec2f, yt as clamp } from "./edges-BZUKQxSE.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BoeIXi0l.js";
 import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var GRID_SIZE = 64;
 var CELL_COUNT = GRID_SIZE * GRID_SIZE;