shaders 2.5.93 → 2.5.95

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 };

package/dist/core/Liquify-CqcAWBwZ.js

@@ -1,228 +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 = 64;
-const componentDefinition = {
-	name: "Liquify",
-	category: "Interactive",
-	description: "Liquid-like interactive deformation effect",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		intensity: {
-			default: 10,
-			description: "Scale of the fabric displacement effect",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 20,
-				step: .1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		stiffness: {
-			default: 3,
-			description: "Fabric rigidity (higher = stiffer canvas, lower = stretchy silk)",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 30,
-				step: .5,
-				label: "Stiffness",
-				group: "Effect"
-			}
-		},
-		damping: {
-			default: 3,
-			description: "How quickly fabric motion settles",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 10,
-				step: .1,
-				label: "Damping",
-				group: "Effect"
-			}
-		},
-		radius: {
-			default: 1,
-			description: "Cursor influence area",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 1.5,
-				step: .1,
-				label: "Radius",
-				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 displacementX = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const displacementY = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const velocityX = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const velocityY = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const tempVelocityX = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const tempVelocityY = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const tempDisplacementX = new Float32Array(GRID_SIZE * GRID_SIZE);
-		const tempDisplacementY = new Float32Array(GRID_SIZE * GRID_SIZE);
-		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();
-		const SUBSTEPS = 2;
-		onBeforeRender(({ pointer }) => {
-			const currentTime = Date.now();
-			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
-			lastTime = currentTime;
-			if (dt <= 0) return;
-			const aspect = dimensions.width / dimensions.height;
-			const stiffness = uniforms.stiffness.uniform.value;
-			const damping = uniforms.damping.uniform.value;
-			const radius = uniforms.radius.uniform.value * .08;
-			const rawVelX = (pointer.x - prevX) / dt;
-			const rawVelY = (pointer.y - prevY) / dt;
-			const speed = Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY);
-			const clampedSpeed = Math.min(speed, 3);
-			let dirX = 0;
-			let dirY = 0;
-			if (speed > .01) {
-				dirX = rawVelX / speed;
-				dirY = rawVelY / speed;
-			}
-			const subDt = dt / SUBSTEPS;
-			for (let s = 0; s < SUBSTEPS; s++) {
-				if (s === 0 && clampedSpeed > .01) {
-					const influenceRadius = radius * 3;
-					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));
-					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));
-					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 forceMag = Math.exp(-dist * dist / (radius * radius)) * clampedSpeed * dt * 2;
-							velocityX[idx] += dirX * forceMag;
-							velocityY[idx] += dirY * forceMag;
-						}
-					}
-				}
-				const dampFactor = Math.max(0, Math.min(1, 1 - damping * subDt));
-				const shearK = stiffness * .35;
-				tempVelocityX.set(velocityX);
-				tempVelocityY.set(velocityY);
-				tempDisplacementX.set(displacementX);
-				tempDisplacementY.set(displacementY);
-				for (let i = 1; i < GRID_SIZE - 1; i++) for (let j = 1; j < GRID_SIZE - 1; j++) {
-					const idx = i * GRID_SIZE + j;
-					let fx = 0;
-					let fy = 0;
-					const idxL = idx - 1;
-					const idxR = idx + 1;
-					const idxU = idx - GRID_SIZE;
-					const idxD = idx + GRID_SIZE;
-					fx += stiffness * (displacementX[idxL] - displacementX[idx]);
-					fx += stiffness * (displacementX[idxR] - displacementX[idx]);
-					fx += stiffness * (displacementX[idxU] - displacementX[idx]);
-					fx += stiffness * (displacementX[idxD] - displacementX[idx]);
-					fy += stiffness * (displacementY[idxL] - displacementY[idx]);
-					fy += stiffness * (displacementY[idxR] - displacementY[idx]);
-					fy += stiffness * (displacementY[idxU] - displacementY[idx]);
-					fy += stiffness * (displacementY[idxD] - displacementY[idx]);
-					const idxUL = idx - GRID_SIZE - 1;
-					const idxUR = idx - GRID_SIZE + 1;
-					const idxDL = idx + GRID_SIZE - 1;
-					const idxDR = idx + GRID_SIZE + 1;
-					fx += shearK * (displacementX[idxUL] - displacementX[idx]);
-					fx += shearK * (displacementX[idxUR] - displacementX[idx]);
-					fx += shearK * (displacementX[idxDL] - displacementX[idx]);
-					fx += shearK * (displacementX[idxDR] - displacementX[idx]);
-					fy += shearK * (displacementY[idxUL] - displacementY[idx]);
-					fy += shearK * (displacementY[idxUR] - displacementY[idx]);
-					fy += shearK * (displacementY[idxDL] - displacementY[idx]);
-					fy += shearK * (displacementY[idxDR] - displacementY[idx]);
-					fx -= stiffness * .1 * displacementX[idx];
-					fy -= stiffness * .1 * displacementY[idx];
-					tempVelocityX[idx] = velocityX[idx] * dampFactor + fx * subDt;
-					tempVelocityY[idx] = velocityY[idx] * dampFactor + fy * subDt;
-					tempDisplacementX[idx] = displacementX[idx] + tempVelocityX[idx] * subDt;
-					tempDisplacementY[idx] = displacementY[idx] + tempVelocityY[idx] * subDt;
-					tempDisplacementX[idx] = Math.max(-.5, Math.min(.5, tempDisplacementX[idx]));
-					tempDisplacementY[idx] = Math.max(-.5, Math.min(.5, tempDisplacementY[idx]));
-				}
-				velocityX.set(tempVelocityX);
-				velocityY.set(tempVelocityY);
-				displacementX.set(tempDisplacementX);
-				displacementY.set(tempDisplacementY);
-			}
-			for (let i = 0; i < GRID_SIZE; i++) for (let j = 0; j < GRID_SIZE; j++) {
-				const idx = i * GRID_SIZE + j;
-				const dIdx = idx * 2;
-				displacementData[dIdx] = displacementX[idx];
-				displacementData[dIdx + 1] = displacementY[idx];
-			}
-			displacementTexture.needsUpdate = true;
-			prevX = pointer.x;
-			prevY = pointer.y;
-		});
-		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 distortedUV = screenUV.sub(clampedDisplacement);
-		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
-	}
-};
-var Liquify_default = componentDefinition;
-export { componentDefinition as n, Liquify_default as t };