shaders 2.2.23 → 2.2.25

package/dist/core/LinearBlur-LmhnQoA4.js

@@ -0,0 +1,62 @@
+import { n as transformAngle } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "LinearBlur",
+	category: "Blurs",
+	description: "Directional motion blur in a specific angle",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 30,
+			description: "Intensity of the linear blur effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Direction of the linear blur (in degrees)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, viewportSize: viewportSize$1, sin: sin$1, cos: cos$1, radians, Fn, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const angleRad = radians(uniforms.angle.uniform);
+		const blurDirection = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		return Fn(() => {
+			const uv = screenUV$1;
+			const texel = vec2$1(1).div(viewportSize$1);
+			const blurVector = blurDirection.mul(uniforms.intensity.uniform).mul(texel).mul(2);
+			const total = vec4$1(0).toVar();
+			const totalWeight = float$1(0).toVar();
+			for (let i = 0; i < 32; i++) {
+				const t = float$1(i).div(float$1(31)).sub(.5).mul(2);
+				const weight = float$1(1).div(float$1(2.506628)).mul(float$1(-.5).mul(t).mul(t).div(float$1(.64)).exp());
+				const coord = uv.add(blurVector.mul(t.mul(.5)));
+				const sample = childTexture.sample(coord).mul(weight);
+				total.assign(total.add(sample));
+				totalWeight.assign(totalWeight.add(weight));
+			}
+			return total.div(totalWeight);
+		})();
+	}
+};
+var LinearBlur_default = componentDefinition;
+export { componentDefinition as n, LinearBlur_default as t };

package/dist/core/LinearGradient-xbloQjzt.js

