shaders 2.5.108 → 2.5.110

package/dist/core/{Tint-DaTx2HII.js → Tint-DdvnpzEJ.js}

@@ -30,7 +30,9 @@ const componentDefinition = {
 		},
 		preserveLuminosity: {
 			default: true,
+			compileTime: true,
 			description: "Preserve original brightness",
+			transform: (v) => v ? 1 : 0,
 			ui: {
 				type: "checkbox",
 				label: "Preserve Luminosity",
@@ -45,14 +47,17 @@ const componentDefinition = {
 		}
 		const tintColor = uniforms.color.uniform;
 		const amount = uniforms.amount.uniform;
-		const preserveLum = uniforms.preserveLuminosity.uniform;
 		const rgb = vec3(childNode.r, childNode.g, childNode.b);
-		const luminanceWeights = vec3(.299, .587, .114);
-		const originalLum = dot(rgb, luminanceWeights);
 		const tinted = mix(rgb, tintColor.rgb, amount);
-		const tintedLum = dot(tinted, luminanceWeights);
-		const lumPreserved = tinted.mul(originalLum.div(max(tintedLum, 1e-4)));
-		return vec4(preserveLum.select(lumPreserved, tinted), childNode.a);
+		const preserveLum = uniforms.preserveLuminosity.uniform.value === 1;
+		let result;
+		if (preserveLum) {
+			const luminanceWeights = vec3(.299, .587, .114);
+			const originalLum = dot(rgb, luminanceWeights);
+			const tintedLum = dot(tinted, luminanceWeights);
+			result = tinted.mul(originalLum.div(max(tintedLum, 1e-4)));
+		} else result = tinted;
+		return vec4(result, childNode.a);
 	}
 };
 var Tint_default = componentDefinition;

package/dist/core/{Tritone-C9Yx69Tw.js → Tritone-Ckb6hTkI.js}

@@ -1,12 +1,10 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { convertToTexture, dot, screenUV, smoothstep, vec3, vec4 } from "three/tsl";
+import { dot, smoothstep, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Tritone",
 	category: "Adjustments",
 	description: "Map colors to three tones: shadows, midtones, highlights",
-	requiresRTT: true,
 	requiresChild: true,
 	props: {
 		colorA: {
@@ -64,19 +62,14 @@ const componentDefinition = {
 			}
 		}
 	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+	fragmentNode: ({ uniforms, childNode }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const inputColor = unpremultiplyAlpha(childTexture.sample(screenUV));
-		const luminance = dot(inputColor.rgb, vec3(.299, .587, .114));
+		const luminance = dot(vec3(childNode.r, childNode.g, childNode.b), vec3(.299, .587, .114));
 		const shadowToMid = smoothstep(uniforms.blendMid.uniform.sub(.25), uniforms.blendMid.uniform, luminance);
 		const csMode = uniforms.colorSpace.uniform.value;
 		const lowerBlend = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, shadowToMid, csMode);
 		const midToHighlight = smoothstep(uniforms.blendMid.uniform, uniforms.blendMid.uniform.add(.25), luminance);
-		return vec4(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, csMode), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), csMode).rgb, inputColor.a);
+		return vec4(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, csMode), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), csMode).rgb, childNode.a);
 	}
 };
 var Tritone_default = componentDefinition;

package/dist/core/{VideoTexture-SWLe5c3m.js → VideoTexture-BMSdfLf_.js}

@@ -1,6 +1,6 @@
 import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
-import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
+import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "VideoTexture",
 	category: "Textures",
@@ -27,6 +27,7 @@ const componentDefinition = {
 					"none": 4
 				}[value] ?? 0;
 			},
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -175,22 +176,34 @@ const componentDefinition = {
 		});
 		const uv$1 = baseUV;
 		const viewportAspect = viewportSize.x.div(viewportSize.y);
