shaders 2.5.94 → 2.5.96

package/dist/core/Blur-CXXttTb1.js

@@ -0,0 +1,138 @@
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { n as createVariableGaussianBlurCompute, t as createGaussianBlurCompute } from "./computeBlur-C3oX720H.js";
+import { Fn, If, clamp, convertToTexture, dot, float, instanceIndex, int, mix, pow, screenUV, texture, textureLoad, textureStore, uint, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "Blur",
+	category: "Blurs",
+	description: "A simple Gaussian blur effect",
+	requiresRTT: true,
+	requiresChild: true,
+	props: { intensity: {
+		default: 50,
+		description: "Intensity of the blur effect",
+		ui: {
+			type: ["range", "map"],
+			min: 0,
+			max: 200,
+			step: 1,
+			label: "Intensity",
+			group: "Effect"
+		}
+	} },
+	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 mapInfo = uniforms.intensity.mapComputeInfo;
+		if (mapInfo) {
+			const { computeNodes: blurNodes, outputTexture: outputTexture$1, blurMapWriteNode } = createVariableGaussianBlurCompute(childTexture, texWidth, texHeight, onCleanup);
+			const w = uint(texWidth);
+			const h = uint(texHeight);
+			const { sourceTexture, channel, inputMin, inputMax, outputMin, outputMax, curve } = mapInfo;
+			const fillBlurMap = Fn(() => {
+				const idx = instanceIndex;
+				const x = idx.mod(w);
+				const y = idx.div(w);
+				If(y.lessThan(h), () => {
+					const sample = textureLoad(sourceTexture, uvec2(x, y), int(0));
+					let raw;
+					if (channel === "alpha") raw = sample.a;
+					else if (channel === "alphaInverted") raw = sample.a.oneMinus();
+					else if (channel === "luminanceInverted") raw = dot(sample.rgb, vec3(.2126, .7152, .0722)).oneMinus();
+					else raw = dot(sample.rgb, vec3(.2126, .7152, .0722));
+					const inputRange = inputMax.sub(inputMin).max(float(1e-4));
+					const radius = mix(outputMin, outputMax, pow(clamp(raw.sub(inputMin).div(inputRange), float(0), float(1)), pow(float(2), curve.negate().mul(float(2))))).mul(float(.36));
+					textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+				});
+			})().compute(texWidth * texHeight, [256]);
+			return {
+				outputs: {
+					childTexture,
+					blurredTexture: outputTexture$1
+				},
+				getComputeNodes: () => [fillBlurMap, ...blurNodes]
+			};
+		}
+		const { computeNodes, outputTexture, updateRadius } = createGaussianBlurCompute(childTexture, texWidth, texHeight, onCleanup);
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				const intensityEntry = uniforms.intensity;
+				const intensity = intensityEntry.getCpuValue?.() ?? (typeof intensityEntry.uniform.value === "number" ? intensityEntry.uniform.value : null);
+				if (intensity !== null) updateRadius(intensity * .36);
+				return computeNodes;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const sharp = computeOutputs.childTexture.sample(screenUV);
+			const blurred = texture(computeOutputs.blurredTexture).sample(screenUV);
+			const intensityPin = uniforms.intensity.uniform.mul(float(0));
+			return unpremultiplyAlpha(vec4(blurred.rgb.add(intensityPin), sharp.a));
+		}
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
+			const blurRadius = scaledIntensity;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
+			for (let x = -6; x <= 6; x++) {
+				const weight = float(weights[x + 6] / weightSum);
+				const offset = vec2(float(x), float(0)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv$1.add(offset);
+				const sample = childTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			return total;
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv$1 = screenUV;
+			const blurRadius = scaledIntensity;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
+			for (let y = -6; y <= 6; y++) {
+				const weight = float(weights[y + 6] / weightSum);
+				const offset = vec2(float(0), float(y)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv$1.add(offset);
+				const sample = horizontalTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			return unpremultiplyAlpha(total);
+		})();
+	}
+};
+var Blur_default = componentDefinition;
+export { componentDefinition as n, Blur_default as t };

package/dist/core/{ChannelBlur-CCaPXjka.js → ChannelBlur-gzP71FWd.js}

