shaders 2.5.93 → 2.5.95

package/dist/core/{ProgressiveBlur-BcHBSVDo.js → ProgressiveBlur-Dm530r0z.js}

@@ -1,6 +1,7 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { Fn, convertToTexture, cos, float, max, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
+import { n as createVariableGaussianBlurCompute } from "./computeBlur-B0KA4n89.js";
+import { Fn, If, convertToTexture, cos, float, instanceIndex, max, radians, screenUV, sin, smoothstep, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ProgressiveBlur",
 	category: "Blurs",
@@ -59,8 +60,64 @@ const componentDefinition = {
 			}
 		}
 	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms }) => {
+		if (!childNode) return null;
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const dpr = renderer?.getPixelRatio?.() ?? 1;
+		const texWidth = Math.round(dimensions.width * dpr);
+		const texHeight = Math.round(dimensions.height * dpr);
+		const { computeNodes: blurNodes, outputTexture, blurMapWriteNode } = createVariableGaussianBlurCompute(childTexture, texWidth, texHeight, onCleanup);
+		const angleU = uniform(0);
+		const centerXU = uniform(0);
+		const centerYU = uniform(.5);
+		const falloffU = uniform(1);
+		const maxRadiusU = uniform(18);
+		const aspectU = uniform(1);
+		const w = uint(texWidth);
+		const h = uint(texHeight);
+		const fillBlurMap = Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const u = x.toFloat().add(float(.5)).div(float(texWidth));
+				const v = y.toFloat().add(float(.5)).div(float(texHeight));
+				const angleRad = angleU.mul(float(Math.PI / 180));
+				const cosA = angleRad.cos();
+				const sinA = angleRad.sin();
+				const direction = vec2(cosA.div(aspectU), sinA);
+				const centerPos = vec2(centerXU, float(1).sub(centerYU));
+				const centeredUV = vec2(u, v).sub(centerPos);
+				const directionalDist = max(float(0), centeredUV.dot(direction));
+				const radius = smoothstep(float(0), falloffU, directionalDist).mul(maxRadiusU);
+				textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+			});
+		})().compute(texWidth * texHeight, [256]);
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				angleU.value = uniforms.angle.uniform.value;
+				centerXU.value = uniforms.center.uniform.value?.x ?? uniforms.center.uniform.x?.value ?? 0;
+				centerYU.value = uniforms.center.uniform.value?.y ?? uniforms.center.uniform.y?.value ?? .5;
+				falloffU.value = uniforms.falloff.uniform.value;
+				aspectU.value = dimensions.width / dimensions.height;
+				maxRadiusU.value = uniforms.intensity.uniform.value * .36;
+				return [fillBlurMap, ...blurNodes];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const sharp = computeOutputs.childTexture.sample(screenUV);
+			return unpremultiplyAlpha(vec4(texture(computeOutputs.blurredTexture).sample(screenUV).rgb, sharp.a));
+		}
 		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();