-		const objectFitMode = uniforms.objectFit.uniform;
-		const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
-		const coverUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
-		const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
-		const containUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
-		const fillUVScale = vec2(1, 1);
-		const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
-		const scaleDownUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
-		const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
-		const noneUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
-		const isCover = step(objectFitMode, float(.5));
-		const isContain = step(float(.5), objectFitMode).mul(step(objectFitMode, float(1.5)));
-		const isFill = step(float(1.5), objectFitMode).mul(step(objectFitMode, float(2.5)));
-		const isScaleDown = step(float(2.5), objectFitMode).mul(step(objectFitMode, float(3.5)));
-		const isNone = step(float(3.5), objectFitMode);
-		const uvScale = vec2(0).add(coverUVScale.mul(isCover)).add(containUVScale.mul(isContain)).add(fillUVScale.mul(isFill)).add(scaleDownUVScale.mul(isScaleDown)).add(noneUVScale.mul(isNone));
+		const objectFitMode = uniforms.objectFit.uniform.value;
+		let uvScale;
+		switch (objectFitMode) {
+			case 1: {
+				const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
+				break;
+			}
+			case 2:
+				uvScale = vec2(1, 1);
+				break;
+			case 3: {
+				const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+				break;
+			}
+			case 4: {
+				const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+				break;
+			}
+			case 0:
+			default: {
+				const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+				break;
+			}
+		}
 		const adjustedUV = uv$1.sub(vec2(.5)).div(uvScale).add(vec2(.5));
 		const finalUV = vec2(adjustedUV.x, float(1).sub(adjustedUV.y));
 		const sampledColor = textureNode.sample(finalUV);

package/dist/core/{WebcamTexture-cXPyEumA.js → WebcamTexture-Ds9IrtRn.js}

@@ -1,6 +1,6 @@
 import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
-import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
+import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "WebcamTexture",
 	category: "Textures",
@@ -18,6 +18,7 @@ const componentDefinition = {
 					"none": 4
 				}[value] ?? 0;
 			},
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -159,22 +160,34 @@ const componentDefinition = {
 		});
 		const uv$1 = baseUV;
 		const viewportAspect = viewportSize.x.div(viewportSize.y);
-		const objectFitMode = uniforms.objectFit.uniform;
-		const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
-		const coverUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
-		const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
-		const containUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
-		const fillUVScale = vec2(1, 1);
-		const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
-		const scaleDownUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
-		const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
-		const noneUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
-		const isCover = step(objectFitMode, float(.5));
-		const isContain = step(float(.5), objectFitMode).mul(step(objectFitMode, float(1.5)));
-		const isFill = step(float(1.5), objectFitMode).mul(step(objectFitMode, float(2.5)));
-		const isScaleDown = step(float(2.5), objectFitMode).mul(step(objectFitMode, float(3.5)));
-		const isNone = step(float(3.5), objectFitMode);
-		const uvScale = vec2(0).add(coverUVScale.mul(isCover)).add(containUVScale.mul(isContain)).add(fillUVScale.mul(isFill)).add(scaleDownUVScale.mul(isScaleDown)).add(noneUVScale.mul(isNone));
+		const objectFitMode = uniforms.objectFit.uniform.value;
+		let uvScale;
+		switch (objectFitMode) {
+			case 1: {
+				const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
+				break;
+			}
+			case 2:
+				uvScale = vec2(1, 1);
+				break;
+			case 3: {
+				const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+				break;
+			}
+			case 4: {
+				const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+				break;
+			}
+			case 0:
+			default: {
+				const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+				break;
+			}
+		}
 		const adjustedUV = uv$1.sub(vec2(.5)).div(uvScale).add(vec2(.5));
 		const mirrorMode = uniforms.mirror.uniform;
 		const finalUV = vec2(select(mirrorMode, float(1).sub(adjustedUV.x), adjustedUV.x), float(1).sub(adjustedUV.y));

package/dist/core/computeBlur-DCRhuYEi.js

