shaders 2.5.94 → 2.5.95

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/{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 = {

package/dist/core/computeBlur-B0KA4n89.js

@@ -0,0 +1,141 @@
+import { StorageTexture } from "three/webgpu";
+import { FloatType } from "three";
+import { Fn, If, float, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniformArray, uvec2, vec4 } from "three/tsl";
+var HALF_KERNEL = 48;
+var KERNEL_SIZE = HALF_KERNEL * 2 + 1;
+var VAR_SIGMA = HALF_KERNEL / 3;
+var FIXED_WEIGHTS = [];
+var fixedWeightSum = 0;
+for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+	const w = Math.exp(-(i * i) / (2 * VAR_SIGMA * VAR_SIGMA));
+	FIXED_WEIGHTS.push(w);
+	fixedWeightSum += w;
+}
+for (let i = 0; i < KERNEL_SIZE; i++) FIXED_WEIGHTS[i] /= fixedWeightSum;
+function createGaussianBlurCompute(inputTexture, width, height, onCleanup) {
+	const intermediateTex = new StorageTexture(width, height);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(width, height);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weights = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	let lastRadius = -1;
+	const w = uint(width);
+	const h = uint(height);
+	const wm1 = int(width - 1);
+	const hm1 = int(height - 1);
+	const horizontalPass = Fn(() => {
+		const idx = instanceIndex;
+		const x = idx.mod(w);
+		const y = idx.div(w);
+		If(y.lessThan(h), () => {
+			const sum = vec4(0).toVar();
+			const xi = x.toInt();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(inputTexture, uvec2(xi.add(int(i)).clamp(int(0), wm1).toUint(), y), int(0));
+				sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(intermediateWriteNode, uvec2(x, y), sum).toWriteOnly();
+		});
+	})().compute(width * height, [256]);
+	const verticalPass = Fn(() => {
+		const idx = instanceIndex;
+		const x = idx.mod(w);
+		const y = idx.div(w);
+		If(y.lessThan(h), () => {
+			const sum = vec4(0).toVar();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(intermediateReadNode, uvec2(x, y.toInt().add(int(i)).clamp(int(0), hm1).toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(outputNode, uvec2(x, y), sum).toWriteOnly();
+		});
+	})().compute(width * height, [256]);
+	function updateRadius(pixelRadius) {
+		if (Math.abs(pixelRadius - lastRadius) < .01) return;
+		lastRadius = pixelRadius;
+		const sigma = Math.max(pixelRadius * .5, .001);
+		const newWeights = new Array(KERNEL_SIZE);
+		let total = 0;
+		for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+			const w$1 = Math.exp(-(i * i) / (2 * sigma * sigma));
+			newWeights[i + HALF_KERNEL] = w$1;
+			total += w$1;
+		}
+		for (let i = 0; i < KERNEL_SIZE; i++) newWeights[i] /= total;
+		weights.array = newWeights;
+	}
+	updateRadius(4);
+	return {
+		computeNodes: [horizontalPass, verticalPass],
+		outputTexture: outputTex,
+		updateRadius
+	};
+}
+function createVariableGaussianBlurCompute(inputTexture, width, height, onCleanup) {
+	const blurMapTex = new StorageTexture(width, height);
+	blurMapTex.type = FloatType;
+	const blurMapWriteNode = storageTexture(blurMapTex);
+	const blurMapReadNode = storageTexture(blurMapTex).toReadOnly();
+	const intermediateTex = new StorageTexture(width, height);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(width, height);
+	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 w = uint(width);
+	const h = uint(height);
+	const wm1 = int(width - 1);
+	const hm1 = int(height - 1);
+	const invHalf = float(1 / HALF_KERNEL);
+	return {
+		computeNodes: [Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(x, y), int(0)).r;
+				const sum = vec4(0).toVar();
+				const xi = x.toInt();
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = float(i).mul(invHalf).mul(blurRadius);
+					const texel = textureLoad(inputTexture, uvec2(xi.add(offset.round().toInt()).clamp(int(0), wm1).toUint(), y), int(0));
+					sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+				}
+				textureStore(intermediateWriteNode, uvec2(x, y), sum).toWriteOnly();
+			});
+		})().compute(width * height, [256]), Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(x, y), int(0)).r;
+				const sum = vec4(0).toVar();
+				const yi = y.toInt();
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = float(i).mul(invHalf).mul(blurRadius);
+					const texel = textureLoad(intermediateReadNode, uvec2(x, yi.add(offset.round().toInt()).clamp(int(0), hm1).toUint()), int(0));
+					sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+				}
+				textureStore(outputNode, uvec2(x, y), sum).toWriteOnly();
+			});
+		})().compute(width * height, [256])],
+		outputTexture: outputTex,
+		blurMapTexture: blurMapTex,
+		blurMapWriteNode
+	};
+}
+export { createVariableGaussianBlurCompute as n, createGaussianBlurCompute as t };

package/dist/core/effects/glass.d.ts

@@ -61,5 +61,5 @@ export interface GlassEffectUniforms {
         uniform: any;
     };
 }
-export declare function applyGlassEffect(childTexture: any, sdfSampler: (uv: any) => any, uniforms: GlassEffectUniforms & UniformsMap, onBeforeRender?: (callback: () => void) => void): Node;
+export declare function applyGlassEffect(childTexture: any, sdfSampler: (uv: any) => any, uniforms: GlassEffectUniforms & UniformsMap, onBeforeRender?: (callback: () => void) => void, blurredTexture?: any): Node;
 //# sourceMappingURL=glass.d.ts.map

package/dist/core/effects/glass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glass.d.ts","sourceRoot":"","sources":["../../src/effects/glass.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAA;AAMzC,eAAO,MAAM,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAO,CAAA;AAO/C,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,IAAI,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,aAAa,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC/B,sBAAsB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxC,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,cAAc,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAChC,iBAAiB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACnC,OAAO,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACzB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,eAAe,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;CAC9B;AAgBD,wBAAgB,gBAAgB,CAC5B,YAAY,EAAE,GAAG,EACjB,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,EAC5B,QAAQ,EAAE,mBAAmB,GAAG,WAAW,EAC3C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,GAChD,IAAI,CAmLN"}
+{"version":3,"file":"glass.d.ts","sourceRoot":"","sources":["../../src/effects/glass.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAA;AAMzC,eAAO,MAAM,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAO,CAAA;AAO/C,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,IAAI,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,aAAa,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC/B,sBAAsB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxC,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,cAAc,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAChC,iBAAiB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACnC,OAAO,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACzB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,eAAe,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;CAC9B;AAgBD,wBAAgB,gBAAgB,CAC5B,YAAY,EAAE,GAAG,EACjB,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,EAC5B,QAAQ,EAAE,mBAAmB,GAAG,WAAW,EAC3C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,EAC/C,cAAc,CAAC,EAAE,GAAG,GACrB,IAAI,CAqMN"}