shaders 2.2.23 → 2.2.25

package/dist/core/Dither-D2Nf4p3w.js

@@ -0,0 +1,66 @@
+import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Dither",
+	category: "Stylize",
+	description: "Bayer matrix dithering to reduce colors",
+	requiresChild: true,
+	props: {
+		pixelSize: {
+			default: 4,
+			description: "Size of dithering pixels",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 20,
+				step: 1,
+				label: "Pixel Size"
+			}
+		},
+		threshold: {
+			default: .5,
+			description: "Luminance threshold for dithering",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold"
+			}
+		},
+		colorA: {
+			default: "transparent",
+			transform: transformColor,
+			description: "Dark color for dithering",
+			ui: {
+				type: "color",
+				label: "Dark Color"
+			}
+		},
+		colorB: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Light color for dithering",
+			ui: {
+				type: "color",
+				label: "Light Color"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode }) => {
+		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, floor, screenUV: screenUV$1, viewportSize: viewportSize$1, dot: dot$1, step: step$1, mix: mix$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const sourceColor = childNode;
+		const luminance = dot$1(sourceColor.rgb, vec3$1(.299, .587, .114)).mul(sourceColor.a);
+		const pixelSize = uniforms.pixelSize.uniform;
+		const bayerPos = floor(screenUV$1.mul(viewportSize$1).div(pixelSize)).mod(vec2$1(4));
+		const x = bayerPos.x;
+		const y = bayerPos.y;
+		const bayerValue = y.equal(0).select(x.equal(0).select(0 / 16, x.equal(1).select(8 / 16, x.equal(2).select(2 / 16, 10 / 16))), y.equal(1).select(x.equal(0).select(12 / 16, x.equal(1).select(4 / 16, x.equal(2).select(14 / 16, 6 / 16))), y.equal(2).select(x.equal(0).select(3 / 16, x.equal(1).select(11 / 16, x.equal(2).select(1 / 16, 9 / 16))), x.equal(0).select(15 / 16, x.equal(1).select(7 / 16, x.equal(2).select(13 / 16, 5 / 16))))));
+		const threshold = uniforms.threshold.uniform;
+		const ditherResult = step$1(bayerValue, luminance.add(threshold.sub(.5)));
+		return vec4$1(mix$1(uniforms.colorA.uniform.rgb, uniforms.colorB.uniform.rgb, ditherResult), mix$1(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, ditherResult));
+	}
+};
+var Dither_default = componentDefinition;
+export { componentDefinition as n, Dither_default as t };

package/dist/core/DotGrid-CzOwquo4.js

@@ -0,0 +1,75 @@
+import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "DotGrid",
+	category: "Base Layers",
+	description: "Grid of dots with optional twinkling animation",
+	acceptsUVContext: true,
+	props: {
+		color: {
+			default: "#ffffff",
+			description: "The color of the dot",
+			transform: transformColor,
+			ui: {
+				type: "color",
+				label: "Color"
+			}
+		},
+		density: {
+			default: 100,
+			description: "The number of dots on the longest canvas edge",
+			ui: {
+				type: "range",
+				min: 10,
+				max: 500,
+				step: 10,
+				label: "Density"
+			}
+		},
+		dotSize: {
+			default: .3,
+			description: "The size of each dot, zero (0) being invisible, one (1) filled the grid with no gaps",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Dot Size"
+			}
+		},
+		twinkle: {
+			default: 0,
+			description: "Intensity of the twinkle effect (0 = off, 1 = full twinkle)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Twinkle"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, uvContext }) => {
+		const { screenUV: screenUV$1, vec4: vec4$1, vec2: vec2$1, smoothstep, length, floor, float: float$1, viewportSize: viewportSize$1, time, sin: sin$1, mix: mix$1 } = TSL;
+		const uvCoords = uvContext ?? screenUV$1;
+		const density = uniforms.density.uniform;
+		const dotSize = uniforms.dotSize.uniform;
+		const dotColor = uniforms.color.uniform;
+		const twinkleIntensity = uniforms.twinkle.uniform;
+		const resolution = viewportSize$1;
+		const aspect = resolution.x.div(resolution.y);
+		const correctedUV = vec2$1(uvCoords.x.mul(aspect), uvCoords.y.oneMinus());
+		const gridUV = correctedUV.mul(density);
+		const centerDistance = length(gridUV.sub(floor(gridUV)).sub(.5));
+		const pixelSize = length(TSL.fwidth(correctedUV.mul(density)));
+		const dot$1 = float$1(1).sub(smoothstep(dotSize.mul(.5), dotSize.mul(.5).add(pixelSize.mul(.5)), centerDistance));
+		const gridPosition = floor(gridUV);
+		const dotPhase = gridPosition.x.mul(12.9898).add(gridPosition.y.mul(78.233)).sin().mul(43758.5453).fract();
+		const twinkleValue = sin$1(time.mul(2).add(dotPhase.mul(6.28318))).mul(.5).add(.5);
+		const twinkleModifier = mix$1(float$1(1), twinkleValue, twinkleIntensity);
+		const twinkledAlpha = dot$1.mul(twinkleModifier);
+		return vec4$1(dotColor.rgb, twinkledAlpha);
+	}
+};
+var DotGrid_default = componentDefinition;
+export { componentDefinition as n, DotGrid_default as t };