@@ -0,0 +1,209 @@
+import { StorageTexture } from "three/webgpu";
+import { FloatType } from "three";
+import { Fn, If, float, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniform, uniformArray, uvec2, vec4 } from "three/tsl";
+var DEFAULT_HALF_KERNEL = 24;
+const DEFAULT_COMPUTE_WIDTH = 1024;
+const DEFAULT_COMPUTE_HEIGHT = 640;
+function buildFixedWeights(halfKernel) {
+	const sigma = halfKernel / 3;
+	const size = halfKernel * 2 + 1;
+	const weights = [];
+	let sum = 0;
+	for (let i = -halfKernel; i <= halfKernel; i++) {
+		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+		weights.push(w);
+		sum += w;
+	}
+	for (let i = 0; i < size; i++) weights[i] /= sum;
+	return weights;
+}
+var PASSTHROUGH_THRESHOLD = .5;
+function createGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+	const KERNEL_SIZE = halfKernel * 2 + 1;
+	const HALF_KERNEL = halfKernel;
+	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(computeWidth, computeHeight);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weightsH = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	const weightsV = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	let lastRadius = -1;
+	const inputWidthU = uniform(inputWidth);
+	const inputHeightU = uniform(inputHeight);
+	let scaleY = inputHeight / computeHeight;
+	const cw = uint(computeWidth);
+	const ch = uint(computeHeight);
+	const computeHm1 = int(computeHeight - 1);
+	const inputWm1 = int(inputWidthU.sub(1));
+	const inputHm1 = int(inputHeightU.sub(1));
+	const horizontalPass = Fn(() => {
+		const idx = instanceIndex;
+		const cx = idx.mod(cw);
+		const cy = idx.div(cw);
+		If(cy.lessThan(ch), () => {
+			const sum = vec4(0).toVar();
+			const inputCx = cx.toFloat().add(float(.5)).mul(inputWidthU).div(float(computeWidth)).sub(float(.5));
+			const inputCy = cy.toFloat().add(float(.5)).mul(inputHeightU).div(float(computeHeight)).sub(float(.5));
+			const inputCxI = inputCx.round().toInt();
+			const inputCyI = inputCy.round().toInt().clamp(int(0), inputHm1);
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(inputTexture, uvec2(inputCxI.add(int(i)).clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weightsH.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(intermediateWriteNode, uvec2(cx, cy), sum).toWriteOnly();
+		});
+	})().compute(computeWidth * computeHeight, [256]);
+	const verticalPass = Fn(() => {
+		const idx = instanceIndex;
+		const cx = idx.mod(cw);
+		const cy = idx.div(cw);
+		If(cy.lessThan(ch), () => {
+			const sum = vec4(0).toVar();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(intermediateReadNode, uvec2(cx, cy.toInt().add(int(i)).clamp(int(0), computeHm1).toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weightsV.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(outputNode, uvec2(cx, cy), sum).toWriteOnly();
+		});
+	})().compute(computeWidth * computeHeight, [256]);
+	function updateWeights() {
+		const pixelRadius = lastRadius < 0 ? 4 : lastRadius;
+		const sigmaH = Math.max(pixelRadius * .5, .001);
+		const sigmaV = Math.max(sigmaH / scaleY, .001);
+		const newH = new Array(KERNEL_SIZE);
+		const newV = new Array(KERNEL_SIZE);
+		let totalH = 0, totalV = 0;
+		for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+			const h = Math.exp(-(i * i) / (2 * sigmaH * sigmaH));
+			const v = Math.exp(-(i * i) / (2 * sigmaV * sigmaV));
+			newH[i + HALF_KERNEL] = h;
+			newV[i + HALF_KERNEL] = v;
+			totalH += h;
+			totalV += v;
+		}
+		for (let i = 0; i < KERNEL_SIZE; i++) {
+			newH[i] /= totalH;
+			newV[i] /= totalV;
+		}
+		weightsH.array = newH;
+		weightsV.array = newV;
+	}
+	function updateRadius(pixelRadius) {
+		if (Math.abs(pixelRadius - lastRadius) < .01) return;
+		lastRadius = pixelRadius;
+		updateWeights();
+	}
+	updateRadius(4);
+	return {
+		computeNodes: [horizontalPass, verticalPass],
+		outputTexture: outputTex,
+		updateRadius,
+		computeWidth,
+		computeHeight,
+		setInputDimensions: (newW, newH) => {
+			inputWidthU.value = newW;
+			inputHeightU.value = newH;
+			const newScaleY = newH / computeHeight;
+			if (Math.abs(newScaleY - scaleY) > .001) {
+				scaleY = newScaleY;
+				updateWeights();
+			}
+		}
+	};
+}
+function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+	const HALF_KERNEL = halfKernel;
+	const FIXED_WEIGHTS = buildFixedWeights(HALF_KERNEL);
+	const blurMapTex = new StorageTexture(computeWidth, computeHeight);
+	blurMapTex.type = FloatType;
+	const blurMapWriteNode = storageTexture(blurMapTex);
+	const blurMapReadNode = storageTexture(blurMapTex).toReadOnly();
+	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(computeWidth, computeHeight);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		blurMapTex.dispose();
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weights = uniformArray(FIXED_WEIGHTS, "float");
+	const inputWidthU = uniform(inputWidth);
+	const inputHeightU = uniform(inputHeight);
+	const scaleYU = uniform(inputHeight / computeHeight);
+	const cw = uint(computeWidth);
+	const ch = uint(computeHeight);
+	const computeHm1 = int(computeHeight - 1);
+	const inputWm1 = int(inputWidthU.sub(1));
+	const inputHm1 = int(inputHeightU.sub(1));
+	const invHalf = float(1 / HALF_KERNEL);
+	const passthroughThreshold = float(PASSTHROUGH_THRESHOLD);
+	return {
+		computeNodes: [Fn(() => {
+			const idx = instanceIndex;
+			const cx = idx.mod(cw);
+			const cy = idx.div(cw);
+			If(cy.lessThan(ch), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(cx, cy), int(0)).r;
+				const inputCx = cx.toFloat().add(float(.5)).mul(inputWidthU).div(float(computeWidth)).sub(float(.5));
+				const inputCy = cy.toFloat().add(float(.5)).mul(inputHeightU).div(float(computeHeight)).sub(float(.5));
+				const inputCxF = inputCx;
+				const inputCyI = inputCy.round().toInt().clamp(int(0), inputHm1);
+				If(blurRadius.lessThan(passthroughThreshold), () => {
+					const texel = textureLoad(inputTexture, uvec2(inputCxF.round().toInt().clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+					textureStore(intermediateWriteNode, uvec2(cx, cy), texel).toWriteOnly();
+				}).Else(() => {
+					const sum = vec4(0).toVar();
+					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+						const offset = float(i).mul(invHalf).mul(blurRadius);
+						const texel = textureLoad(inputTexture, uvec2(inputCxF.add(offset).round().toInt().clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+					}
+					textureStore(intermediateWriteNode, uvec2(cx, cy), sum).toWriteOnly();
+				});
+			});
+		})().compute(computeWidth * computeHeight, [256]), Fn(() => {
+			const idx = instanceIndex;
+			const cx = idx.mod(cw);
+			const cy = idx.div(cw);
+			If(cy.lessThan(ch), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(cx, cy), int(0)).r;
+				If(blurRadius.lessThan(passthroughThreshold), () => {
+					const texel = textureLoad(intermediateReadNode, uvec2(cx, cy), int(0));
+					textureStore(outputNode, uvec2(cx, cy), texel).toWriteOnly();
+				}).Else(() => {
+					const sum = vec4(0).toVar();
+					const yi = cy.toInt();
+					const radiusComputeY = blurRadius.div(scaleYU);
+					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+						const offset = float(i).mul(invHalf).mul(radiusComputeY);
+						const texel = textureLoad(intermediateReadNode, uvec2(cx, yi.add(offset.round().toInt()).clamp(int(0), computeHm1).toUint()), int(0));
+						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+					}
+					textureStore(outputNode, uvec2(cx, cy), sum).toWriteOnly();
+				});
+			});
+		})().compute(computeWidth * computeHeight, [256])],
+		outputTexture: outputTex,
+		blurMapTexture: blurMapTex,
+		blurMapWriteNode,
+		computeWidth,
+		computeHeight,
+		setInputDimensions: (newW, newH) => {
+			inputWidthU.value = newW;
+			inputHeightU.value = newH;
+			scaleYU.value = newH / computeHeight;
+		}
+	};
+}
+export { createVariableGaussianBlurCompute as i, DEFAULT_COMPUTE_WIDTH as n, createGaussianBlurCompute as r, DEFAULT_COMPUTE_HEIGHT as t };