@@ -0,0 +1,133 @@
+import { a as transformEdges, i as transformColorSpace, n as transformAngle, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
+import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "LinearGradient",
+	category: "Base Layers",
+	description: "Create smooth linear color gradients",
+	acceptsUVContext: true,
+	props: {
+		colorA: {
+			default: "#1aff00",
+			transform: transformColor,
+			description: "The starting color of the gradient",
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#0000ff",
+			transform: transformColor,
+			description: "The ending color of the gradient",
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		start: {
+			default: {
+				x: 0,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The starting point of the gradient",
+			ui: {
+				type: "position",
+				label: "Start"
+			}
+		},
+		end: {
+			default: {
+				x: 1,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The ending point of the gradient",
+			ui: {
+				type: "position",
+				label: "End"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Additional rotation angle of the gradient (in degrees)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		edges: {
+			default: "stretch",
+			transform: transformEdges,
+			description: "How to handle areas beyond the gradient endpoints",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, uvContext }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, cos: cos$1, sin: sin$1, dot: dot$1, radians, screenUV: screenUV$1, length, normalize, abs: abs$1, mod, fract } = TSL;
+		const uv = uvContext ?? screenUV$1;
+		const startPos = vec2$1(uniforms.start.uniform[0], uniforms.start.uniform[1].oneMinus());
+		const endPos = vec2$1(uniforms.end.uniform[0], uniforms.end.uniform[1].oneMinus());
+		const gradientVector = endPos.sub(startPos);
+		const gradientLength = length(gradientVector);
+		const gradientDir = normalize(gradientVector);
+		const angleRad = radians(uniforms.angle.uniform).negate();
+		const cosAngle = cos$1(angleRad);
+		const sinAngle = sin$1(angleRad);
+		const midpoint = startPos.add(endPos).mul(.5);
+		const centeredUV = uv.sub(midpoint);
+		const t = dot$1(vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
+		const edgeMode = uniforms.edges.uniform;
+		const stretchT = t.clamp(float$1(0), float$1(1));
+		const inBoundsX = t.greaterThanEqual(float$1(0)).select(float$1(1), float$1(0));
+		const inBoundsY = t.lessThanEqual(float$1(1)).select(float$1(1), float$1(0));
+		const inBounds = inBoundsX.mul(inBoundsY);
+		const mirrorT = mod(abs$1(t), float$1(2));
+		const finalMirrorT = mirrorT.greaterThan(float$1(1)).select(float$1(2).sub(mirrorT), mirrorT);
+		const wrapT = fract(t);
+		const isMode1OrHigher = edgeMode.greaterThanEqual(float$1(.5));
+		const isMode2OrHigher = edgeMode.greaterThanEqual(float$1(1.5));
+		const finalT = edgeMode.greaterThanEqual(float$1(2.5)).select(wrapT, isMode2OrHigher.select(finalMirrorT, isMode1OrHigher.select(t, stretchT)));
+		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float$1(0), float$1(1)), uniforms.colorSpace.uniform);
+		const finalAlpha = isMode1OrHigher.and(edgeMode.lessThan(float$1(1.5))).select(mixedColor.w.mul(inBounds), mixedColor.w);
+		return vec4$1(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
+	}
+};
+var LinearGradient_default = componentDefinition;
+export { componentDefinition as n, LinearGradient_default as t };

package/dist/core/Liquify-DMe1V5-O.js

@@ -0,0 +1,175 @@
+import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
+import { a as transformEdges } from "./transformations-DxfQXZWi.js";
+import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
+import * as TSL from "three/tsl";
+var GRID_SIZE = 32;
+var displacementStateCache = /* @__PURE__ */ new WeakMap();
+var getOrCreateDisplacementState = (uniforms) => {
+	let state = displacementStateCache.get(uniforms);
+	if (!state) {
+		const data = new Float32Array(GRID_SIZE * GRID_SIZE * 2);
+		const texture = new DataTexture(data, GRID_SIZE, GRID_SIZE, RGFormat, FloatType);
+		texture.magFilter = LinearFilter;
+		texture.minFilter = LinearFilter;
+		texture.needsUpdate = true;
+		state = {
+			texture,
+			data,
+			tslNode: TSL.texture(texture),
+			initialized: false
+		};
+		displacementStateCache.set(uniforms, state);
+	}
+	return state;
+};
+const componentDefinition = {
+	name: "Liquify",
+	category: "Interactive",
+	description: "Liquid-like interactive deformation effect",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 1,
+			description: "Strength of the distortion effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Intensity"
+			}
+		},
+		swirl: {
+			default: 0,
+			description: "Amount of swirl motion (0-1)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Swirl"
+			}
+		},
+		decay: {
+			default: 3,
+			description: "Rate of distortion decay (higher = faster)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Decay"
+			}
+		},
+		radius: {
+			default: 1,
+			description: "Radius of the distortion effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Radius"
+			}
+		},
+		edges: {
+			default: "stretch",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms }) => {
+		const { vec2: vec2$1, float: float$1 } = TSL;
+		const displacement = getOrCreateDisplacementState(uniforms).tslNode.sample(uv).xy;
+		const maxDisplacement = float$1(.2);
+		const clampedDisplacement = displacement.clamp(vec2$1(maxDisplacement.negate(), maxDisplacement.negate()), vec2$1(maxDisplacement, maxDisplacement));
+		return uv.sub(clampedDisplacement);
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, uniform: uniform$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
+		const { texture: displacementTexture, data: displacementData, tslNode: displacementField } = getOrCreateDisplacementState(uniforms);
+		const mouseVelX = uniform$1(0);
+		const mouseVelY = uniform$1(0);
+		let prevX = .5;
+		let prevY = .5;
+		let lastTime = Date.now();
+		onBeforeRender(({ pointer }) => {
+			const currentTime = Date.now();
+			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
+			lastTime = currentTime;
+			const velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
+			const velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
+			mouseVelX.value = mouseVelX.value * .85 + velX * .15;
+			mouseVelY.value = mouseVelY.value * .85 + velY * .15;
+			const decay = uniforms.decay.uniform.value;
+			const intensity = uniforms.intensity.uniform.value;
+			const radius = uniforms.radius.uniform.value * .05;
+			const swirl = uniforms.swirl.uniform.value;
+			for (let i = 0; i < GRID_SIZE; i++) for (let j = 0; j < GRID_SIZE; j++) {
+				const idx = (i * GRID_SIZE + j) * 2;
+				displacementData[idx] *= 1 - decay * dt;
+				displacementData[idx + 1] *= 1 - decay * dt;
+				const cellX = (j + .5) / GRID_SIZE;
+				const cellY = (i + .5) / GRID_SIZE;
+				const dx = cellX - pointer.x;
+				const dy = cellY - pointer.y;
+				const dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist < radius * 2 && Math.abs(velX) + Math.abs(velY) > .01) {
+					const influence = Math.exp(-dist * dist / (radius * radius));
+					displacementData[idx] += mouseVelX.value * influence * intensity * dt * .5;
+					displacementData[idx + 1] += mouseVelY.value * influence * intensity * dt * .5;
+					if (swirl > 0) {
+						const angle = Math.atan2(dy, dx) + Math.PI * .5;
+						displacementData[idx] += Math.cos(angle) * swirl * influence * dt * 2;
+						displacementData[idx + 1] += Math.sin(angle) * swirl * influence * dt * 2;
+					}
+				}
+				displacementData[idx] = Math.max(-1, Math.min(1, displacementData[idx]));
+				displacementData[idx + 1] = Math.max(-1, Math.min(1, displacementData[idx + 1]));
+			}
+			displacementTexture.needsUpdate = true;
+			prevX = pointer.x;
+			prevY = pointer.y;
+		});
+		onCleanup(() => {
+			displacementTexture.dispose();
+			displacementStateCache.delete(uniforms);
+		});
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const displacement = displacementField.sample(screenUV$1).xy;
+		const maxDisplacement = float$1(.2);
+		const negMaxDisplacement = float$1(-.2);
+		const clampedDisplacement = displacement.clamp(vec2$1(negMaxDisplacement, negMaxDisplacement), vec2$1(maxDisplacement, maxDisplacement));
+		const distortedUV = screenUV$1.sub(clampedDisplacement);
+		return applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform);
+	}
+};
+var Liquify_default = componentDefinition;
+export { componentDefinition as n, Liquify_default as t };