@@ -1,5 +1,6 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { Fn, convertToTexture, float, screenUV, vec2, vec4, viewportSize } from "three/tsl";
+import { t as createGaussianBlurCompute } from "./computeBlur-C3oX720H.js";
+import { Fn, convertToTexture, float, mix, screenUV, texture, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ChannelBlur",
 	category: "Blurs",
@@ -44,8 +45,42 @@ 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 { computeNodes, outputTexture, updateRadius } = createGaussianBlurCompute(childTexture, Math.round(dimensions.width * dpr), Math.round(dimensions.height * dpr), onCleanup);
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				const r = uniforms.redIntensity.uniform.value * .1;
+				const g = uniforms.greenIntensity.uniform.value * .1;
+				const b = uniforms.blueIntensity.uniform.value * .1;
+				updateRadius(Math.max(r, g, b, .01));
+				return computeNodes;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const sharp = computeOutputs.childTexture.sample(screenUV);
+			const blurred = texture(computeOutputs.blurredTexture).sample(screenUV);
+			const redRadius$1 = uniforms.redIntensity.uniform.mul(.1);
+			const greenRadius$1 = uniforms.greenIntensity.uniform.mul(.1);
+			const blueRadius$1 = uniforms.blueIntensity.uniform.mul(.1);
+			const maxRadius = redRadius$1.max(greenRadius$1).max(blueRadius$1).max(float(.01));
+			const rMix = redRadius$1.div(maxRadius);
+			const gMix = greenRadius$1.div(maxRadius);
+			const bMix = blueRadius$1.div(maxRadius);
+			return unpremultiplyAlpha(vec4(mix(sharp.r, blurred.r, rMix), mix(sharp.g, blurred.g, gMix), mix(sharp.b, blurred.b, bMix), sharp.a));
+		}
 		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();