package/dist/core/index.js

@@ -5,64 +5,64 @@ import "./AngularBlur-BgZWbEjj.js";
 import "./Ascii-BwSMmD6Z.js";
 import "./colorMixing-BPpDnR5I.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
-import "./Aurora-BPHeGEZ_.js";
+import "./Aurora-KcUDr49P.js";
 import "./Beam-CAnoOWgt.js";
 import "./Blob-CuRSRXmA.js";
-import "./computeBlur-DeXZ99YL.js";
-import "./Blur-Cxx3ZuHi.js";
+import "./computeBlur-DCRhuYEi.js";
+import "./Blur-DG7lJKPo.js";
 import "./BrightnessContrast-CJTOpQCn.js";
 import "./Bulge-Chpbxxzj.js";
-import "./ChannelBlur-Cth0biwG.js";
+import "./ChannelBlur-BhcCkwcO.js";
 import "./Checkerboard-ucave4-a.js";
 import "./ChromaFlow-DxQaUqPL.js";
 import "./ChromaticAberration-DsMj-vBw.js";
 import "./Circle-QgCuVo44.js";
 import "./ConcentricSpin-Crfxti93.js";
 import "./ConicGradient-CQAPYlQg.js";
-import "./ContourLines-KTHC32hd.js";
+import "./ContourLines-tDBvQOvb.js";
 import "./sdf-DyC2H_qS.js";
 import "./Crescent-BkRt-XWy.js";
 import "./Cross-kkY7feuC.js";
 import "./CRTScreen-CTwXU-NX.js";
 import "./Crystal-COGiLVvV.js";
 import "./CursorRipples-D-cfjHY5.js";