package/dist/core/{Ring-Chj1tp_P.js → Ring-QApyKPzE.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { l as ringSdf } from "./sdf-Bux00UoZ.js";
+import { l as ringSdf } from "./sdf-DyC2H_qS.js";
 import { float, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{RoundedRect-BEj6tE1e.js → RoundedRect-Ca9af9xe.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { u as roundedRectSdf } from "./sdf-Bux00UoZ.js";
+import { u as roundedRectSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Shatter-CZMOHj60.js → Shatter-BssZTRYJ.js}

@@ -1,12 +1,15 @@
 import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { DataTexture, FloatType, LinearFilter, NearestFilter, RGBAFormat } from "three";
-import { convertToTexture, float, screenUV, smoothstep, texture, vec2, vec4 } from "three/tsl";
+import { StorageTexture } from "three/webgpu";
+import { DataTexture, FloatType, LinearFilter as LinearFilter$1, NearestFilter, RGBAFormat } from "three";
+import { Fn, If, convertToTexture, float, instanceIndex, int, screenUV, smoothstep, storageTexture, texture, textureStore, uint, uniformArray, uvec2, vec2, vec4 } from "three/tsl";
 var seededRandom = (seed) => {
 	const x = Math.sin(seed) * 1e4;
 	return x - Math.floor(x);
 };
+var SHARD_COUNT = 16;
+var VORONOI_SIZE = 1024;
 const componentDefinition = {
 	name: "Shatter",
 	category: "Interactive",
@@ -140,23 +143,148 @@ const componentDefinition = {
 			}
 		}
 	},
-	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions }) => {
-		const SHARD_COUNT = 16;
+	computeNode: ({ uniforms, onCleanup }) => {
+		const cellPositions = uniformArray(new Array(SHARD_COUNT * 2).fill(0), "float");
+		const voronoiTex = new StorageTexture(VORONOI_SIZE, VORONOI_SIZE);
+		voronoiTex.type = FloatType;
+		voronoiTex.magFilter = NearestFilter;
+		voronoiTex.minFilter = NearestFilter;
+		voronoiTex.generateMipmaps = false;
+		const voronoiTexNode = storageTexture(voronoiTex);
+		onCleanup(() => {
+			voronoiTex.dispose();
+		});
+		const vs = uint(VORONOI_SIZE);
+		const invVS = float(1 / VORONOI_SIZE);
+		const voronoiKernel = Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(vs);
+			const y = idx.div(vs);
+			If(y.lessThan(vs), () => {
+				const u = x.toFloat().add(float(.5)).mul(invVS);
+				const v = y.toFloat().add(float(.5)).mul(invVS);
+				const d1 = float(99999).toVar();
+				const d2 = float(99999).toVar();
+				const idx1 = float(0).toVar();
+				const idx2 = float(0).toVar();
+				for (let i = 0; i < SHARD_COUNT; i++) {
+					const cellX = cellPositions.element(int(i * 2));
+					const cellY = cellPositions.element(int(i * 2 + 1));
+					const ddx = u.sub(cellX);
+					const ddy = v.sub(cellY);
+					const distSq = ddx.mul(ddx).add(ddy.mul(ddy));
+					If(distSq.lessThan(d1), () => {
+						d2.assign(d1);
+						idx2.assign(idx1);
+						d1.assign(distSq);
+						idx1.assign(float(i));
+					}).Else(() => {
+						If(distSq.lessThan(d2), () => {
+							d2.assign(distSq);
+							idx2.assign(float(i));
+						});
+					});
+				}
+				textureStore(voronoiTexNode, uvec2(x, y), vec4(idx1, idx2, float(0), float(0))).toWriteOnly();
+			});
+		})().compute(VORONOI_SIZE * VORONOI_SIZE, [256]);
+		let currentSeed = uniforms.seed.uniform.value;
+		let needsDispatch = true;
+		const generateCells = (seed) => {
+			const positions = new Array(SHARD_COUNT * 2);
+			for (let i = 0; i < SHARD_COUNT; i++) {
+				positions[i * 2] = seededRandom(seed + i * 2);
+				positions[i * 2 + 1] = seededRandom(seed + i * 2 + 1);
+			}
+			cellPositions.array = positions;
+		};
+		generateCells(currentSeed);
+		return {
+			outputs: { voronoiTexture: voronoiTex },
+			getComputeNodes: () => {
+				const newSeed = uniforms.seed.uniform.value;
+				if (newSeed !== currentSeed) {
+					currentSeed = newSeed;
+					generateCells(currentSeed);
+					needsDispatch = true;
+				}
+				if (needsDispatch) {
+					needsDispatch = false;
+					return [voronoiKernel];
+				}
+				return null;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions, computeOutputs }) => {
 		const FRICTION = 1;
 		const cellData = new Float32Array(SHARD_COUNT * 4);
 		const cellTexture = new DataTexture(cellData, 4, 4, RGBAFormat, FloatType);
-		cellTexture.magFilter = LinearFilter;
-		cellTexture.minFilter = LinearFilter;
+		cellTexture.magFilter = LinearFilter$1;
+		cellTexture.minFilter = LinearFilter$1;
 		const displacementData = new Float32Array(SHARD_COUNT * 4);
 		const displacementTexture = new DataTexture(displacementData, 4, 4, RGBAFormat, FloatType);
-		displacementTexture.magFilter = LinearFilter;
-		displacementTexture.minFilter = LinearFilter;
-		const VORONOI_SIZE = 1024;
-		const voronoiData = new Float32Array(VORONOI_SIZE * VORONOI_SIZE * 4);
-		const voronoiTexture = new DataTexture(voronoiData, VORONOI_SIZE, VORONOI_SIZE, RGBAFormat, FloatType);
-		voronoiTexture.magFilter = NearestFilter;
-		voronoiTexture.minFilter = NearestFilter;
-		const generateCells = (seed) => {
+		displacementTexture.magFilter = LinearFilter$1;
+		displacementTexture.minFilter = LinearFilter$1;
+		let voronoiField;
+		if (computeOutputs?.voronoiTexture) voronoiField = texture(computeOutputs.voronoiTexture);
+		else {
+			const voronoiData = new Float32Array(VORONOI_SIZE * VORONOI_SIZE * 4);
+			const voronoiTexture = new DataTexture(voronoiData, VORONOI_SIZE, VORONOI_SIZE, RGBAFormat, FloatType);
+			voronoiTexture.magFilter = NearestFilter;
+			voronoiTexture.minFilter = NearestFilter;
+			voronoiField = texture(voronoiTexture);
+			const generateVoronoi = () => {
+				for (let y = 0; y < VORONOI_SIZE; y++) for (let x = 0; x < VORONOI_SIZE; x++) {
+					const u = (x + .5) / VORONOI_SIZE;
+					const v = (y + .5) / VORONOI_SIZE;
+					let d1 = Infinity, d2 = Infinity, i1 = 0, i2 = 0;
+					for (let i = 0; i < SHARD_COUNT; i++) {
+						const dx = u - cellData[i * 4];
+						const dy = v - cellData[i * 4 + 1];
+						const distSq = dx * dx + dy * dy;
+						if (distSq < d1) {
+							d2 = d1;
+							i2 = i1;
+							d1 = distSq;
+							i1 = i;
+						} else if (distSq < d2) {
+							d2 = distSq;
+							i2 = i;
+						}
+					}
+					const offset = (y * VORONOI_SIZE + x) * 4;
+					voronoiData[offset] = i1;
+					voronoiData[offset + 1] = i2;
+				}
+				voronoiTexture.needsUpdate = true;
+			};
+			let currentSeed = uniforms.seed.uniform.value;
+			const generateCells = (seed) => {
+				for (let i = 0; i < SHARD_COUNT; i++) {
+					cellData[i * 4] = seededRandom(seed + i * 2);
+					cellData[i * 4 + 1] = seededRandom(seed + i * 2 + 1);
+					cellData[i * 4 + 2] = seededRandom(seed + i * 3);
+					cellData[i * 4 + 3] = seededRandom(seed + i * 3 + 1);
+				}
+				cellTexture.needsUpdate = true;
+			};
+			generateCells(currentSeed);
+			generateVoronoi();
+			onBeforeRender(() => {
+				const newSeed = uniforms.seed.uniform.value;
+				if (newSeed !== currentSeed) {
+					currentSeed = newSeed;
+					generateCells(currentSeed);
+					generateVoronoi();
+					displacementData.fill(0);
+				}
+			});
+			onCleanup(() => {
+				voronoiTexture.dispose();
+			});
+		}
+		const generateCellsFull = (seed) => {
 			for (let i = 0; i < SHARD_COUNT; i++) {
 				cellData[i * 4] = seededRandom(seed + i * 2);
 				cellData[i * 4 + 1] = seededRandom(seed + i * 2 + 1);
@@ -165,60 +293,25 @@ const componentDefinition = {
 			}
 			cellTexture.needsUpdate = true;
 		};
-		const generateVoronoi = () => {
-			for (let y = 0; y < VORONOI_SIZE; y++) for (let x = 0; x < VORONOI_SIZE; x++) {
-				const u = (x + .5) / VORONOI_SIZE;
-				const v = (y + .5) / VORONOI_SIZE;
-				let d1 = Infinity;
-				let d2 = Infinity;
-				let idx1 = 0;
-				let idx2 = 0;
-				for (let i = 0; i < SHARD_COUNT; i++) {
-					const dx = u - cellData[i * 4];
-					const dy = v - cellData[i * 4 + 1];
-					const distSq = dx * dx + dy * dy;
-					if (distSq < d1) {
-						d2 = d1;
-						idx2 = idx1;
-						d1 = distSq;
-						idx1 = i;
-					} else if (distSq < d2) {
-						d2 = distSq;
-						idx2 = i;
-					}
-				}
-				const offset = (y * VORONOI_SIZE + x) * 4;
-				voronoiData[offset] = idx1;
-				voronoiData[offset + 1] = idx2;
-				voronoiData[offset + 2] = 0;
-				voronoiData[offset + 3] = 0;
-			}
-			voronoiTexture.needsUpdate = true;
-		};
-		let currentSeed = uniforms.seed.uniform.value;
-		generateCells(currentSeed);
-		generateVoronoi();
+		let currentSeedForDisp = uniforms.seed.uniform.value;
+		generateCellsFull(currentSeedForDisp);
 		displacementData.fill(0);
 		displacementTexture.needsUpdate = true;
-		let prevX = .5;
-		let prevY = .5;
-		let lastTime = Date.now();
+		let prevX = .5, prevY = .5, lastTime = Date.now();
 		onBeforeRender(({ pointer }) => {
 			const currentTime = Date.now();
 			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
 			lastTime = currentTime;
 			const aspect = dimensions.width / dimensions.height;
 			const newSeed = uniforms.seed.uniform.value;
-			if (newSeed !== currentSeed) {
-				currentSeed = newSeed;
-				generateCells(currentSeed);
-				generateVoronoi();
+			if (newSeed !== currentSeedForDisp) {
+				currentSeedForDisp = newSeed;
+				generateCellsFull(currentSeedForDisp);
 				displacementData.fill(0);
 			}
 			const intensity = uniforms.intensity.uniform.value;
 			const radius = uniforms.radius.uniform.value;
 			const decay = uniforms.decay.uniform.value;
-			const friction = FRICTION;
 			let velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
 			let velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
 			let speed = Math.sqrt(velX * velX + velY * velY);
@@ -243,8 +336,7 @@ const componentDefinition = {
 				const decayFactor = Math.exp(-dt / decayTime);
 				currentDx *= decayFactor;
 				currentDy *= decayFactor;
-				let velocityDx = 0;
-				let velocityDy = 0;
+				let velocityDx = 0, velocityDy = 0;
 				if (dist < radius && speed > .01) {
 					const influence = Math.max(0, 1 - dist / radius);
 					const influenceCurve = influence * influence;
@@ -255,7 +347,7 @@ const componentDefinition = {
 					velocityDx += randomDirX * jitterForce;
 					velocityDy += randomDirY * jitterForce;
 				}
-				const lerpFactor = Math.min(1, friction * dt);
+				const lerpFactor = Math.min(1, FRICTION * dt);
 				displacementData[i * 4] = currentDx + velocityDx * lerpFactor;
 				displacementData[i * 4 + 1] = currentDy + velocityDy * lerpFactor;
 				displacementData[i * 4 + 2] = 0;
@@ -268,7 +360,6 @@ const componentDefinition = {
 		onCleanup(() => {
 			cellTexture.dispose();
 			displacementTexture.dispose();
-			voronoiTexture.dispose();
 		});
 		if (!childNode) return vec4(0, 0, 0, 0);
 		const childTexture = convertToTexture(childNode);
@@ -277,7 +368,7 @@ const componentDefinition = {
 		});
 		const cellField = texture(cellTexture);
 		const dispField = texture(displacementTexture);
-		const voronoiSample = texture(voronoiTexture).sample(screenUV);
+		const voronoiSample = voronoiField.sample(screenUV);
 		const nearestIdx = voronoiSample.r;
 		const secondIdx = voronoiSample.g;
 		const nearestUV = vec2(nearestIdx.mod(float(4)).add(.5).div(4), nearestIdx.div(float(4)).floor().add(.5).div(4));
@@ -304,12 +395,9 @@ const componentDefinition = {
 		const rUV = displacedUV.add(rOffset.mul(crackIntensity));
 		const gUV = displacedUV.add(gOffset.mul(crackIntensity));
 		const bUV = displacedUV.add(bOffset.mul(crackIntensity));
-		const rSample = childTexture.sample(rUV);
-		const gSample = childTexture.sample(gUV);
-		const bSample = childTexture.sample(bUV);
-		const rFinal = applyEdgeHandling(rUV, rSample, childTexture, uniforms.edges.uniform.value);
-		const gFinal = applyEdgeHandling(gUV, gSample, childTexture, uniforms.edges.uniform.value);
-		const bFinal = applyEdgeHandling(bUV, bSample, childTexture, uniforms.edges.uniform.value);
+		const rFinal = applyEdgeHandling(rUV, childTexture.sample(rUV), childTexture, uniforms.edges.uniform.value);
+		const gFinal = applyEdgeHandling(gUV, childTexture.sample(gUV), childTexture, uniforms.edges.uniform.value);
+		const bFinal = applyEdgeHandling(bUV, childTexture.sample(bUV), childTexture, uniforms.edges.uniform.value);
 		const refractedColor = vec4(rFinal.r, gFinal.g, bFinal.b, gFinal.a);
 		const normalColor = applyEdgeHandling(displacedUV, childTexture.sample(displacedUV), childTexture, uniforms.edges.uniform.value);
 		let shadedRGB = normalColor.rgb.mul(float(1).sub(crackIntensity)).add(refractedColor.rgb.mul(crackIntensity));

package/dist/core/{Star-fPw1j10r.js → Star-DiXwnPGP.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { d as starSdf } from "./sdf-Bux00UoZ.js";
+import { d as starSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{TiltShift-BysRsV8v.js → TiltShift-BqKaU3TM.js}

@@ -1,6 +1,7 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { Fn, abs, convertToTexture, cos, dot, float, mix, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
+import { n as createVariableGaussianBlurCompute } from "./computeBlur-B0KA4n89.js";
+import { Fn, If, abs, convertToTexture, cos, dot, float, instanceIndex, mix, radians, screenUV, sin, smoothstep, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "TiltShift",
 	category: "Blurs",
@@ -71,8 +72,65 @@ const componentDefinition = {
 			}
 		}
 	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms }) => {
+		if (!childNode) return null;
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const dpr = renderer?.getPixelRatio?.() ?? 1;
+		const texWidth = Math.round(dimensions.width * dpr);
+		const texHeight = Math.round(dimensions.height * dpr);
+		const { computeNodes: blurNodes, outputTexture, blurMapWriteNode } = createVariableGaussianBlurCompute(childTexture, texWidth, texHeight, onCleanup);
+		const angleU = uniform(0);
+		const centerXU = uniform(.5);
+		const centerYU = uniform(.5);
+		const focusWidthU = uniform(.15);
+		const falloffU = uniform(.3);
+		const maxRadiusU = uniform(18);
+		const aspectU = uniform(1);
+		const w = uint(texWidth);
+		const h = uint(texHeight);
+		const fillBlurMap = Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const u = x.toFloat().add(float(.5)).div(float(texWidth));
+				const v = y.toFloat().add(float(.5)).div(float(texHeight));
+				const angleRad = angleU.mul(float(Math.PI / 180));
+				const cosA = angleRad.cos();
+				const perpVector = vec2(angleRad.sin().negate(), cosA);
+				const centerPos = vec2(centerXU, float(1).sub(centerYU));
+				const centeredUV = vec2(u, v).sub(centerPos);
+				const distFromLine = abs(dot(vec2(centeredUV.x.mul(aspectU), centeredUV.y), perpVector));
+				const radius = smoothstep(focusWidthU, focusWidthU.add(falloffU), distFromLine).mul(maxRadiusU);
+				textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+			});
+		})().compute(texWidth * texHeight, [256]);
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				angleU.value = uniforms.angle.uniform.value;
+				centerXU.value = uniforms.center.uniform.value?.x ?? uniforms.center.uniform.x?.value ?? .5;
+				centerYU.value = uniforms.center.uniform.value?.y ?? uniforms.center.uniform.y?.value ?? .5;
+				focusWidthU.value = uniforms.width.uniform.value * .5;
+				falloffU.value = uniforms.falloff.uniform.value;
+				aspectU.value = dimensions.width / dimensions.height;
+				maxRadiusU.value = uniforms.intensity.uniform.value * .36;
+				return [fillBlurMap, ...blurNodes];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const sharp = computeOutputs.childTexture.sample(screenUV);
+			return unpremultiplyAlpha(vec4(texture(computeOutputs.blurredTexture).sample(screenUV).rgb, sharp.a));
+		}
 		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();

package/dist/core/{Trapezoid-Cr61vRvN.js → Trapezoid-BX_hmeZJ.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { f as trapezoidSdf } from "./sdf-Bux00UoZ.js";
+import { f as trapezoidSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Vesica-AXTA8DJU.js → Vesica-DU0f85NG.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { p as vesicaSdf } from "./sdf-Bux00UoZ.js";
+import { p as vesicaSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{VideoTexture-BobyGZGr.js → VideoTexture-DJrkry82.js}

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

package/dist/core/{WaveDistortion-BVT1KuLK.js → WaveDistortion-BKma8-Ju.js}

@@ -2,7 +2,7 @@ import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
-import { PI, abs, convertToTexture, cos, float, fract, screenUV, sin, step, vec2, vec4, viewportSize } from "three/tsl";
+import { PI, abs, convertToTexture, cos, float, fract, screenUV, sin, step, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "WaveDistortion",
 	category: "Distortions",
@@ -130,14 +130,27 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: (params) => {
-		const { uniforms, childNode, onCleanup } = params;
+		const { uniforms, childNode, onCleanup, onBeforeRender } = params;
 		if (!childNode) return vec4(0, 0, 0, 0);
 		const uvCoord = screenUV;
 		const aspect = viewportSize.x.div(viewportSize.y);
 		const t = createAnimatedTime(params, uniforms.speed).mul(.5);
-		const angleRad = uniforms.angle.uniform.mul(PI).div(180);
-		const cosAngle = cos(angleRad);
-		const sinAngle = sin(angleRad);
+		let cosAngle, sinAngle;
+		if (uniforms.angle.uniform.isUniformNode) {
+			const precomputedCos = uniform(1);
+			const precomputedSin = uniform(0);
+			onBeforeRender(() => {
+				const rad = uniforms.angle.uniform.value * Math.PI / 180;
+				precomputedCos.value = Math.cos(rad);
+				precomputedSin.value = Math.sin(rad);
+			});
+			cosAngle = precomputedCos;
+			sinAngle = precomputedSin;
+		} else {
+			const angleRad = uniforms.angle.uniform.mul(PI).div(180);
+			cosAngle = cos(angleRad);
+			sinAngle = sin(angleRad);
+		}
 		const centeredUV = uvCoord.sub(vec2(.5, .5));
 		const aspectCorrectedUV = vec2(centeredUV.x.mul(aspect), centeredUV.y);
 		const phase = vec2(aspectCorrectedUV.x.mul(cosAngle).sub(aspectCorrectedUV.y.mul(sinAngle)), aspectCorrectedUV.x.mul(sinAngle).add(aspectCorrectedUV.y.mul(cosAngle))).y.add(.5).mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);

package/dist/core/{WebcamTexture-BXj7sqND.js → WebcamTexture-Cf8J7JB1.js}

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