package/dist/core/{Crescent-DPxGWdPH.js → Crescent-BkRt-XWy.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 { i as crescentSdf } from "./sdf-Bux00UoZ.js";
+import { i as crescentSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Cross-CDyzf8TT.js → Cross-kkY7feuC.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 { a as crossSdf } from "./sdf-Bux00UoZ.js";
+import { a as crossSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Crystal-DSuN8TNY.js → Crystal-xVyUhVD-.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition } from "./transformations-B5lM6fYX.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-Bux00UoZ.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
 import { Fn, atan, clamp, convertToTexture, cos, dot, float, fract, max, min, mix, mx_worley_noise_float, pow, screenUV, sin, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var transformBoolean = (value) => value ? 1 : 0;
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({

package/dist/core/CursorRipples-Cgm7N0Bp.js

@@ -0,0 +1,289 @@
+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 { StorageTexture } from "three/webgpu";
+import { DataTexture, FloatType, LinearFilter as LinearFilter$1, RGFormat } from "three";
+import { Fn, If, attributeArray, convertToTexture, float, instanceIndex, screenUV, storageTexture, texture, textureStore, uint, uniform, uvec2, 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"
+			}
+		}
+	},
+	computeNode: ({ uniforms, onCleanup, dimensions }) => {
+		const bufferA = attributeArray(GRID_SIZE * GRID_SIZE, "float");
+		const bufferB = attributeArray(GRID_SIZE * GRID_SIZE, "float");
+		const dispTex = new StorageTexture(GRID_SIZE, GRID_SIZE);
+		dispTex.type = FloatType;
+		const dispTexNode = storageTexture(dispTex);
+		onCleanup(() => {
+			dispTex.dispose();
+		});
+		const cursorXU = uniform(.5);
+		const cursorYU = uniform(.5);
+		const mouseSpeedU = uniform(0);
+		const dtU = uniform(.016);
+		const decayU = uniform(10);
+		const radiusU = uniform(.025);
+		const aspectU = uniform(1);
+		const gs = uint(GRID_SIZE);
+		const gsm1 = uint(GRID_SIZE - 1);
+		const buildPropagateKernel = (readBuf, writeBuf) => Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			If(i.greaterThan(uint(0)).and(i.lessThan(gsm1)).and(j.greaterThan(uint(0))).and(j.lessThan(gsm1)), () => {
+				const left = readBuf.element(idx.sub(uint(1)));
+				const right = readBuf.element(idx.add(uint(1)));
+				const up = readBuf.element(idx.sub(gs));
+				const down = readBuf.element(idx.add(gs));
+				const avg = left.add(right).add(up).add(down).mul(float(.5));
+				const prev = writeBuf.element(idx);
+				const dampFactor = float(1).sub(decayU.mul(float(.004)));
+				const next = avg.sub(prev).mul(dampFactor).toVar();
+				const cellX = j.toFloat().add(float(.5)).div(float(GRID_SIZE));
+				const cellY = i.toFloat().add(float(.5)).div(float(GRID_SIZE));
+				const ddx = aspectU.greaterThanEqual(float(1)).select(cellX.sub(cursorXU).mul(aspectU), cellX.sub(cursorXU));
+				const ddy = aspectU.greaterThanEqual(float(1)).select(cellY.sub(cursorYU), cellY.sub(cursorYU).div(aspectU));
+				const distSq = ddx.mul(ddx).add(ddy.mul(ddy));
+				const influenceRadius = radiusU.mul(float(3));
+				If(distSq.lessThan(influenceRadius.mul(influenceRadius)).and(mouseSpeedU.greaterThan(float(.01))), () => {
+					const influence = distSq.negate().div(radiusU.mul(radiusU)).exp();
+					next.assign(next.sub(influence.mul(mouseSpeedU).mul(dtU).mul(float(3))));
+				});
+				writeBuf.element(idx).assign(next);
+			});
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		const buildGradientKernel = (srcBuf) => Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			If(i.greaterThan(uint(0)).and(i.lessThan(gsm1)).and(j.greaterThan(uint(0))).and(j.lessThan(gsm1)), () => {
+				const right = srcBuf.element(idx.add(uint(1)));
+				const left = srcBuf.element(idx.sub(uint(1)));
+				const down = srcBuf.element(idx.add(gs));
+				const up = srcBuf.element(idx.sub(gs));
+				const dx = right.sub(left).mul(float(.5));
+				const dy = down.sub(up).mul(float(.5));
+				textureStore(dispTexNode, uvec2(j, i), vec4(dx, dy, float(0), float(1))).toWriteOnly();
+			});
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		const propagateAtoB = buildPropagateKernel(bufferA, bufferB);
+		const gradientB = buildGradientKernel(bufferB);
+		const propagateBtoA = buildPropagateKernel(bufferB, bufferA);
+		const gradientA = buildGradientKernel(bufferA);
+		let direction = 0;
+		let prevX = .5;
+		let prevY = .5;
+		let lastTime = Date.now();
+		let lastActiveTime = Date.now();
+		return {
+			outputs: { displacement: dispTex },
+			getComputeNodes: (params) => {
+				const currentTime = Date.now();
+				const dt = Math.min((currentTime - lastTime) / 1e3, .016);
+				lastTime = currentTime;
+				const aspect = dimensions.width / dimensions.height;
+				const decay = uniforms.decay.uniform.value;
+				const radius = uniforms.radius.uniform.value * .05;
+				const rawVelX = dt > 0 ? (params.pointer.x - prevX) / dt : 0;
+				const rawVelY = dt > 0 ? (params.pointer.y - prevY) / dt : 0;
+				const mouseSpeed = Math.min(Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY), 2);
+				prevX = params.pointer.x;
+				prevY = params.pointer.y;
+				if (mouseSpeed > .01) lastActiveTime = currentTime;
+				const dampFactor = 1 - decay * .004;
+				const settleTime = dampFactor >= 1 ? Infinity : Math.min(3e4, Math.log(1e-6) / Math.log(Math.max(dampFactor, .001)) * 16.67);
+				if (currentTime - lastActiveTime > settleTime) return null;
+				cursorXU.value = params.pointer.x;
+				cursorYU.value = params.pointer.y;
+				mouseSpeedU.value = mouseSpeed;
+				dtU.value = dt;
+				decayU.value = decay;
+				radiusU.value = radius;
+				aspectU.value = aspect;
+				const nodes = direction === 0 ? [propagateAtoB, gradientB] : [propagateBtoA, gradientA];
+				direction = 1 - direction;
+				return nodes;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions, computeOutputs }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		let displacement;
+		if (computeOutputs?.displacement) displacement = texture(computeOutputs.displacement).sample(screenUV).xy;
+		else {
+			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$1;
+			displacementTexture.minFilter = LinearFilter$1;
+			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();
+			});
+			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 };