shaders 2.5.122 → 2.5.124

package/dist/core/{FloatingParticles-DKoG78j0.js → FloatingParticles-LMsFTJKp.js}

@@ -1,11 +1,21 @@
 import { a as transformColor } from "./transformations-CJcUeZIC.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
-import { Fn, cos, dot, float, floor, fract, length, min, mix, screenUV, sin, smoothstep, time, vec2, vec3, vec4, viewportSize } from "three/tsl";
+import { StorageTexture } from "three/webgpu";
+import { FloatType } from "three";
+import { Fn, cos, dot, float, floor, fract, instanceIndex, length, min, mix, screenUV, sin, smoothstep, storageTexture, texture, textureStore, time, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
+var PARTICLE_TEX = 1024;
 var hash1_2 = Fn(([p]) => {
-	return fract(sin(dot(p, vec2(127.1, 311.7))).mul(43758.5453123));
+	const p3 = fract(vec3(p.x, p.y, p.x).mul(.1031));
+	const d = dot(p3, vec3(p3.y, p3.z, p3.x).add(33.33));
+	const p3b = p3.add(d);
+	return fract(p3b.x.add(p3b.y).mul(p3b.z));
 });
 var hash2_2 = Fn(([p]) => {
-	return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))).mul(43758.5453));
+	const p3 = fract(vec3(p.x, p.y, p.x).mul(vec3(.1031, .103, .0973)));
+	const d = dot(p3, vec3(p3.y, p3.z, p3.x).add(33.33));
+	const p3b = p3.add(d);
+	const s = p3b.x.add(p3b.y);
+	return fract(vec2(s.mul(p3b.z), s.mul(p3b.y)));
 });
 var voronoiPointFromRoot = Fn(([root, deg]) => {
 	const point = hash2_2(root).sub(.5);
@@ -20,6 +30,13 @@ var getParticleDistance = Fn(([uv$1, cellUV, randomness]) => {
 	const pointUV = voronoiPointFromRoot(cellUV, degFromRootUV(cellUV, randomness));
 	return length(uv$1.sub(pointUV));
 });
+var degFromRootUV_compute = Fn(([uv$1, randomness, frameTimeU]) => {
+	return frameTimeU.mul(randomness).mul(hash1_2(uv$1).sub(.5)).mul(2);
+});
+var getParticleDistance_compute = Fn(([uv$1, cellUV, randomness, frameTimeU]) => {
+	const pointUV = voronoiPointFromRoot(cellUV, degFromRootUV_compute(cellUV, randomness, frameTimeU));
+	return length(uv$1.sub(pointUV));
+});
 const componentDefinition = {
 	name: "FloatingParticles",
 	category: "Textures",
@@ -63,7 +80,7 @@ const componentDefinition = {
 			}
 		},
 		particleSize: {
-			default: 1,
+			default: 2,
 			description: "Size of particles",
 			ui: {
 				type: ["range", "map"],
@@ -157,8 +174,106 @@ const componentDefinition = {
 			}
 		}
 	},
+	computeNode: (params) => {
+		const { uniforms, onCleanup } = params;
+		const texSize = PARTICLE_TEX;
+		const count = texSize * texSize;
+		const gs = uint(texSize);
+		const outTex = new StorageTexture(texSize, texSize);
+		outTex.type = FloatType;
+		const outTexNode = storageTexture(outTex);
+		onCleanup(() => outTex.dispose());
+		const animTimeU = uniform(0);
+		const frameTimeU = uniform(0);
+		const aspectU = uniform(16 / 9);
+		const computeRenderParticle = Fn(([uv$1]) => {
+			const rootUV = floor(uv$1);
+			const randomness = uniforms.randomness.uniform;
+			const dCenter = getParticleDistance_compute(uv$1, rootUV, randomness, frameTimeU);
+			const dLeft = getParticleDistance_compute(uv$1, rootUV.add(vec2(-1, 0)), randomness, frameTimeU);
+			const dRight = getParticleDistance_compute(uv$1, rootUV.add(vec2(1, 0)), randomness, frameTimeU);
+			const dTop = getParticleDistance_compute(uv$1, rootUV.add(vec2(0, -1)), randomness, frameTimeU);
+			const dBottom = getParticleDistance_compute(uv$1, rootUV.add(vec2(0, 1)), randomness, frameTimeU);
+			const minDist = min(min(min(min(dCenter, dLeft), dRight), dTop), dBottom);
+			const softness = uniforms.particleSoftness.uniform;
+			const scaledSize = uniforms.particleSize.uniform.mul(.01);
+			const innerRadius = scaledSize.mul(.6);
+			const baseIntensity = smoothstep(innerRadius, innerRadius.add(softness.mul(scaledSize.mul(2.4))), minDist).oneMinus();
+			const twinkleIntensity = uniforms.twinkle.uniform;
+			const particlePhase = hash1_2(rootUV);
+			const twinkleValue = sin(frameTimeU.mul(2).add(particlePhase.mul(6.28318))).mul(.5).add(.5);
+			const twinkleModifier = mix(float(1), twinkleValue, twinkleIntensity);
+			return baseIntensity.mul(twinkleModifier).mul(uniforms.particleColor.uniform.rgb);
+		});
+		const computeLayeredParticles = Fn(([uv$1]) => {
+			const sizeMod = float(1.05);
+			const alphaMod = float(.9);
+			const layers = uniforms.count.uniform;
+			const particles = vec3(0).toVar();
+			const layerScale = float(1).toVar();
+			const alpha = float(1).toVar();
+			const offset = vec2(0).toVar();
+			const angleRad = uniforms.angle.uniform.mul(3.14159).div(180);
+			const baseMovementDir = vec2(cos(angleRad), sin(angleRad));
+			const baseMovement = animTimeU.mul(baseMovementDir);
+			const speedVar = uniforms.speedVariance.uniform;
+			const angleVar = uniforms.angleVariance.uniform.mul(3.14159).div(180);
+			for (let i = 0; i < 5; i++) {
+				const layerActive = float(i).lessThan(layers).and(alpha.greaterThan(.02));
+				const layerHash = hash2_2(vec2(alpha, float(i).mul(7.919)));
+				const speedMod = float(1).add(layerHash.x.sub(.5).mul(speedVar));
+				const angleDelta = layerHash.y.sub(.5).mul(angleVar).mul(2);
+				const variedAngle = angleRad.add(angleDelta).toVar();
+				const variedDir = vec2(cos(variedAngle), sin(variedAngle));
+				const movement = baseMovement.mul(speedMod).add(variedDir.sub(baseMovementDir).mul(animTimeU));
+				const layerParticles = computeRenderParticle(uv$1.mul(layerScale).add(movement).add(offset)).mul(alpha);
+				particles.assign(particles.add(layerActive.select(layerParticles, vec3(0))));
+				offset.assign(offset.add(layerHash.mul(10)));
+				alpha.assign(alpha.mul(alphaMod));
+				layerScale.assign(layerScale.mul(sizeMod));
+			}
+			return particles;
+		});
+		const particlePass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const u = j.toFloat().add(.5).div(float(texSize));
+			const v = i.toFloat().add(.5).div(float(texSize));
+			const particles = computeLayeredParticles(vec2(u.mul(2).sub(1).mul(aspectU), v.mul(2).sub(1)).mul(uniforms.particleDensity.uniform));
+			const pa = length(particles).clamp(0, 1);
+			textureStore(outTexNode, uvec2(j, i), vec4(particles, pa)).toWriteOnly();
+		})().compute(count, [256]);
+		return {
+			outputs: { particleTexture: outTex },
+			getComputeNodes: (frameParams) => {
+				animTimeU.value += frameParams.deltaTime * uniforms.speed.uniform.value;
+				frameTimeU.value += frameParams.deltaTime;
+				if (frameParams.dimensions.height > 0) aspectU.value = frameParams.dimensions.width / frameParams.dimensions.height;
+				return [particlePass];
+			}
+		};
+	},
 	fragmentNode: (params) => {
-		const { uniforms, childNode } = params;
+		const { uniforms, childNode, computeOutputs } = params;
+		if (computeOutputs?.particleTexture) {
+			const particleField = texture(computeOutputs.particleTexture);
+			const px = float(1 / PARTICLE_TEX);
+			const s0 = particleField.sample(screenUV);
+			const s1 = particleField.sample(screenUV.add(vec2(px, float(0))));
+			const s2 = particleField.sample(screenUV.add(vec2(float(0), px)));
+			const s3 = particleField.sample(screenUV.add(vec2(px.negate(), float(0))));
+			const s4 = particleField.sample(screenUV.add(vec2(float(0), px.negate())));
+			const w0 = float(.5), w1 = float(.125);
+			const particles$1 = s0.xyz.mul(w0).add(s1.xyz.mul(w1)).add(s2.xyz.mul(w1)).add(s3.xyz.mul(w1)).add(s4.xyz.mul(w1));
+			const particleAlpha$1 = s0.w.mul(w0).add(s1.w.mul(w1)).add(s2.w.mul(w1)).add(s3.w.mul(w1)).add(s4.w.mul(w1));
+			if (childNode) {
+				const mixedColor = mix(childNode.xyz, particles$1, particleAlpha$1.greaterThan(.01).select(particleAlpha$1, 0));
+				const pa = particleAlpha$1.clamp(0, 1);
+				return vec4(mixedColor, pa.add(childNode.w.mul(float(1).sub(pa))));
+			}
+			return vec4(particles$1, particleAlpha$1);
+		}
 		const baseUV = screenUV;
 		const animTime = createAnimatedTime(params, uniforms.speed);
 		const renderParticle = Fn(([uv$2]) => {
@@ -175,7 +290,7 @@ const componentDefinition = {
 			const innerRadius = scaledSize.mul(.6);
 			const baseIntensity = smoothstep(innerRadius, innerRadius.add(softness.mul(scaledSize.mul(2.4))), minDist).oneMinus();
 			const twinkleIntensity = uniforms.twinkle.uniform;
-			const particlePhase = rootUV.x.mul(12.9898).add(rootUV.y.mul(78.233)).sin().mul(43758.5453).fract();
+			const particlePhase = hash1_2(rootUV);
 			const twinkleValue = sin(time.mul(2).add(particlePhase.mul(6.28318))).mul(.5).add(.5);
 			const twinkleModifier = mix(float(1), twinkleValue, twinkleIntensity);
 			return baseIntensity.mul(twinkleModifier).mul(uniforms.particleColor.uniform.rgb);
@@ -193,7 +308,7 @@ const componentDefinition = {
 			const baseMovement = animTime.mul(baseMovementDir);
 			const speedVar = uniforms.speedVariance.uniform;
 			const angleVar = uniforms.angleVariance.uniform.mul(3.14159).div(180);
-			for (let i = 0; i < 4; i++) {
+			for (let i = 0; i < 5; i++) {
 				const layerActive = float(i).lessThan(layers).and(alpha.greaterThan(.02));
 				const layerHash = hash2_2(vec2(alpha, float(i).mul(7.919)));
 				const speedMod = float(1).add(layerHash.x.sub(.5).mul(speedVar));

package/dist/core/ReflectivePlane-UIT4xlmn.js

@@ -0,0 +1,230 @@
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
+import { c as transformEdges } from "./transformations-CJcUeZIC.js";
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { Fn, If, convertToTexture, float, instanceIndex, mix, screenUV, smoothstep, step, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";
+var HALF_KERNEL = 30;
+var BLUR_TO_RADIUS_PX = 12;
+var POISSON_DISK = [
+	[0, 0],
+	[-.94, -.34],
+	[.95, .31],
+	[-.09, -.93],
+	[.34, .94],
+	[-.91, .41],
+	[.88, -.46],
+	[-.4, .71],
+	[.51, .58],
+	[-.49, -.59],
+	[.4, -.68],
+	[-.71, .05],
+	[.07, .21]
+];
+var POISSON_WEIGHT = 1 / POISSON_DISK.length;
+const componentDefinition = {
+	name: "ReflectivePlane",
+	category: "Stylize",
+	description: "Reflective floor that mirrors the content above it",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		height: {
+			default: .7,
+			description: "Vertical position of the reflective surface",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Floor Height",
+				group: "Plane"
+			}
+		},
+		distance: {
+			default: .5,
+			description: "How far below the floor the reflection remains visible before fully fading to transparent.",
+			ui: {
+				type: ["range", "map"],
+				min: .01,
+				max: 1,
+				step: .01,
+				label: "Reflection Distance",
+				group: "Plane"
+			}
+		},
+		falloff: {
+			default: .5,
+			description: "Width of the fade zone, as a fraction of reflection distance.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Reflection Falloff",
+				group: "Plane"
+			}
+		},
+		blur: {
+			default: 3,
+			description: "Maximum blur applied to the reflection far from the surface.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 5,
+				step: .05,
+				label: "Blur",
+				group: "Surface"
+			}
+		},
+		blurDistance: {
+			default: .3,
+			description: "How far below the surface the blur takes to ramp from sharp to maximum.",
+			ui: {
+				type: "range",
+				min: .01,
+				max: 1,
+				step: .01,
+				label: "Blur Distance",
+				group: "Surface"
+			}
+		},
+		edges: {
+			default: "stretch",
+			description: "How to handle reflected samples that fall outside the source content.",
+			transform: transformEdges,
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges",
+				group: "Surface"
+			}
+		}
+	},
+	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms, onResize }) => {
+		if (!childNode) return null;
+		if (uniforms.height.mapComputeInfo || uniforms.blur.mapComputeInfo || uniforms.blurDistance.mapComputeInfo) return null;
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const dpr = renderer?.getPixelRatio?.() ?? 1;
+		const blur = createVariableGaussianBlurCompute(childTexture, Math.round(dimensions.width * dpr), Math.round(dimensions.height * dpr), onCleanup, HALF_KERNEL);
+		const { computeNodes: blurNodes, outputTexture, blurMapWriteNode, computeWidth, computeHeight } = blur;
+		const heightU = uniform(.5);
+		const blurAmountU = uniform(1);
+		const blurDistanceU = uniform(.5);
+		const cw = uint(computeWidth);
+		const ch = uint(computeHeight);
+		function readScalar(entry) {
+			return entry.getCpuValue?.() ?? (typeof entry.uniform.value === "number" ? entry.uniform.value : null);
+		}
+		function updateUniforms() {
+			const h = readScalar(uniforms.height);
+			if (h !== null) heightU.value = h;
+			const b = readScalar(uniforms.blur);
+			if (b !== null) blurAmountU.value = b;
+			const bd = readScalar(uniforms.blurDistance);
+			if (bd !== null) blurDistanceU.value = Math.max(.01, bd);
+		}
+		const fillBlurMap = Fn(() => {
+			const idx = instanceIndex;
+			const cx = idx.mod(cw);
+			const cy = idx.div(cw);
+			If(cy.lessThan(ch), () => {
+				const v = cy.toFloat().add(float(.5)).div(float(computeHeight));
+				const distBelowAtOutput = heightU.sub(v).max(float(0));
+				const ramp = smoothstep(float(0), blurDistanceU, distBelowAtOutput);
+				const radius = blurAmountU.mul(ramp).mul(float(BLUR_TO_RADIUS_PX));
+				textureStore(blurMapWriteNode, uvec2(cx, cy), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+			});
+		})().compute(computeWidth * computeHeight, [256]);
+		onResize(({ width, height }) => {
+			blur.setInputDimensions(Math.round(width * dpr), Math.round(height * dpr));
+		});
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				updateUniforms();
+				return [fillBlurMap, ...blurNodes];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture && computeOutputs?.childTexture) {
+			const sharp = computeOutputs.childTexture;
+			const blurred = texture(computeOutputs.blurredTexture);
+			return Fn(() => {
+				const floorY = uniforms.height.uniform;
+				const uv$1 = screenUV;
+				const distBelow = uv$1.y.sub(floorY).max(float(0));
+				const originalSample = sharp.sample(uv$1);
+				const reflectedUV = vec2(uv$1.x, floorY.mul(2).sub(uv$1.y));
+				const reflSample = applyEdgeHandling(reflectedUV, blurred.sample(reflectedUV), blurred, uniforms.edges.uniform.value);
+				const distanceMax = uniforms.distance.uniform.max(float(.001));
+				const fadeWidth = distanceMax.mul(uniforms.falloff.uniform).max(float(1e-4));
+				const fadeStart = distanceMax.sub(fadeWidth);
+				const visibility = float(1).sub(smoothstep(fadeStart, distanceMax, distBelow));
+				const effReflA = reflSample.a.mul(visibility);
+				const reflPremultRgb = reflSample.rgb.mul(visibility);
+				const propsPin = uniforms.height.uniform.mul(float(0)).add(uniforms.blur.uniform.mul(float(0))).add(uniforms.blurDistance.uniform.mul(float(0)));
+				const oneMinusReflA = effReflA.oneMinus();
+				return unpremultiplyAlpha(mix(originalSample, vec4(reflPremultRgb.add(originalSample.rgb.mul(oneMinusReflA)).add(propsPin), effReflA.add(originalSample.a.mul(oneMinusReflA))), step(floorY, uv$1.y)));
+			})();
+		}
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const floorY = uniforms.height.uniform;
+			const uv$1 = screenUV;
+			const aspect = viewportSize.x.div(viewportSize.y);
+			const distBelow = uv$1.y.sub(floorY).max(float(0));
+			const originalSample = childTexture.sample(uv$1);
+			const reflectedUV = vec2(uv$1.x, floorY.mul(2).sub(uv$1.y));
+			const clampedBlurDistance = uniforms.blurDistance.uniform.max(float(.01));
+			const blurRamp = smoothstep(float(0), clampedBlurDistance, distBelow);
+			const blurRadius = uniforms.blur.uniform.mul(blurRamp).mul(.02);
+			const blurredColor = vec4(0).toVar();
+			for (let i = 0; i < POISSON_DISK.length; i++) {
+				const [ox, oy] = POISSON_DISK[i];
+				const offset = vec2(float(ox).mul(blurRadius).div(aspect), float(oy).mul(blurRadius));
+				const sampleUV = reflectedUV.add(offset);
+				const edgeHandled = applyEdgeHandling(sampleUV, childTexture.sample(sampleUV), childTexture, uniforms.edges.uniform.value);
+				blurredColor.assign(blurredColor.add(edgeHandled.mul(float(POISSON_WEIGHT))));
+			}
+			const distanceMax = uniforms.distance.uniform.max(float(.001));
+			const fadeWidth = distanceMax.mul(uniforms.falloff.uniform).max(float(1e-4));
+			const fadeStart = distanceMax.sub(fadeWidth);
+			const visibility = float(1).sub(smoothstep(fadeStart, distanceMax, distBelow));
+			const effReflA = blurredColor.a.mul(visibility);
+			const reflPremultRgb = blurredColor.rgb.mul(visibility);
+			const oneMinusReflA = effReflA.oneMinus();
+			return unpremultiplyAlpha(mix(originalSample, vec4(reflPremultRgb.add(originalSample.rgb.mul(oneMinusReflA)), effReflA.add(originalSample.a.mul(oneMinusReflA))), step(floorY, uv$1.y)));
+		})();
+	}
+};
+var ReflectivePlane_default = componentDefinition;
+export { componentDefinition as n, ReflectivePlane_default as t };

