shaders 2.2.24 → 2.2.25

package/dist/core/Blob-CxFDZovO.js

@@ -0,0 +1,218 @@
+import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
+import { i as transformColorSpace, 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: "Blob",
+	category: "Base Layers",
+	description: "Organic animated blob with 3D lighting and gradients",
+	acceptsUVContext: true,
+	props: {
+		colorA: {
+			default: "#ff6b35",
+			transform: transformColor,
+			description: "Primary color of the blob",
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#e91e63",
+			transform: transformColor,
+			description: "Secondary color of the blob",
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		size: {
+			default: .5,
+			description: "Size of the blob",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Size"
+			}
+		},
+		deformation: {
+			default: .5,
+			description: "How organic and blobby the shape is (0 = circle, 1 = very blobby)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Deformation"
+			}
+		},
+		softness: {
+			default: .5,
+			description: "Softness of the blob edges (combines edge width and transition curve)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness"
+			}
+		},
+		highlightIntensity: {
+			default: .5,
+			description: "Intensity of specular highlight effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Highlight Intensity"
+			}
+		},
+		highlightX: {
+			default: .3,
+			description: "Light direction X component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Highlight X"
+			}
+		},
+		highlightY: {
+			default: -.3,
+			description: "Light direction Y component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Highlight Y"
+			}
+		},
+		highlightZ: {
+			default: .4,
+			description: "Light direction Z component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Highlight Z"
+			}
+		},
+		highlightColor: {
+			default: "#ffe11a",
+			transform: transformColor,
+			description: "Color of the specular highlight",
+			ui: {
+				type: "color",
+				label: "Highlight Color"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .1,
+				label: "Speed"
+			}
+		},
+		seed: {
+			default: 1,
+			description: "Adjusts the starting state, useful for variation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the blob",
+			ui: {
+				type: "position",
+				label: "Center Position"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, uvContext } = params;
+		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, smoothstep, sin: sin$1, length, viewportSize: viewportSize$1, pow: pow$1, max: max$1, normalize, dot: dot$1, reflect } = TSL;
+		const baseUV = uvContext ?? screenUV$1;
+		const animTime = createAnimatedTime(params, uniforms.speed, uniforms.seed);
+		const colorA = uniforms.colorA.uniform;
+		const colorB = uniforms.colorB.uniform;
+		const size = uniforms.size.uniform;
+		const deformation = uniforms.deformation.uniform;
+		const softness = uniforms.softness.uniform;
+		const highlightIntensity = uniforms.highlightIntensity.uniform;
+		const highlightX = uniforms.highlightX.uniform;
+		const highlightY = uniforms.highlightY.uniform;
+		const highlightZ = uniforms.highlightZ.uniform;
+		const highlightColor = uniforms.highlightColor.uniform;
+		const edgeWidth = softness.mul(float$1(.3));
+		const edgeCurve = softness.mul(float$1(2)).add(float$1(.5));
+		const edgeComplexity = float$1(.5);
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const aspectCorrectedUV = vec2$1(baseUV.x.mul(aspect), baseUV.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const uv = aspectCorrectedUV.sub(centerPos);
+		const dist = length(uv);
+		const baseRadius = size;
+		const noiseScale = float$1(4);
+		const noise1 = sin$1(uv.x.mul(noiseScale.mul(float$1(.8))).add(animTime.mul(float$1(.8)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(.7))).add(animTime.mul(float$1(.6))))).add(sin$1(uv.x.mul(noiseScale.mul(float$1(1.2))).sub(uv.y.mul(noiseScale.mul(float$1(.9))).add(animTime.mul(float$1(.4)))))).mul(float$1(.15)).mul(deformation);
+		const noise2 = sin$1(uv.x.mul(noiseScale.mul(float$1(1.4))).sub(animTime.mul(float$1(.5)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(1.1))).add(animTime.mul(float$1(.7))))).mul(float$1(.12)).mul(deformation).mul(smoothstep(float$1(.15), float$1(.25), edgeComplexity));
+		const noise3 = sin$1(uv.x.mul(noiseScale.mul(float$1(1.8))).add(uv.y.mul(noiseScale.mul(float$1(1.6))).add(animTime.mul(float$1(.3))))).add(sin$1(uv.x.mul(noiseScale.mul(float$1(.6))).sub(animTime.mul(float$1(.9))))).mul(float$1(.1)).mul(deformation).mul(smoothstep(float$1(.3), float$1(.4), edgeComplexity));
+		const noise4 = sin$1(uv.x.mul(noiseScale.mul(float$1(2.2))).add(animTime.mul(float$1(.2)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(1.9))).sub(animTime.mul(float$1(.8))))).mul(float$1(.08)).mul(deformation).mul(smoothstep(float$1(.45), float$1(.55), edgeComplexity));
+		const noise5 = sin$1(uv.x.mul(noiseScale.mul(float$1(2.8))).sub(uv.y.mul(noiseScale.mul(float$1(2.4))).add(animTime.mul(float$1(.6))))).mul(float$1(.06)).mul(deformation).mul(smoothstep(float$1(.6), float$1(.7), edgeComplexity));
+		const noise6 = sin$1(uv.x.mul(noiseScale.mul(float$1(3.2))).add(animTime.mul(float$1(1.1)))).add(sin$1(uv.y.mul(noiseScale.mul(float$1(3.5))).sub(animTime.mul(float$1(.4))))).mul(float$1(.04)).mul(deformation).mul(smoothstep(float$1(.75), float$1(.85), edgeComplexity));
+		const noiseAmount = noise1.add(noise2).add(noise3).add(noise4).add(noise5).add(noise6);
+		const organicRadius = baseRadius.add(noiseAmount);
+		const blobMask = pow$1(smoothstep(organicRadius.add(edgeWidth), organicRadius.sub(edgeWidth), dist), edgeCurve);
+		const distFromCenter = length(uv);
+		const sphereRadius = organicRadius;
+		const normalTilt = smoothstep(float$1(0), sphereRadius, distFromCenter);
+		const fakeZ = float$1(1).sub(normalTilt.mul(float$1(.1)));
+		const surfaceNormal = normalize(vec3$1(uv.x.mul(normalTilt.add(float$1(.2))), uv.y.mul(normalTilt.add(float$1(.2))), fakeZ));
+		const lightDir = normalize(vec3$1(highlightX, highlightY, highlightZ));
+		const viewDir = vec3$1(float$1(0), float$1(0), float$1(1));
+		const reflectDir = reflect(lightDir.negate(), surfaceNormal);
+		const specularPower = float$1(32);
+		const specular = pow$1(max$1(float$1(0), dot$1(reflectDir, viewDir)), specularPower);
+		const curvatureBoost = normalTilt.mul(float$1(.5)).add(float$1(.5));
+		const finalHighlight = specular.mul(curvatureBoost).mul(highlightIntensity).mul(blobMask);
+		const posX = uv.x.mul(float$1(3));
+		const posY = uv.y.mul(float$1(3));
+		const colorNoise1 = sin$1(posX.add(animTime.mul(float$1(.4)))).mul(sin$1(posY.add(animTime.mul(float$1(.3))))).add(sin$1(posX.mul(float$1(.7)).add(posY.mul(float$1(.8))).add(animTime.mul(float$1(.2))))).mul(float$1(.5)).add(float$1(.5));
+		const colorNoise2 = sin$1(posX.mul(float$1(1.3)).sub(animTime.mul(float$1(.5)))).mul(sin$1(posY.mul(float$1(1.1)).add(animTime.mul(float$1(.6))))).add(sin$1(posX.mul(float$1(.5)).sub(posY.mul(float$1(.6)).sub(animTime.mul(float$1(.3)))))).mul(float$1(.5)).add(float$1(.5));
+		const combinedNoise = colorNoise1.mul(float$1(.6)).add(colorNoise2.mul(float$1(.4)));
+		const finalColorRGB = mixColors(colorA, colorB, smoothstep(float$1(.1), float$1(.9), combinedNoise), uniforms.colorSpace.uniform).rgb;
+		const avgAlpha = colorA.a.add(colorB.a).div(float$1(2));
+		const highlightContribution = highlightColor.rgb.mul(finalHighlight);
+		return vec4$1(finalColorRGB.add(highlightContribution), avgAlpha.mul(blobMask));
+	}
+};
+var Blob_default = componentDefinition;
+export { componentDefinition as n, Blob_default as t };