-import "./CursorTrail-R4IBB4eu.js";
+import "./CursorTrail-CgRMXbTG.js";
 import "./DiamondGradient-BC3ugP8a.js";
 import "./DiffuseBlur-eyM1v3ad.js";
 import "./Dither-CDfDotR6.js";
 import "./DOMTexture-D-RkeyMs.js";
 import "./DotGrid-T9YbgC3V.js";
-import "./DropShadow-jMhnYPXZ.js";
-import "./Duotone-Bl02WcA2.js";
+import "./DropShadow-B7FzTp4H.js";
+import "./Duotone-CqQ0NMxS.js";
 import "./Ellipse-CXxGqTYI.js";
 import "./Emboss-LU-6cckT.js";
 import "./FallingLines-CArEXajJ.js";
 import "./FilmGrain-DSJiMtEp.js";
-import "./FloatingParticles-BtwGRl_d.js";
+import "./FloatingParticles-DpYA0_TE.js";
 import "./Flower-MAwlZEv8.js";
 import "./FlowField-RyqiRxyI.js";
 import "./FlowingGradient-C0Zoyfd6.js";
 import "./Fog-BeKcPcTq.js";
-import "./Form3D-DaPbLGUi.js";
-import "./Glass-TRSXbuE6.js";
+import "./Form3D-Bufw6tZb.js";
+import "./Glass-Bz9IKI2q.js";
 import "./GlassTiles-Dgh6nOaE.js";
 import "./Glitch-BsbzLahF.js";