package/dist/core/Duotone-XuTN9tI7.js

@@ -0,0 +1,65 @@
+import { i as transformColorSpace, 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: "Duotone",
+	category: "Adjustments",
+	description: "Map colors to two tones based on luminance",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		colorA: {
+			default: "#ff0000",
+			transform: transformColor,
+			description: "First color (used for darker areas)",
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#023af4",
+			transform: transformColor,
+			description: "Second color (used for brighter areas)",
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		blend: {
+			default: .5,
+			description: "Blend point between the two colors",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Blend"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec3: vec3$1, vec4: vec4$1, dot: dot$1, smoothstep, 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 inputColor = childTexture.sample(screenUV$1);
+		const luminance = dot$1(inputColor.rgb, vec3$1(.299, .587, .114));
+		const adjustedLuminance = smoothstep(uniforms.blend.uniform.sub(.5), uniforms.blend.uniform.add(.5), luminance);
+		return vec4$1(mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, adjustedLuminance, uniforms.colorSpace.uniform).rgb, inputColor.a);
+	}
+};
+var Duotone_default = componentDefinition;
+export { componentDefinition as n, Duotone_default as t };

package/dist/core/FilmGrain-D3-nbi12.js

@@ -0,0 +1,28 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "FilmGrain",
+	category: "Stylize",
+	description: "Analog film grain texture overlay",
+	requiresChild: true,
+	acceptsUVContext: true,
+	props: { strength: {
+		default: .5,
+		description: "Intensity of the film grain noise",
+		ui: {
+			type: "range",
+			min: 0,
+			max: 1,
+			step: .01,
+			label: "Strength"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode, uvContext }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, dot: dot$1, fract } = TSL;
+		const strength = uniforms.strength.uniform;
+		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
+		const grainIntensity = fract(sin$1(dot$1(uvContext ?? screenUV$1, vec2$1(float$1(12.9898), float$1(78.233)).mul(float$1(2)))).mul(float$1(43758.5453))).mul(float$1(2)).sub(float$1(1)).mul(strength.mul(float$1(.1)));
+		return vec4$1(sourceColor.rgb.add(grainIntensity), sourceColor.a);
+	}
+};
+var FilmGrain_default = componentDefinition;
+export { componentDefinition as n, FilmGrain_default as t };

package/dist/core/FloatingParticles-D9Nnu1qg.js