package/dist/core/Blur-Y2FsmFk_.js

@@ -0,0 +1,77 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Blur",
+	category: "Blurs",
+	description: "A simple Gaussian blur effect",
+	requiresRTT: true,
+	requiresChild: true,
+	props: { intensity: {
+		default: 50,
+		description: "Intensity of the blur effect",
+		ui: {
+			type: "range",
+			min: 0,
+			max: 100,
+			step: 1,
+			label: "Intensity"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, Fn } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
+		const horizontalTexture = convertToTexture$1(Fn(() => {
+			const uv = screenUV$1;
+			const blurRadius = scaledIntensity;
+			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 blurRadius = scaledIntensity;
+			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 Blur_default = componentDefinition;
+export { componentDefinition as n, Blur_default as t };

package/dist/core/Bulge-Cb-t0xqI.js

@@ -0,0 +1,132 @@
+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: "Bulge",
+	category: "Distortions",
+	description: "Magnify or pinch content around a center point",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the bulge effect",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		strength: {
+			default: 1,
+			description: "The intensity of the bulge effect (positive = bulge out, negative = pinch in)",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Strength"
+			}
+		},
+		radius: {
+			default: 1,
+			description: "The radius of the bulge effect area",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .01,
+				label: "Radius"
+			}
+		},
+		falloff: {
+			default: .5,
+			description: "Controls the smoothness of the transition (0 = hard edge, 1 = very smooth)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Falloff"
+			}
+		},
+		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, viewportSize: viewportSize$1 }) => {
+		const { vec2: vec2$1, length, smoothstep, float: float$1, max: max$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 distance = length(delta);
+		const effectRadius = uniforms.radius.uniform.mul(.5);
+		const falloffAmount = uniforms.falloff.uniform;
+		const smoothFalloff = smoothstep(effectRadius.mul(float$1(1).sub(falloffAmount).sub(float$1(.001)).max(float$1(0))), effectRadius, distance).oneMinus();
+		const normalizedDist = distance.div(effectRadius);
+		const distSq = normalizedDist.mul(normalizedDist);
+		const quadraticFalloff = max$1(float$1(0), float$1(1).sub(distSq));
+		const falloff = smoothFalloff.mul(quadraticFalloff);
+		const displacementAmount = uniforms.strength.uniform.negate().mul(falloff);
+		const scaleFactor = float$1(1).add(displacementAmount);
+		const bulgedDelta = delta.mul(scaleFactor);
+		const bulgedUV = centerPos.add(bulgedDelta);
+		return vec2$1(bulgedUV.x.div(aspect), bulgedUV.y);
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, length, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, smoothstep } = 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 distance = length(delta);
+		const effectRadius = uniforms.radius.uniform.mul(.5);
+		const falloffAmount = uniforms.falloff.uniform;
+		const smoothFalloff = smoothstep(effectRadius.mul(TSL.float(1).sub(falloffAmount).sub(TSL.float(.001)).max(TSL.float(0))), effectRadius, distance).oneMinus();
+		const normalizedDist = distance.div(effectRadius);
+		const distSq = normalizedDist.mul(normalizedDist);
+		const quadraticFalloff = TSL.max(TSL.float(0), TSL.float(1).sub(distSq));
+		const falloff = smoothFalloff.mul(quadraticFalloff);
+		const displacementAmount = uniforms.strength.uniform.negate().mul(falloff);
+		const scaleFactor = TSL.float(1).add(displacementAmount);
+		const bulgedDelta = delta.mul(scaleFactor);
+		const bulgedUV = centerPos.add(bulgedDelta);
+		const finalUV = vec2$1(bulgedUV.x.div(aspect), bulgedUV.y);
+		return applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform);
+	}
+};
+var Bulge_default = componentDefinition;
+export { componentDefinition as n, Bulge_default as t };

