shaders 2.5.94 → 2.5.95

package/dist/js/createShader.js

@@ -41,7 +41,7 @@ async function createShader(canvas, preset, options) {
 	if (isExternalUser()) {
 		const checkRendering = () => {
 			if (renderer.getPerformanceStats().fps > 0) {
-				telemetryCollector = startTelemetry(renderer, "2.5.94", options?.disableTelemetry || false, false);
+				telemetryCollector = startTelemetry(renderer, "2.5.95", options?.disableTelemetry || false, false);
 				if (telemetryCollector) telemetryCollector.start();
 				telemetryStartTimeout = null;
 			} else telemetryStartTimeout = setTimeout(checkRendering, 500);

package/dist/react/Shader.js

@@ -89,7 +89,7 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 				return;
 			}
 			if (rendererRef.current.getPerformanceStats().fps > 0) {
-				telemetryCollectorRef.current = startTelemetry(rendererRef.current, "2.5.94", disableTelemetry, isPreview);
+				telemetryCollectorRef.current = startTelemetry(rendererRef.current, "2.5.95", disableTelemetry, isPreview);
 				if (telemetryCollectorRef.current) telemetryCollectorRef.current.start();
 				telemetryStartTimeoutRef.current = null;
 			} else telemetryStartTimeoutRef.current = window.setTimeout(checkRendering, 500);

package/dist/registry.js

@@ -1512,7 +1512,7 @@ export const shaderRegistry = [
               "map"
             ],
             "min": 0,
-            "max": 100,
+            "max": 200,
             "step": 1,
             "label": "Intensity",
             "group": "Effect"
@@ -1528,7 +1528,7 @@ export const shaderRegistry = [
             "map"
           ],
           "min": 0,
-          "max": 100,
+          "max": 200,
           "step": 1,
           "label": "Intensity",
           "group": "Effect"

package/dist/solid/engine/Shader.js

@@ -67,7 +67,7 @@ function Shader(allProps) {
     const checkRendering = () => {
       const stats = rendererInstance.getPerformanceStats();
       if (stats.fps > 0) {
-        const version = "2.5.94";
+        const version = "2.5.95";
         telemetryCollector = startTelemetry(rendererInstance, version, props.disableTelemetry, props.isPreview);
         if (telemetryCollector) {
           telemetryCollector.start();

package/dist/svelte/index.js

@@ -20546,7 +20546,7 @@ function Shader($$anchor, $$props) {
 		const checkRendering = () => {
 			if (!rendererInstance) return;
 			if (rendererInstance.getPerformanceStats().fps > 0) {
-				telemetryCollector = startTelemetry(rendererInstance, "2.5.94", disableTelemetry(), isPreview());
+				telemetryCollector = startTelemetry(rendererInstance, "2.5.95", disableTelemetry(), isPreview());
 				if (telemetryCollector) telemetryCollector.start();
 				telemetryStartTimeout = null;
 			} else telemetryStartTimeout = window.setTimeout(checkRendering, 500);

package/dist/vue/Shader.vue_vue_type_script_setup_true_lang.js

@@ -60,7 +60,7 @@ var Shader_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineC
 		const startTelemetryWhenReady = () => {
 			const checkRendering = () => {
 				if (rendererInstance.value.getPerformanceStats().fps > 0) {
-					telemetryCollector = startTelemetry(rendererInstance.value, "2.5.94", props.disableTelemetry, props.isPreview);
+					telemetryCollector = startTelemetry(rendererInstance.value, "2.5.95", props.disableTelemetry, props.isPreview);
 					if (telemetryCollector) telemetryCollector.start();
 					telemetryStartTimeout = null;
 				} else telemetryStartTimeout = setTimeout(checkRendering, 500);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shaders",
-  "version": "2.5.94",
+  "version": "2.5.95",
   "description": "Shader magic for modern frontends",
   "author": "Shader Effects Inc.",
   "homepage": "https://shaders.com/",

package/dist/core/CursorRipples-Bo-3LZoC.js

@@ -1,186 +0,0 @@
-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, RGFormat } from "three";
-import { convertToTexture, float, screenUV, texture, vec2, vec4 } from "three/tsl";
-var GRID_SIZE = 128;
-const componentDefinition = {
-	name: "CursorRipples",
-	category: "Interactive",
-	description: "Fluid-like ripple distortion",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		intensity: {
-			default: 10,
-			description: "Strength of the ripple distortion",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 20,
-				step: .1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		decay: {
-			default: 10,
-			description: "How quickly ripples fade (higher = faster)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 20,
-				step: .1,
-				label: "Decay",
-				group: "Effect"
-			}
-		},
-		radius: {
-			default: .5,
-			description: "Radius of cursor influence",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 1,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		chromaticSplit: {
-			default: 1,
-			description: "RGB channel separation along ripple edges",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 3,
-				step: .1,
-				label: "Chromatic Split",
-				group: "Effect"
-			}
-		},
-		edges: {
-			default: "stretch",
-			description: "How to handle edges when distortion pushes content out of bounds",
-			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: "Effect"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions }) => {
-		const buffers = [new Float32Array(GRID_SIZE * GRID_SIZE), new Float32Array(GRID_SIZE * GRID_SIZE)];
-		let currentBuffer = 0;
-		const displacementData = new Float32Array(GRID_SIZE * GRID_SIZE * 2);
-		const displacementTexture = new DataTexture(displacementData, GRID_SIZE, GRID_SIZE, RGFormat, FloatType);
-		displacementTexture.magFilter = LinearFilter;
-		displacementTexture.minFilter = LinearFilter;
-		displacementTexture.needsUpdate = true;
-		const displacementField = texture(displacementTexture);
-		let prevX = .5;
-		let prevY = .5;
-		let lastTime = Date.now();
-		let prevMaxAbsVal = 1;
-		onBeforeRender(({ pointer }) => {
-			const currentTime = Date.now();
-			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
-			lastTime = currentTime;
-			const aspect = dimensions.width / dimensions.height;
-			const substeps = 1;
-			const decay = uniforms.decay.uniform.value;
-			const radius = uniforms.radius.uniform.value * .05;
-			const rawVelX = dt > 0 ? (pointer.x - prevX) / dt : 0;
-			const rawVelY = dt > 0 ? (pointer.y - prevY) / dt : 0;
-			const mouseSpeed = Math.min(Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY), 2);
-			prevX = pointer.x;
-			prevY = pointer.y;
-			if (mouseSpeed <= .01 && prevMaxAbsVal < 1e-6) return;
-			const dampFactor = 1 - decay * .004;
-			let maxAbsVal = 0;
-			for (let s = 0; s < substeps; s++) {
-				const curr$1 = buffers[currentBuffer];
-				const prev = buffers[1 - currentBuffer];
-				if (s === 0 && mouseSpeed > .01) {
-					const influenceRadius = radius * 3;
-					const minJ = Math.max(1, Math.floor((pointer.x - influenceRadius) * GRID_SIZE));
-					const maxJ = Math.min(GRID_SIZE - 2, Math.ceil((pointer.x + influenceRadius) * GRID_SIZE));
-					const minI = Math.max(1, Math.floor((pointer.y - influenceRadius) * GRID_SIZE));
-					const maxI = Math.min(GRID_SIZE - 2, Math.ceil((pointer.y + influenceRadius) * GRID_SIZE));
-					for (let i = minI; i <= maxI; i++) for (let j = minJ; j <= maxJ; j++) {
-						const idx = i * GRID_SIZE + j;
-						const cellX = (j + .5) / GRID_SIZE;
-						const cellY = (i + .5) / GRID_SIZE;
-						const ddx = aspect >= 1 ? (cellX - pointer.x) * aspect : cellX - pointer.x;
-						const ddy = aspect >= 1 ? cellY - pointer.y : (cellY - pointer.y) / aspect;
-						const dist = Math.sqrt(ddx * ddx + ddy * ddy);
-						if (dist < influenceRadius) {
-							const influence = Math.exp(-dist * dist / (radius * radius));
-							curr$1[idx] -= influence * mouseSpeed * dt * 3;
-						}
-					}
-				}
-				for (let i = 1; i < GRID_SIZE - 1; i++) for (let j = 1; j < GRID_SIZE - 1; j++) {
-					const idx = i * GRID_SIZE + j;
-					const next = ((curr$1[idx - 1] + curr$1[idx + 1] + curr$1[idx - GRID_SIZE] + curr$1[idx + GRID_SIZE]) * .5 - prev[idx]) * dampFactor;
-					prev[idx] = next;
-					const absNext = next < 0 ? -next : next;
-					if (absNext > maxAbsVal) maxAbsVal = absNext;
-				}
-				currentBuffer = 1 - currentBuffer;
-			}
-			prevMaxAbsVal = maxAbsVal;
-			const curr = buffers[currentBuffer];
-			for (let i = 1; i < GRID_SIZE - 1; i++) for (let j = 1; j < GRID_SIZE - 1; j++) {
-				const idx = i * GRID_SIZE + j;
-				const dIdx = idx * 2;
-				displacementData[dIdx] = (curr[idx + 1] - curr[idx - 1]) * .5;
-				displacementData[dIdx + 1] = (curr[idx + GRID_SIZE] - curr[idx - GRID_SIZE]) * .5;
-			}
-			displacementTexture.needsUpdate = true;
-		});
-		onCleanup(() => {
-			displacementTexture.dispose();
-		});
-		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const displacement = displacementField.sample(screenUV).xy;
-		const intensityScale = uniforms.intensity.uniform.mul(.1);
-		const scaledDisplacement = displacement.mul(intensityScale);
-		const maxDisp = float(.15);
-		const clampedDisplacement = scaledDisplacement.clamp(vec2(maxDisp.negate(), maxDisp.negate()), vec2(maxDisp, maxDisp));
-		const chromaticScale = uniforms.chromaticSplit.uniform.mul(.1);
-		const rUV = screenUV.sub(clampedDisplacement.mul(float(1).add(chromaticScale)));
-		const gUV = screenUV.sub(clampedDisplacement);
-		const bUV = screenUV.sub(clampedDisplacement.mul(float(1).sub(chromaticScale)));
-		const rSample = applyEdgeHandling(rUV, childTexture.sample(rUV), childTexture, uniforms.edges.uniform.value);
-		const gSample = applyEdgeHandling(gUV, childTexture.sample(gUV), childTexture, uniforms.edges.uniform.value);
-		const bSample = applyEdgeHandling(bUV, childTexture.sample(bUV), childTexture, uniforms.edges.uniform.value);
-		return unpremultiplyAlpha(vec4(rSample.r, gSample.g, bSample.b, gSample.a));
-	}
-};
-var CursorRipples_default = componentDefinition;
-export { componentDefinition as n, CursorRipples_default as t };

package/dist/core/CursorTrail-C-0lpOV1.js

@@ -1,160 +0,0 @@
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { DataTexture, FloatType, LinearFilter, RGBAFormat } from "three";
-import { float, screenUV, step, texture, vec2, vec4 } from "three/tsl";
-const componentDefinition = {
-	name: "CursorTrail",
-	category: "Interactive",
-	description: "Animated trail effect that tracks cursor movement",
-	props: {
-		colorA: {
-			default: "#00aaff",
-			transform: transformColor,
-			description: "Color of fresh trails",
-			ui: {
-				type: "color",
-				label: "Start Color",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#ff00aa",
-			transform: transformColor,
-			description: "Color trails transition to as they fade",
-			ui: {
-				type: "color",
-				label: "End Color",
-				group: "Colors"
-			}
-		},
-		radius: {
-			default: .5,
-			description: "Base radius of trail circles",
-			ui: {
-				type: "range",
-				min: .5,
-				max: 2,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		length: {
-			default: .5,
-			description: "How long trail circles persist (in seconds)",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 2,
-				step: .1,
-				label: "Trail Length",
-				group: "Animation"
-			}
-		},
-		shrink: {
-			default: 1,
-			description: "How much circles shrink as they fade out (0 = no shrink, 1 = full shrink)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Shrink Amount",
-				group: "Effect"
-			}
-		},
-		colorSpace: {
-			default: "linear",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for color interpolation",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, onBeforeRender, onCleanup, dimensions }) => {
-		const GRID_SIZE = 128;
-		const trailData = new Float32Array(GRID_SIZE * GRID_SIZE * 4);
-		const trailTexture = new DataTexture(trailData, GRID_SIZE, GRID_SIZE, RGBAFormat, FloatType);
-		trailTexture.magFilter = LinearFilter;
-		trailTexture.minFilter = LinearFilter;
-		trailTexture.needsUpdate = true;
-		const trailField = texture(trailTexture);
-		let prevX = .5;
-		let prevY = .5;
-		let 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 radius = uniforms.radius.uniform.value * .1;
-			const length$1 = uniforms.length.uniform.value;
-			const shrink = uniforms.shrink.uniform.value;
-			const dx = pointer.x - prevX;
-			const dy = pointer.y - prevY;
-			const speed = Math.sqrt(dx * dx + dy * dy);
-			const fadeRate = 1 - dt / Math.max(.1, length$1);
-			const ageRate = dt / Math.max(.1, length$1);
-			for (let i = 0; i < GRID_SIZE * GRID_SIZE * 4; i += 4) {
-				trailData[i] *= fadeRate;
-				trailData[i + 1] = 1 - (1 - trailData[i]) * shrink;
-				trailData[i + 2] = Math.min(1, trailData[i + 2] + ageRate);
-			}
-			if (speed > .001) {
-				const influenceRadius = radius * 3;
-				const stepSize = Math.max(.005, radius * .5);
-				const numSteps = Math.min(20, Math.max(1, Math.ceil(speed / stepSize)));
-				const amountPerStep = speed / numSteps * 50 * dt;
-				for (let s = 0; s < numSteps; s++) {
-					const t = (s + .5) / numSteps;
-					const px = prevX + dx * t;
-					const py = prevY + dy * t;
-					const minJ = Math.max(0, Math.floor((px - influenceRadius) * GRID_SIZE));
-					const maxJ = Math.min(GRID_SIZE - 1, Math.ceil((px + influenceRadius) * GRID_SIZE));
-					const minI = Math.max(0, Math.floor((py - influenceRadius) * GRID_SIZE));
-					const maxI = Math.min(GRID_SIZE - 1, Math.ceil((py + influenceRadius) * GRID_SIZE));
-					for (let i = minI; i <= maxI; i++) for (let j = minJ; j <= maxJ; j++) {
-						const idx = (i * GRID_SIZE + j) * 4;
-						const cellX = (j + .5) / GRID_SIZE;
-						const cellY = (i + .5) / GRID_SIZE;
-						const cellDx = aspect >= 1 ? (cellX - px) * aspect : cellX - px;
-						const cellDy = aspect >= 1 ? cellY - py : (cellY - py) / aspect;
-						const dist = Math.sqrt(cellDx * cellDx + cellDy * cellDy);
-						if (dist < influenceRadius) {
-							const influence = Math.exp(-dist * dist / (radius * radius));
-							trailData[idx] = Math.min(1, trailData[idx] + influence * amountPerStep);
-							trailData[idx + 1] = 1;
-							trailData[idx + 2] = 0;
-						}
-					}
-				}
-			}
-			trailTexture.needsUpdate = true;
-			prevX = pointer.x;
-			prevY = pointer.y;
-		});
-		onCleanup(() => {
-			trailTexture.dispose();
-		});
-		const pixelSize = float(1 / GRID_SIZE);
-		const centerSample = trailField.sample(screenUV);
-		const sample1 = trailField.sample(screenUV.add(vec2(pixelSize, float(0))));
-		const sample2 = trailField.sample(screenUV.add(vec2(float(0), pixelSize)));
-		const sample3 = trailField.sample(screenUV.add(vec2(pixelSize.negate(), float(0))));
-		const sample4 = trailField.sample(screenUV.add(vec2(float(0), pixelSize.negate())));
-		const trailIntensity = centerSample.x.mul(float(.5)).add(sample1.x.mul(float(.125))).add(sample2.x.mul(float(.125))).add(sample3.x.mul(float(.125))).add(sample4.x.mul(float(.125)));
-		const trailAge = centerSample.z.mul(float(.5)).add(sample1.z.mul(float(.125))).add(sample2.z.mul(float(.125))).add(sample3.z.mul(float(.125))).add(sample4.z.mul(float(.125)));
-		const circleMask = step(float(.01), trailIntensity);
-		const colorA = uniforms.colorA.uniform;
-		const colorB = uniforms.colorB.uniform;
-		const trailColor = mixColors(colorA, colorB, trailAge, uniforms.colorSpace.uniform.value);
-		return vec4(trailColor.rgb, trailColor.a.mul(circleMask));
-	}
-};
-var CursorTrail_default = componentDefinition;
-export { componentDefinition as n, CursorTrail_default as t };

package/dist/core/GridDistortion-DXM5MgSc.js

@@ -1,183 +0,0 @@
-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, RGFormat } from "three";
-import { convertToTexture, float, screenUV, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
-var DEFAULT_GRID_SIZE = 20;
-var displacementStateCache = /* @__PURE__ */ new WeakMap();
-var getOrCreateDisplacementState = (uniforms) => {
-	let state = displacementStateCache.get(uniforms);
-	const gridSize = uniforms?.gridSize?.uniform?.value ? Math.max(8, Math.min(128, Math.floor(uniforms.gridSize.uniform.value))) : DEFAULT_GRID_SIZE;
-	if (state && state.gridSize !== gridSize) {
-		state.dataTexture.dispose();
-		state = void 0;
-		displacementStateCache.delete(uniforms);
-	}
-	if (!state) {
-		const data = new Float32Array(gridSize * gridSize * 2);
-		const dataTexture = new DataTexture(data, gridSize, gridSize, RGFormat, FloatType);
-		dataTexture.magFilter = LinearFilter;
-		dataTexture.minFilter = LinearFilter;
-		dataTexture.needsUpdate = true;
-		state = {
-			dataTexture,
-			data,
-			tslNode: texture(dataTexture),
-			gridSize
-		};
-		displacementStateCache.set(uniforms, state);
-	}
-	return state;
-};
-const componentDefinition = {
-	name: "GridDistortion",
-	category: "Interactive",
-	description: "Interactive grid distortion controlled by mouse position",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		intensity: {
-			default: 1,
-			description: "Strength of the distortion effect",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 5,
-				step: .1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		decay: {
-			default: 3,
-			description: "Rate of distortion decay (higher = faster)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 10,
-				step: .1,
-				label: "Decay",
-				group: "Effect"
-			}
-		},
-		radius: {
-			default: 1,
-			description: "Radius of the distortion effect",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 3,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		gridSize: {
-			default: 20,
-			description: "Resolution of the distortion grid (higher = more detailed)",
-			ui: {
-				type: ["range", "map"],
-				min: 8,
-				max: 128,
-				step: 1,
-				label: "Grid Size",
-				group: "Effect"
-			}
-		},
-		edges: {
-			default: "stretch",
-			description: "How to handle edges when distortion pushes content out of bounds",
-			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: "Effect"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions }) => {
-		const { dataTexture: displacementTexture, data: displacementData, tslNode: displacementField, gridSize: GRID_SIZE } = getOrCreateDisplacementState(uniforms);
-		const mouseVelX = uniform(0);
-		const mouseVelY = uniform(0);
-		let prevX = .5;
-		let prevY = .5;
-		let lastTime = Date.now();
-		onBeforeRender(({ pointer }) => {
-			const currentTime = Date.now();
-			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
-			lastTime = currentTime;
-			const aspect$1 = Math.max(1, dimensions.width) / Math.max(1, dimensions.height);
-			const velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
-			const velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
-			mouseVelX.value = mouseVelX.value * .85 + velX * .15;
-			mouseVelY.value = mouseVelY.value * .85 + velY * .15;
-			const decay = uniforms.decay.uniform.value;
-			const intensity = uniforms.intensity.uniform.value;
-			const radius = uniforms.radius.uniform.value * .05;
-			for (let i = 0; i < GRID_SIZE; i++) for (let j = 0; j < GRID_SIZE; j++) {
-				const idx = (i * GRID_SIZE + j) * 2;
-				displacementData[idx] *= 1 - decay * dt;
-				displacementData[idx + 1] *= 1 - decay * dt;
-				const cellX = (j + .5) / GRID_SIZE;
-				const cellY = (i + .5) / GRID_SIZE;
-				const dx = aspect$1 >= 1 ? (cellX - pointer.x) * aspect$1 : cellX - pointer.x;
-				const dy = aspect$1 >= 1 ? cellY - pointer.y : (cellY - pointer.y) / aspect$1;
-				const dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist < radius * 2 && Math.abs(velX) + Math.abs(velY) > .01) {
-					const influence = Math.exp(-dist * dist / (radius * radius));
-					displacementData[idx] += mouseVelX.value * influence * intensity * dt * .5;
-					displacementData[idx + 1] += mouseVelY.value * influence * intensity * dt * .5;
-				}
-				displacementData[idx] = Math.max(-1, Math.min(1, displacementData[idx]));
-				displacementData[idx + 1] = Math.max(-1, Math.min(1, displacementData[idx + 1]));
-			}
-			displacementTexture.needsUpdate = true;
-			prevX = pointer.x;
-			prevY = pointer.y;
-		});
-		onCleanup(() => {
-			displacementTexture.dispose();
-			displacementStateCache.delete(uniforms);
-		});
-		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const aspect = viewportSize.x.div(viewportSize.y);
-		const gridSizeUniform = uniforms.gridSize.uniform;
-		const isWide = aspect.greaterThan(float(1));
-		const cellsX = isWide.select(gridSizeUniform, gridSizeUniform.mul(aspect)).max(float(1));
-		const cellsY = isWide.select(gridSizeUniform.div(aspect), gridSizeUniform).max(float(1));
-		const cellIndexX = screenUV.x.mul(cellsX).floor();
-		const cellIndexY = screenUV.y.mul(cellsY).floor();
-		const gridCellUV = vec2(cellIndexX.add(.5).div(cellsX), cellIndexY.add(.5).div(cellsY));
-		const displacement = displacementField.sample(gridCellUV).xy;
-		const maxDisplacement = float(.1);
-		const negMaxDisplacement = float(-.1);
-		const clampedDisplacement = displacement.clamp(vec2(negMaxDisplacement, negMaxDisplacement), vec2(maxDisplacement, maxDisplacement));
-		const distortedUV = screenUV.sub(clampedDisplacement);
-		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
-	}
-};
-var GridDistortion_default = componentDefinition;
-export { componentDefinition as n, GridDistortion_default as t };