package/dist/core/{VideoTexture-D9XxE1Hw.js → VideoTexture-ClutlOqj.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-BamVDhaZ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-NUM-x2tw.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{WebcamTexture-9Td8qQWm.js → WebcamTexture-D4e06ajM.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-BamVDhaZ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-NUM-x2tw.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/index.js

@@ -42,7 +42,7 @@ import "./Ellipse-sWhNvW9-.js";
 import "./Emboss-DGaubb9x.js";
 import "./FallingLines-DqIZ8wTH.js";
 import "./FilmGrain-Dbw02Jz9.js";
-import "./FloatingParticles-DKoG78j0.js";
+import "./FloatingParticles-LMsFTJKp.js";
 import "./Flower-BbRNrXIa.js";
 import "./FlowField-D3CAHBBG.js";
 import "./FlowingGradient-BRQ_K-k3.js";
@@ -83,46 +83,47 @@ import "./Posterize-DNxTRgvF.js";
 import "./ProgressiveBlur-BJwJ5mE0.js";
 import "./RadialGradient-CQIctl__.js";
 import "./RectangularCoordinates-F2VzXmal.js";
-import "./Ring-CtnDtTY8.js";
-import "./Ripples-B4H0VoZb.js";
-import "./RoundedRect-tnt7Jr5b.js";
-import "./Saturation-6FlxHXSi.js";
-import "./Sharpness-C4cJlBuh.js";
-import "./Shatter-CnkycTRD.js";
-import "./SimplexNoise-BnRaoxON.js";
-import "./SineWave-CZ4Fanvr.js";
-import "./Smoke-CXPjGG-b.js";
-import "./SmokeFill-DzEtYeKN.js";
-import "./Solarize-CynVlxjT.js";
-import "./SolidColor-dCAOGC_P.js";
-import "./Spherize-C77QGVWj.js";
-import "./Spiral-eN65wa6O.js";
-import "./Star-0Flymgm9.js";
-import "./Strands-DnWJDGiO.js";
-import "./Stretch-B5XGF1bF.js";
-import "./Stripes-CNXJpFyr.js";
-import "./StudioBackground-DtiE2mCf.js";
-import "./SunBurst-D9X1-buZ.js";
-import "./Swirl-BV6pN94G.js";
-import "./TiltShift-r4qzPb2k.js";
-import "./Tint-CJ8FQdzA.js";
-import "./Trapezoid-JmybJMUr.js";
-import "./Tritone-D_QvxjGc.js";
-import "./Truchet-BJeZS_JQ.js";
-import "./Twirl-8ayqS0n8.js";
-import "./Vesica-D7iqgpJg.js";
-import "./VHS-Gbec95K_.js";
-import "./Vibrance-COKHmh8r.js";
-import "./browser-BamVDhaZ.js";
-import "./VideoTexture-D9XxE1Hw.js";
-import "./Vignette-Y_2yono-.js";
-import "./Voronoi-DQ_f6k5D.js";
-import "./WaveDistortion-R5FfwKQN.js";
-import "./Weave-DJ4s3Gwc.js";
-import "./WebcamTexture-9Td8qQWm.js";
-import "./WorleyNoise-CWytDfGH.js";
-import "./ZoomBlur-DWFQVFMK.js";
-import { t as getAllShaders } from "./shaderRegistry-BoqhBfun.js";
+import "./ReflectivePlane-UIT4xlmn.js";
+import "./Ring-UT__kmzY.js";
+import "./Ripples-CWVLSUP0.js";
+import "./RoundedRect-BPWHTT1j.js";
+import "./Saturation-DFOp2yD9.js";
+import "./Sharpness-C-IEswPL.js";
+import "./Shatter-CUYQp-qy.js";
+import "./SimplexNoise-LAxWw8fJ.js";
+import "./SineWave-CEQWxC9Q.js";
+import "./Smoke-DO4yylWk.js";
+import "./SmokeFill-Dm0sZS5F.js";
+import "./Solarize-mE7LU1li.js";
+import "./SolidColor-BljkSdvg.js";
+import "./Spherize-DARagREe.js";
+import "./Spiral-CumsIpkp.js";
+import "./Star-8fAlzR9L.js";
+import "./Strands-BB4RIsFz.js";
+import "./Stretch-3S2atBkJ.js";
+import "./Stripes-BGFVSZIt.js";
+import "./StudioBackground-BtJ6b1Ki.js";
+import "./SunBurst-BJRFFYhs.js";
+import "./Swirl-KA9cEnLI.js";
+import "./TiltShift-DtQ3dRL-.js";
+import "./Tint-W_EvzN1-.js";
+import "./Trapezoid-cQzS6-bh.js";
+import "./Tritone-B3hI2nAi.js";
+import "./Truchet-s9PmowCP.js";
+import "./Twirl-UDDXGkFl.js";
+import "./Vesica-ChQBYWuw.js";
+import "./VHS-DW1H7Wuy.js";
+import "./Vibrance-DUj7hwzE.js";
+import "./browser-NUM-x2tw.js";
+import "./VideoTexture-ClutlOqj.js";
+import "./Vignette-F9yxi-UM.js";
+import "./Voronoi-D8HHP_WR.js";
+import "./WaveDistortion-CDIc5Uyk.js";
+import "./Weave-ou5shgl3.js";
+import "./WebcamTexture-D4e06ajM.js";
+import "./WorleyNoise-Uf6IPm7A.js";
+import "./ZoomBlur-DJ-RNKHM.js";
+import { t as getAllShaders } from "./shaderRegistry-DZDkRCt8.js";
 import { Material, Mesh, MeshBasicNodeMaterial, OrthographicCamera, PlaneGeometry, SRGBColorSpace, Scene, Vector2, WebGPURenderer } from "three/webgpu";
 import { WebGLRenderer } from "three";
 import { PI, abs, add, atan, clamp, convertToTexture, cos, div, dot, float, fract, max, min, mix, mul, pow, screenUV, sign, sin, smoothstep, sqrt, step, sub, time, uniform, uv, vec2, vec3, vec4 } from "three/tsl";

package/dist/core/registry.js

@@ -42,7 +42,7 @@ import "./Ellipse-sWhNvW9-.js";
 import "./Emboss-DGaubb9x.js";
 import "./FallingLines-DqIZ8wTH.js";
 import "./FilmGrain-Dbw02Jz9.js";
-import "./FloatingParticles-DKoG78j0.js";
+import "./FloatingParticles-LMsFTJKp.js";
 import "./Flower-BbRNrXIa.js";
 import "./FlowField-D3CAHBBG.js";
 import "./FlowingGradient-BRQ_K-k3.js";
@@ -83,44 +83,45 @@ import "./Posterize-DNxTRgvF.js";
 import "./ProgressiveBlur-BJwJ5mE0.js";
 import "./RadialGradient-CQIctl__.js";
 import "./RectangularCoordinates-F2VzXmal.js";
-import "./Ring-CtnDtTY8.js";
-import "./Ripples-B4H0VoZb.js";
-import "./RoundedRect-tnt7Jr5b.js";
-import "./Saturation-6FlxHXSi.js";
-import "./Sharpness-C4cJlBuh.js";
-import "./Shatter-CnkycTRD.js";
-import "./SimplexNoise-BnRaoxON.js";
-import "./SineWave-CZ4Fanvr.js";
-import "./Smoke-CXPjGG-b.js";
-import "./SmokeFill-DzEtYeKN.js";
-import "./Solarize-CynVlxjT.js";
-import "./SolidColor-dCAOGC_P.js";
-import "./Spherize-C77QGVWj.js";
-import "./Spiral-eN65wa6O.js";
-import "./Star-0Flymgm9.js";
-import "./Strands-DnWJDGiO.js";
-import "./Stretch-B5XGF1bF.js";
-import "./Stripes-CNXJpFyr.js";
-import "./StudioBackground-DtiE2mCf.js";
-import "./SunBurst-D9X1-buZ.js";
-import "./Swirl-BV6pN94G.js";
-import "./TiltShift-r4qzPb2k.js";
-import "./Tint-CJ8FQdzA.js";
-import "./Trapezoid-JmybJMUr.js";
-import "./Tritone-D_QvxjGc.js";
-import "./Truchet-BJeZS_JQ.js";
-import "./Twirl-8ayqS0n8.js";
-import "./Vesica-D7iqgpJg.js";
-import "./VHS-Gbec95K_.js";
-import "./Vibrance-COKHmh8r.js";
-import "./browser-BamVDhaZ.js";
-import "./VideoTexture-D9XxE1Hw.js";
-import "./Vignette-Y_2yono-.js";
-import "./Voronoi-DQ_f6k5D.js";
-import "./WaveDistortion-R5FfwKQN.js";
-import "./Weave-DJ4s3Gwc.js";
-import "./WebcamTexture-9Td8qQWm.js";
-import "./WorleyNoise-CWytDfGH.js";
-import "./ZoomBlur-DWFQVFMK.js";
-import { a as shaderRegistry, i as getShadersByCategory, n as getShaderByName, r as getShaderCategories, t as getAllShaders } from "./shaderRegistry-BoqhBfun.js";
+import "./ReflectivePlane-UIT4xlmn.js";
+import "./Ring-UT__kmzY.js";
+import "./Ripples-CWVLSUP0.js";
+import "./RoundedRect-BPWHTT1j.js";
+import "./Saturation-DFOp2yD9.js";
+import "./Sharpness-C-IEswPL.js";
+import "./Shatter-CUYQp-qy.js";
+import "./SimplexNoise-LAxWw8fJ.js";
+import "./SineWave-CEQWxC9Q.js";
+import "./Smoke-DO4yylWk.js";
+import "./SmokeFill-Dm0sZS5F.js";
+import "./Solarize-mE7LU1li.js";
+import "./SolidColor-BljkSdvg.js";
+import "./Spherize-DARagREe.js";
+import "./Spiral-CumsIpkp.js";
+import "./Star-8fAlzR9L.js";
+import "./Strands-BB4RIsFz.js";
+import "./Stretch-3S2atBkJ.js";
+import "./Stripes-BGFVSZIt.js";
+import "./StudioBackground-BtJ6b1Ki.js";
+import "./SunBurst-BJRFFYhs.js";
+import "./Swirl-KA9cEnLI.js";
+import "./TiltShift-DtQ3dRL-.js";
+import "./Tint-W_EvzN1-.js";
+import "./Trapezoid-cQzS6-bh.js";
+import "./Tritone-B3hI2nAi.js";
+import "./Truchet-s9PmowCP.js";
+import "./Twirl-UDDXGkFl.js";
+import "./Vesica-ChQBYWuw.js";
+import "./VHS-DW1H7Wuy.js";
+import "./Vibrance-DUj7hwzE.js";
+import "./browser-NUM-x2tw.js";
+import "./VideoTexture-ClutlOqj.js";
+import "./Vignette-F9yxi-UM.js";
+import "./Voronoi-D8HHP_WR.js";
+import "./WaveDistortion-CDIc5Uyk.js";
+import "./Weave-ou5shgl3.js";
+import "./WebcamTexture-D4e06ajM.js";
+import "./WorleyNoise-Uf6IPm7A.js";
+import "./ZoomBlur-DJ-RNKHM.js";
+import { a as shaderRegistry, i as getShadersByCategory, n as getShaderByName, r as getShaderCategories, t as getAllShaders } from "./shaderRegistry-DZDkRCt8.js";
 export { getAllShaders, getShaderByName, getShaderCategories, getShadersByCategory, shaderRegistry };