package/dist/core/CRTScreen-CtERsenz.js

@@ -0,0 +1,112 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "CRTScreen",
+	category: "Stylize",
+	description: "Retro CRT monitor simulation with scanlines",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		pixelSize: {
+			default: 128,
+			description: "Size of individual TV pixels (lower = more pixels)",
+			ui: {
+				type: "range",
+				min: 8,
+				max: 128,
+				step: 1,
+				label: "Pixel Size"
+			}
+		},
+		colorShift: {
+			default: 1,
+			description: "Chromatic aberration amount",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Color Shift"
+			}
+		},
+		scanlineIntensity: {
+			default: .3,
+			description: "Strength of horizontal scanlines",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Scanline Intensity"
+			}
+		},
+		scanlineFrequency: {
+			default: 200,
+			description: "Number of scanlines across screen",
+			ui: {
+				type: "range",
+				min: 100,
+				max: 800,
+				step: 10,
+				label: "Scanline Frequency"
+			}
+		},
+		brightness: {
+			default: 1.1,
+			description: "Screen brightness boost",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 2,
+				step: .01,
+				label: "Brightness"
+			}
+		},
+		contrast: {
+			default: 1.2,
+			description: "Screen contrast enhancement",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 2,
+				step: .01,
+				label: "Contrast"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, fract, smoothstep, length, 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.pixelSize.uniform;
+		const colorShift = uniforms.colorShift.uniform;
+		const scanlineIntensity = uniforms.scanlineIntensity.uniform;
+		const scanlineFrequency = uniforms.scanlineFrequency.uniform;
+		const brightness = uniforms.brightness.uniform;
+		const contrast = uniforms.contrast.uniform;
+		const scaledColorShift = colorShift.mul(float$1(.002));
+		const redUV = screenUV$1.add(vec2$1(scaledColorShift, float$1(0)));
+		const greenUV = screenUV$1;
+		const blueUV = screenUV$1.sub(vec2$1(scaledColorShift, float$1(0)));
+		const redSample = childTexture.sample(redUV).r;
+		const greenSample = childTexture.sample(greenUV).g;
+		const blueSample = childTexture.sample(blueUV).b;
+		const adjustedColor = vec3$1(redSample, greenSample, blueSample).sub(float$1(.5)).mul(contrast).add(float$1(.5)).mul(brightness);
+		const scanlineWave = sin$1(screenUV$1.y.mul(scanlineFrequency).mul(float$1(3.14159 * 2)));
+		const scanlineEffect = float$1(1).sub(scanlineIntensity.mul(scanlineWave.mul(float$1(.5)).add(float$1(.5))));
+		const scanlinedColor = adjustedColor.mul(scanlineEffect);
+		const phosphorScale = pixelSize.mul(float$1(.5));
+		const pixelPhase = fract(screenUV$1.mul(phosphorScale));
+		const redMask = sin$1(pixelPhase.x.mul(float$1(6.28318))).mul(float$1(.1)).add(float$1(.95));
+		const greenMask = sin$1(pixelPhase.x.mul(float$1(6.28318)).add(float$1(2.09))).mul(float$1(.1)).add(float$1(.95));
+		const blueMask = sin$1(pixelPhase.x.mul(float$1(6.28318)).add(float$1(4.18))).mul(float$1(.1)).add(float$1(.95));
+		const phosphorColor = vec3$1(scanlinedColor.r.mul(redMask), scanlinedColor.g.mul(greenMask), scanlinedColor.b.mul(blueMask));
+		const vignetteDistance = length(screenUV$1.sub(vec2$1(.5, .5)));
+		const vignette = smoothstep(float$1(.8), float$1(.3), vignetteDistance);
+		return vec4$1(phosphorColor.mul(vignette), float$1(1));
+	}
+};
+var CRTScreen_default = componentDefinition;
+export { componentDefinition as n, CRTScreen_default as t };