@@ -0,0 +1,217 @@
+import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+var { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, sin: sin$1, cos: cos$1, smoothstep, mix: mix$1, min: min$1, floor, fract, length, dot: dot$1, screenUV: screenUV$1, viewportSize: viewportSize$1, time, Fn } = TSL;
+var hash1_2 = Fn(([p]) => {
+	return fract(sin$1(dot$1(p, vec2$1(127.1, 311.7))).mul(43758.5453123));
+});
+var hash2_2 = Fn(([p]) => {
+	return fract(sin$1(vec2$1(dot$1(p, vec2$1(127.1, 311.7)), dot$1(p, vec2$1(269.5, 183.3)))).mul(43758.5453));
+});
+var voronoiPointFromRoot = Fn(([root, deg]) => {
+	const point = hash2_2(root).sub(.5);
+	const s = sin$1(deg);
+	const c = cos$1(deg);
+	return vec2$1(c.mul(point.x).sub(s.mul(point.y)).mul(.66), s.mul(point.x).add(c.mul(point.y)).mul(.66)).add(root).add(.5);
+});
+var degFromRootUV = Fn(([uv, randomness]) => {
+	return time.mul(randomness).mul(hash1_2(uv).sub(.5)).mul(2);
+});
+var getParticleDistance = Fn(([uv, cellUV, randomness]) => {
+	const pointUV = voronoiPointFromRoot(cellUV, degFromRootUV(cellUV, randomness));
+	return length(uv.sub(pointUV));
+});
+const componentDefinition = {
+	name: "FloatingParticles",
+	category: "Base Layers",
+	description: "Animated floating particles with twinkle effects",
+	requiresRTT: false,
+	acceptsUVContext: true,
+	props: {
+		randomness: {
+			default: .25,
+			description: "Randomness of particle animation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Randomness"
+			}
+		},
+		speed: {
+			default: .25,
+			description: "Speed of particle movement",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed"
+			}
+		},
+		angle: {
+			default: 90,
+			description: "Movement angle in degrees (0=right, 90=down, 180=left, 270=up)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		particleSize: {
+			default: 1,
+			description: "Size of particles",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 20,
+				step: .1,
+				label: "Particle Size"
+			}
+		},
+		particleSoftness: {
+			default: 0,
+			description: "Edge softness of particles (0 = sharp, 1 = very soft)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .01,
+				label: "Particle Softness"
+			}
+		},
+		twinkle: {
+			default: .5,
+			description: "Intensity of the twinkle effect (0 = off, 1 = full twinkle)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Twinkle"
+			}
+		},
+		count: {
+			default: 5,
+			description: "Number of particle layers",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 5,
+				step: 1,
+				label: "Count"
+			}
+		},
+		particleColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the particles",
+			ui: {
+				type: "color",
+				label: "Particle Color"
+			}
+		},
+		speedVariance: {
+			default: .3,
+			description: "Per-layer speed variance (0 = all layers same speed, 1 = high variance)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed Variance"
+			}
+		},
+		angleVariance: {
+			default: 30,
+			description: "Per-layer angle variance in degrees (0 = all layers same angle, 180 = full variance)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 180,
+				step: 1,
+				label: "Angle Variance"
+			}
+		},
+		particleDensity: {
+			default: 3,
+			description: "Particle density (lower = more spread out, higher = more dense)",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 3,
+				step: .1,
+				label: "Particle Density"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, uvContext }) => {
+		const baseUV = uvContext ?? screenUV$1;
+		const renderParticle = Fn(([uv$1]) => {
+			const rootUV = floor(uv$1);
+			const localPos = fract(uv$1);
+			let minDist = getParticleDistance(uv$1, rootUV, uniforms.randomness.uniform);
+			const softness = uniforms.particleSoftness.uniform;
+			const scaledSize = uniforms.particleSize.uniform.mul(.01);
+			const outerRadius = scaledSize.mul(.6).add(softness.mul(scaledSize.mul(2.4)));
+			const needsNeighbors = outerRadius.greaterThan(.35);
+			const nearLeft = localPos.x.lessThan(.4);
+			const nearRight = localPos.x.greaterThan(.6);
+			const nearTop = localPos.y.lessThan(.4);
+			const nearBottom = localPos.y.greaterThan(.6);
+			const checkLeft = needsNeighbors.and(nearLeft);
+			const checkRight = needsNeighbors.and(nearRight);
+			const checkTop = needsNeighbors.and(nearTop);
+			const checkBottom = needsNeighbors.and(nearBottom);
+			minDist = checkLeft.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(-1, 0)), uniforms.randomness.uniform)), minDist);
+			minDist = checkRight.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(1, 0)), uniforms.randomness.uniform)), minDist);
+			minDist = checkTop.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(0, -1)), uniforms.randomness.uniform)), minDist);
+			minDist = checkBottom.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(0, 1)), uniforms.randomness.uniform)), minDist);
+			const baseIntensity = smoothstep(outerRadius, scaledSize.mul(.6), minDist);
+			const twinkleIntensity = uniforms.twinkle.uniform;
+			const particlePhase = rootUV.x.mul(12.9898).add(rootUV.y.mul(78.233)).sin().mul(43758.5453).fract();
+			const twinkleValue = sin$1(time.mul(2).add(particlePhase.mul(6.28318))).mul(.5).add(.5);
+			const twinkleModifier = mix$1(float$1(1), twinkleValue, twinkleIntensity);
+			return baseIntensity.mul(twinkleModifier).mul(uniforms.particleColor.uniform.rgb);
+		});
+		const layeredParticles = Fn(([uv$1]) => {
+			const sizeMod = float$1(1.05);
+			const alphaMod = float$1(.9);
+			const layers = uniforms.count.uniform;
+			const particles$1 = vec3$1(0).toVar();
+			const size = float$1(1).toVar();
+			const alpha = float$1(1).toVar();
+			const offset = vec2$1(0).toVar();
+			const angleRad = uniforms.angle.uniform.mul(3.14159).div(180);
+			const baseMovementDir = vec2$1(cos$1(angleRad), sin$1(angleRad));
+			const baseMovement = time.mul(baseMovementDir).mul(uniforms.speed.uniform);
+			const speedVar = uniforms.speedVariance.uniform;
+			const angleVar = uniforms.angleVariance.uniform.mul(3.14159).div(180);
+			for (let i = 0; i < 4; i++) {
+				const layerActive = float$1(i).lessThan(layers).and(alpha.greaterThan(.02));
+				const layerHash = hash2_2(vec2$1(alpha, float$1(i).mul(7.919)));
+				const speedMod = float$1(1).add(layerHash.x.sub(.5).mul(speedVar));
+				const angleDelta = layerHash.y.sub(.5).mul(angleVar).mul(2);
+				const variedAngle = angleRad.add(angleDelta);
+				const variedDir = vec2$1(cos$1(variedAngle), sin$1(variedAngle));
+				const movement = baseMovement.mul(speedMod).add(variedDir.sub(baseMovementDir).mul(time).mul(uniforms.speed.uniform));
+				const layerParticles = renderParticle(uv$1.mul(size).add(movement).add(offset)).mul(alpha);
+				particles$1.assign(particles$1.add(layerActive.select(layerParticles, vec3$1(0))));
+				offset.assign(offset.add(layerHash.mul(10)));
+				alpha.assign(alpha.mul(alphaMod));
+				size.assign(size.mul(sizeMod));
+			}
+			return particles$1;
+		});
+		const uv = baseUV.mul(2).sub(1);
+		const aspectRatio = viewportSize$1.x.div(viewportSize$1.y);
+		const particles = layeredParticles(vec2$1(uv.x.mul(aspectRatio), uv.y).mul(uniforms.particleDensity.uniform));
+		const particleAlpha = length(particles);
+		if (childNode) return vec4$1(mix$1(childNode.xyz, particles, particleAlpha.greaterThan(.01).select(particleAlpha, 0)), childNode.w);
+		return vec4$1(particles, particleAlpha);
+	}
+};
+var FloatingParticles_default = componentDefinition;
+export { componentDefinition as n, FloatingParticles_default as t };