package/dist/core/Pixelate-Cv8537Pj.js

@@ -0,0 +1,37 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Pixelate",
+	category: "Stylize",
+	description: "Pixelation effect with adjustable cell size",
+	requiresRTT: true,
+	requiresChild: true,
+	props: { scale: {
+		default: 50,
+		description: "Pixel size - higher values create larger, more visible pixels",
+		ui: {
+			type: "range",
+			min: 1,
+			max: 200,
+			step: 1,
+			label: "Scale"
+		}
+	} },
+	uvTransformNode: ({ uv, uniforms }) => {
+		const { floor } = TSL;
+		const pixelSize = uniforms.scale.uniform;
+		return floor(uv.mul(pixelSize)).div(pixelSize);
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec4: vec4$1, floor, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const pixelSize = uniforms.scale.uniform;
+		const pixelatedUV = floor(screenUV$1.mul(pixelSize)).div(pixelSize);
+		return childTexture.sample(pixelatedUV);
+	}
+};
+var Pixelate_default = componentDefinition;
+export { componentDefinition as n, Pixelate_default as t };

package/dist/core/PolarCoordinates-DDvDhBE-.js

@@ -0,0 +1,112 @@
+import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
+import { a as transformEdges, o as transformPosition } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "PolarCoordinates",
+	category: "Distortions",
+	description: "Convert rectangular coordinates to polar space",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point for polar coordinate conversion",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		wrap: {
+			default: 1,
+			description: "Controls how much of the angular range to use (1 = full 360°, 0.5 = 180°)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Wrap"
+			}
+		},
+		radius: {
+			default: 1,
+			description: "Controls how much of the radius range to use (affects the radial mapping)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Radius"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Blends between original UVs (0) and polar coordinates (1)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity"
+			}
+		},
+		edges: {
+			default: "transparent",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
+		const { vec2: vec2$1, length, atan: atan$1, PI, mix: mix$1 } = TSL;
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const aspectCorrectedUV = vec2$1(uv.x.mul(aspect), uv.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const delta = aspectCorrectedUV.sub(centerPos);
+		const normalizedAngle = atan$1(delta.y, delta.x).add(PI).div(PI.mul(2));
+		const r = length(delta);
+		return mix$1(uv, vec2$1(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, length, atan: atan$1, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, PI, mix: mix$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const aspectCorrectedUV = vec2$1(screenUV$1.x.mul(aspect), screenUV$1.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const delta = aspectCorrectedUV.sub(centerPos);
+		const normalizedAngle = atan$1(delta.y, delta.x).add(PI).div(PI.mul(2));
+		const r = length(delta);
+		const blendedUV = mix$1(screenUV$1, vec2$1(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
+		return applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform);
+	}
+};
+var PolarCoordinates_default = componentDefinition;
+export { componentDefinition as n, PolarCoordinates_default as t };

package/dist/core/Posterize-3m3xkWOz.js

@@ -0,0 +1,29 @@
+import * as TSL from "three/tsl";
+import { posterize } from "three/src/nodes/display/PosterizeNode";
+const componentDefinition = {
+	name: "Posterize",
+	category: "Adjustments",
+	description: "Reduce color depth to create a poster effect",
+	requiresChild: true,
+	props: { intensity: {
+		default: 5,
+		description: "The intensity of the posterization effect (lower is more posterized)",
+		ui: {
+			type: "range",
+			min: 2,
+			max: 20,
+			step: 1,
+			label: "Intensity"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode }) => {
+		const { vec4: vec4$1, int } = TSL;
+		if (!childNode) {
+			console.error("You must pass a child component into the Posterize shader.");
+			return vec4$1(0);
+		}
+		return posterize(childNode || vec4$1(0, 0, 0, 0), int(uniforms.intensity.uniform));
+	}
+};
+var Posterize_default = componentDefinition;
+export { componentDefinition as n, Posterize_default as t };

package/dist/core/ProgressiveBlur-EGkevObV.js

@@ -0,0 +1,121 @@
+import { n as transformAngle, o as transformPosition } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "ProgressiveBlur",
+	category: "Blurs",
+	description: "Blur that increases progressively in one direction",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 50,
+			description: "Maximum intensity of the blur effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Direction of the blur gradient (in degrees)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		center: {
+			default: {
+				x: 0,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point where blur begins",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		falloff: {
+			default: 1,
+			description: "Distance over which blur transitions to full strength",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Falloff"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, viewportSize: viewportSize$1, sin: sin$1, cos: cos$1, radians, max: max$1, smoothstep, Fn, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const angleRad = radians(uniforms.angle.uniform);
+		const direction = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		const centerPosition = vec2$1(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const centeredUV = screenUV$1.sub(centerPosition);
+		const directionalDist = max$1(float$1(0), centeredUV.dot(direction));
+		const falloff = max$1(float$1(.001), uniforms.falloff.uniform);
+		const blurAmount = smoothstep(float$1(0), falloff, directionalDist);
+		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
+		const blurRadius = blurAmount.mul(scaledIntensity);
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const horizontalTexture = convertToTexture$1(Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const total = vec4$1(0).toVar();
+			for (let x = -6; x <= 6; x++) {
+				const weight = float$1(weights[x + 6] / weightSum);
+				const offset = vec2$1(float$1(x), float$1(0)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv.add(offset);
+				const sample = childTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			return total;
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const total = vec4$1(0).toVar();
+			for (let y = -6; y <= 6; y++) {
+				const weight = float$1(weights[y + 6] / weightSum);
+				const offset = vec2$1(float$1(0), float$1(y)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv.add(offset);
+				const sample = horizontalTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			return total;
+		})();
+	}
+};
+var ProgressiveBlur_default = componentDefinition;
+export { componentDefinition as n, ProgressiveBlur_default as t };