package/dist/core/ChannelBlur-CvM6GJgZ.js

@@ -0,0 +1,118 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "ChannelBlur",
+	category: "Blurs",
+	description: "Independent blur for red, green, and blue channels",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		redIntensity: {
+			default: 0,
+			description: "Blur intensity for red channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Red Intensity"
+			}
+		},
+		greenIntensity: {
+			default: 20,
+			description: "Blur intensity for green channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Green Intensity"
+			}
+		},
+		blueIntensity: {
+			default: 40,
+			description: "Blur intensity for blue channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Blue Intensity"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, Fn } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const redRadius = uniforms.redIntensity.uniform.mul(.1);
+		const greenRadius = uniforms.greenIntensity.uniform.mul(.1);
+		const blueRadius = uniforms.blueIntensity.uniform.mul(.1);
+		const horizontalTexture = convertToTexture$1(Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const redTotal = float$1(0).toVar();
+			const greenTotal = float$1(0).toVar();
+			const blueTotal = float$1(0).toVar();
+			for (let x = -6; x <= 6; x++) {
+				const weight = float$1(weights[x + 6] / weightSum);
+				const xOffset = float$1(x).mul(pixelSize.x);
+				const redOffset = vec2$1(xOffset.mul(redRadius), float$1(0));
+				const greenOffset = vec2$1(xOffset.mul(greenRadius), float$1(0));
+				const blueOffset = vec2$1(xOffset.mul(blueRadius), float$1(0));
+				const redSample = childTexture.sample(uv.add(redOffset)).r.mul(weight);
+				const greenSample = childTexture.sample(uv.add(greenOffset)).g.mul(weight);
+				const blueSample = childTexture.sample(uv.add(blueOffset)).b.mul(weight);
+				redTotal.assign(redTotal.add(redSample));
+				greenTotal.assign(greenTotal.add(greenSample));
+				blueTotal.assign(blueTotal.add(blueSample));
+			}
+			return vec4$1(redTotal, greenTotal, blueTotal, float$1(1));
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const redTotal = float$1(0).toVar();
+			const greenTotal = float$1(0).toVar();
+			const blueTotal = float$1(0).toVar();
+			for (let y = -6; y <= 6; y++) {
+				const weight = float$1(weights[y + 6] / weightSum);
+				const yOffset = float$1(y).mul(pixelSize.y);
+				const redOffset = vec2$1(float$1(0), yOffset.mul(redRadius));
+				const greenOffset = vec2$1(float$1(0), yOffset.mul(greenRadius));
+				const blueOffset = vec2$1(float$1(0), yOffset.mul(blueRadius));
+				const redSample = horizontalTexture.sample(uv.add(redOffset)).r.mul(weight);
+				const greenSample = horizontalTexture.sample(uv.add(greenOffset)).g.mul(weight);
+				const blueSample = horizontalTexture.sample(uv.add(blueOffset)).b.mul(weight);
+				redTotal.assign(redTotal.add(redSample));
+				greenTotal.assign(greenTotal.add(greenSample));
+				blueTotal.assign(blueTotal.add(blueSample));
+			}
+			const originalAlpha = childTexture.sample(uv).a;
+			return vec4$1(redTotal, greenTotal, blueTotal, originalAlpha);
+		})();
+	}
+};
+var ChannelBlur_default = componentDefinition;
+export { componentDefinition as n, ChannelBlur_default as t };