package/dist/core/GlassTiles-CnjCvajI.js

@@ -0,0 +1,69 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "GlassTiles",
+	category: "Distortions",
+	description: "Refraction-like distortion in a tile grid pattern",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 1,
+			description: "The intensity of the glass tiles effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Intensity"
+			}
+		},
+		tileCount: {
+			default: 100,
+			description: "Number of tiles across the shortest dimension",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 200,
+				step: 1,
+				label: "Tile Count"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
+		const { vec2: vec2$1, floor, select } = TSL;
+		const intensity = uniforms.intensity.uniform;
+		const baseTileCount = uniforms.tileCount.uniform;
+		const aspectRatio = viewportSize$1.x.div(viewportSize$1.y);
+		const tileCount = vec2$1(select(aspectRatio.greaterThanEqual(1), baseTileCount.mul(aspectRatio), baseTileCount), select(aspectRatio.lessThan(1), baseTileCount.div(aspectRatio), baseTileCount));
+		const cellCoord = floor(uv.mul(tileCount)).div(tileCount);
+		const localUV = uv.sub(cellCoord);
+		const distortionCenter = vec2$1(.5, .5);
+		const distortionFactor = intensity.mul(.025);
+		const distortion = localUV.div(vec2$1(1, 1).div(tileCount)).sub(distortionCenter).mul(distortionFactor);
+		return localUV.add(distortion).add(cellCoord);
+	},
+	fragmentNode: ({ uniforms, childNode, dimensions, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, floor, mul: mul$1, div: div$1, sub: sub$1, add: add$1, screenUV: screenUV$1, uniform: uniform$1, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) {
+			console.error("You must pass a child component into the Glass Tiles shader.");
+			return vec4$1(0);
+		}
+		const texture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (texture?.renderTarget?.dispose) texture.renderTarget.dispose();
+		});
+		const aspectRatioUniform = uniform$1(dimensions.width / dimensions.height);
+		const uvNode = screenUV$1;
+		const intensity = uniforms.intensity.uniform;
+		const baseTileCount = uniforms.tileCount.uniform;
+		const tileCount = vec2$1(aspectRatioUniform.greaterThanEqual(1).select(mul$1(baseTileCount, aspectRatioUniform), baseTileCount), aspectRatioUniform.lessThan(1).select(div$1(baseTileCount, aspectRatioUniform), baseTileCount));
+		const cellCoord = div$1(floor(mul$1(uvNode, tileCount)), tileCount);
+		const localUV = sub$1(uvNode, cellCoord);
+		const distortionCenter = vec2$1(.5, .5);
+		const distortionFactor = mul$1(intensity, .025);
+		const finalUV = add$1(add$1(localUV, mul$1(sub$1(div$1(localUV, div$1(vec2$1(1), tileCount)), distortionCenter), distortionFactor)), cellCoord);
+		return vec4$1(texture.sample(finalUV));
+	}
+};
+var GlassTiles_default = componentDefinition;
+export { componentDefinition as n, GlassTiles_default as t };