-import "./Glow-8bKkyehK.js";
+import "./Glow-CUv1yHLZ.js";
 import "./Godrays-D1LINbut.js";
 import "./Grayscale-Ri-695Uh.js";
 import "./Grid-BYSsAIEv.js";
-import "./GridDistortion-CpSiGEGV.js";
+import "./GridDistortion-SRyevgsp.js";
 import "./Group-CkhjTW59.js";
 import "./Halftone-BUCDTTAU.js";
 import "./HexGrid-BUiDrehv.js";
-import "./HueShift-BtGVMu7q.js";
-import "./ImageTexture-CrX_9-f0.js";
+import "./HueShift-ctEX5vfo.js";
+import "./ImageTexture-uxj4LpF7.js";
 import "./Invert-azYrcDMi.js";
 import "./Kaleidoscope-CFWtKisp.js";
 import "./LensFlare-ttrXgfea.js";
 import "./LinearBlur-By2aD8OO.js";
 import "./LinearGradient-CM02z32l.js";
-import "./Liquify-D9YIfbfB.js";
+import "./Liquify-p-_qcb1f.js";
 import "./Mirror-B7XmfGdw.js";
 import "./MultiPointGradient-8zGSIM4U.js";
 import "./Neon-CMmGJzPy.js";
@@ -73,16 +73,16 @@ import "./Plasma-DGCw0cd7.js";
 import "./PolarCoordinates-CMYCFT4S.js";
 import "./Polygon-CsCOt5YE.js";
 import "./Posterize-Blv9pzPT.js";
-import "./ProgressiveBlur-B_z0pZ1V.js";
+import "./ProgressiveBlur-NbvxFfRa.js";
 import "./RadialGradient-De0gtdh3.js";
 import "./RectangularCoordinates-8Sa2GaDy.js";
 import "./Ring-kHH-DIDQ.js";
 import "./Ripples-Bf6Zwg6X.js";
 import "./RoundedRect-B0sWh2BN.js";
-import "./Saturation-CB19kOXg.js";
-import "./Sharpness-CQOboeqy.js";
-import "./Shatter-SHNbU2KC.js";
-import "./SimplexNoise-BcSgytjc.js";
+import "./Saturation-DCFAIUvZ.js";
+import "./Sharpness-DSpEoCSL.js";
+import "./Shatter-ByKkCYTR.js";
+import "./SimplexNoise-CMuU8n27.js";
 import "./SineWave-VTNDSK_g.js";
 import "./Smoke-9MJIAKq7.js";
 import "./SmokeFill-qV2iRIts.js";
@@ -95,25 +95,25 @@ import "./Strands-DOthZNHt.js";
 import "./Stretch--GV6hbru.js";
 import "./Stripes-CFCXw1_N.js";
 import "./StudioBackground-DJr-cxOL.js";
-import "./Swirl-By5FadQK.js";
-import "./TiltShift-GqDjHvmk.js";
-import "./Tint-DaTx2HII.js";
+import "./Swirl-B_KxdaX2.js";
+import "./TiltShift-BSAyR0Me.js";
+import "./Tint-DdvnpzEJ.js";
 import "./Trapezoid-Co0sIA73.js";
-import "./Tritone-C9Yx69Tw.js";
+import "./Tritone-Ckb6hTkI.js";
 import "./Truchet-CkFSkniR.js";
 import "./Twirl-v8pLqUTN.js";
 import "./Vesica-CxP7UD0a.js";
 import "./VHS-mKd1QBBj.js";
 import "./Vibrance-WR5yQv_9.js";
 import "./browser-D8zonASQ.js";
-import "./VideoTexture-SWLe5c3m.js";
+import "./VideoTexture-BMSdfLf_.js";
 import "./Vignette-hAIKTi35.js";
 import "./Voronoi-DOGmwUSK.js";
 import "./WaveDistortion-BGdgj3Iz.js";
 import "./Weave-CIP_EUPa.js";