package/dist/core/Glow-BluFc9be.js

@@ -0,0 +1,75 @@
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Glow",
+	category: "Stylize",
+	description: "Soft glow effect with adjustable intensity",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 1,
+			description: "Glow intensity (brightness of the glow effect)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .01,
+				label: "Intensity"
+			}
+		},
+		threshold: {
+			default: .5,
+			description: "Brightness threshold for glow extraction (lower = more glow)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold"
+			}
+		},
+		size: {
+			default: 10,
+			description: "Size/spread of the glow effect",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 20,
+				step: .01,
+				label: "Glow Size"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, max: max$1, dot: dot$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 originalColor = childTexture.sample(screenUV$1);
+		const glowEffect = Fn(() => {
+			const blurRadius = uniforms.size.uniform;
+			const threshold = uniforms.threshold.uniform;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const blurredGlow = vec4$1(0, 0, 0, 0).toVar();
+			const radius = 5;
+			for (let dx = -radius; dx <= radius; dx++) for (let dy = -radius; dy <= radius; dy++) {
+				const offset = vec2$1(float$1(dx), float$1(dy)).mul(pixelSize).mul(blurRadius);
+				const sampleUV = screenUV$1.add(offset);
+				const sampleColor = childTexture.sample(sampleUV);
+				const luminance = dot$1(sampleColor.rgb, vec3$1(.299, .587, .114));
+				const brightnessMask = max$1(float$1(0), luminance.sub(threshold));
+				const brightColor = sampleColor.mul(brightnessMask);
+				blurredGlow.assign(blurredGlow.add(brightColor));
+			}
+			const totalSamples = float$1((radius * 2 + 1) * (radius * 2 + 1));
+			return blurredGlow.div(totalSamples);
+		})();
+		const intensity = uniforms.intensity.uniform;
+		const intensifiedGlow = glowEffect.mul(intensity);
+		return vec4$1(originalColor.rgb.add(intensifiedGlow.rgb), max$1(originalColor.a, intensifiedGlow.a));
+	}
+};
+var Glow_default = componentDefinition;
+export { componentDefinition as n, Glow_default as t };