-import "./WebcamTexture-cXPyEumA.js";
+import "./WebcamTexture-Ds9IrtRn.js";
 import "./ZoomBlur-BuIVpHGG.js";
-import { t as getAllShaders } from "./shaderRegistry-fwljIrjT.js";
+import { t as getAllShaders } from "./shaderRegistry-DFzzFEKX.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";
@@ -775,11 +775,6 @@ function shaderRenderer() {
 	let previousTextures = /* @__PURE__ */ new Set();
 	let pendingResize = null;
 	let isResizeScheduled = false;
-	const COMPUTE_REBUILD_DEBOUNCE_MS = 200;
-	const COMPUTE_REBUILD_SKIP_TOLERANCE = .02;
-	let computeRebuildTimeout = null;
-	let lastComputeRebuildWidth = 0;
-	let lastComputeRebuildHeight = 0;
 	const updateRendererDimensions = (width, height) => {
 		if (width <= 0 || height <= 0) return;
 		if (width === currentWidth && height === currentHeight) return;
@@ -798,8 +793,6 @@ function shaderRenderer() {
 				currentHeight = height$1;
 				if (!hasInitialDimensions) {
 					hasInitialDimensions = true;
-					lastComputeRebuildWidth = width$1;
-					lastComputeRebuildHeight = height$1;
 					if (nodeRegistry.nodes.size > 0 && materialUpdateBatchRAF === null) materialUpdateBatchRAF = requestAnimationFrame(() => {
 						materialUpdateBatchRAF = null;
 						updateMaterial();
@@ -828,27 +821,6 @@ function shaderRenderer() {
 						}
 					});
 				});
-				let hasComputeNodes = false;
-				for (const ni of nodeRegistry.nodes.values()) if (ni.computeGetNodes) {
-					hasComputeNodes = true;
-					break;
-				}
-				if (hasComputeNodes) {
-					const lastW = lastComputeRebuildWidth;
-					const lastH = lastComputeRebuildHeight;
-					const widthDelta = lastW > 0 ? Math.abs(width$1 - lastW) / lastW : 1;
-					const heightDelta = lastH > 0 ? Math.abs(height$1 - lastH) / lastH : 1;
-					if (!(widthDelta < COMPUTE_REBUILD_SKIP_TOLERANCE && heightDelta < COMPUTE_REBUILD_SKIP_TOLERANCE)) {
-						if (computeRebuildTimeout !== null) clearTimeout(computeRebuildTimeout);
-						computeRebuildTimeout = setTimeout(() => {
-							computeRebuildTimeout = null;
-							if (materialUpdateBatchRAF === null) materialUpdateBatchRAF = requestAnimationFrame(() => {
-								materialUpdateBatchRAF = null;
-								updateMaterial();
-							});
-						}, COMPUTE_REBUILD_DEBOUNCE_MS);
-					}
-				}
 				lastRenderTime = 0;
 				renderFrame();
 			});
@@ -943,8 +915,6 @@ function shaderRenderer() {
 					material = newMaterial;
 					needsMaterialRefresh = false;
 					lastComposedNodes = currentComposedNodes;
-					lastComputeRebuildWidth = currentWidth;
-					lastComputeRebuildHeight = currentHeight;
 					if (!hasEmittedReady && currentComposedNodes.size > 0) firstRenderPending = true;
 				}
 			}
@@ -2222,10 +2192,6 @@ function shaderRenderer() {
 	};
 	const cleanup = () => {
 		if (initializationAbortController) initializationAbortController.abort();
-		if (computeRebuildTimeout !== null) {
-			clearTimeout(computeRebuildTimeout);
-			computeRebuildTimeout = null;
-		}
 		if (resizeObserver) {
 			resizeObserver.disconnect();
 			resizeObserver = null;