shaders 2.5.94 → 2.5.95

package/dist/core/Liquify-cE5dxrfh.js

@@ -0,0 +1,351 @@
+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 = 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"
+			}
+		}
+	},
+	computeNode: ({ uniforms, onCleanup, dimensions }) => {
+		const bufferA = attributeArray(GRID_SIZE * GRID_SIZE, "vec4");
+		const bufferB = attributeArray(GRID_SIZE * GRID_SIZE, "vec4");
+		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 dirXU = uniform(0);
+		const dirYU = uniform(0);
+		const clampedSpeedU = uniform(0);
+		const dtU = uniform(.016);
+		const subDtU = uniform(.008);
+		const stiffnessU = uniform(3);
+		const dampFactorU = uniform(.97);
+		const radiusU = uniform(.08);
+		const aspectU = uniform(1);
+		const gs = uint(GRID_SIZE);
+		const gsm1 = uint(GRID_SIZE - 1);
+		const buildSpringKernel = (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 current = readBuf.element(idx);
+				const dispX = current.x;
+				const dispY = current.y;
+				const velX = current.z;
+				const velY = current.w;
+				const idxL = idx.sub(uint(1));
+				const idxR = idx.add(uint(1));
+				const idxU = idx.sub(gs);
+				const idxD = idx.add(gs);
+				const idxUL = idx.sub(gs).sub(uint(1));
+				const idxUR = idx.sub(gs).add(uint(1));
+				const idxDL = idx.add(gs).sub(uint(1));
+				const idxDR = idx.add(gs).add(uint(1));
+				const fx = stiffnessU.mul(readBuf.element(idxL).x.sub(dispX).add(readBuf.element(idxR).x.sub(dispX)).add(readBuf.element(idxU).x.sub(dispX)).add(readBuf.element(idxD).x.sub(dispX))).toVar();
+				const fy = stiffnessU.mul(readBuf.element(idxL).y.sub(dispY).add(readBuf.element(idxR).y.sub(dispY)).add(readBuf.element(idxU).y.sub(dispY)).add(readBuf.element(idxD).y.sub(dispY))).toVar();
+				const shearK = stiffnessU.mul(float(.35));
+				fx.assign(fx.add(shearK.mul(readBuf.element(idxUL).x.sub(dispX).add(readBuf.element(idxUR).x.sub(dispX)).add(readBuf.element(idxDL).x.sub(dispX)).add(readBuf.element(idxDR).x.sub(dispX)))));
+				fy.assign(fy.add(shearK.mul(readBuf.element(idxUL).y.sub(dispY).add(readBuf.element(idxUR).y.sub(dispY)).add(readBuf.element(idxDL).y.sub(dispY)).add(readBuf.element(idxDR).y.sub(dispY)))));
+				fx.assign(fx.sub(stiffnessU.mul(float(.1)).mul(dispX)));
+				fy.assign(fy.sub(stiffnessU.mul(float(.1)).mul(dispY)));
+				const newVelX = velX.mul(dampFactorU).add(fx.mul(subDtU)).toVar();
+				const newVelY = velY.mul(dampFactorU).add(fy.mul(subDtU)).toVar();
+				If(clampedSpeedU.greaterThan(float(.01)), () => {
+					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)), () => {
+						const forceMag = distSq.negate().div(radiusU.mul(radiusU)).exp().mul(clampedSpeedU).mul(dtU).mul(float(2));
+						newVelX.assign(newVelX.add(dirXU.mul(forceMag)));
+						newVelY.assign(newVelY.add(dirYU.mul(forceMag)));
+					});
+				});
+				const newDispX = dispX.add(newVelX.mul(subDtU)).clamp(float(-.5), float(.5));
+				const newDispY = dispY.add(newVelY.mul(subDtU)).clamp(float(-.5), float(.5));
+				writeBuf.element(idx).assign(vec4(newDispX, newDispY, newVelX, newVelY));
+			});
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		const buildOutputKernel = (srcBuf) => Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const cell = srcBuf.element(idx);
+			textureStore(dispTexNode, uvec2(j, i), vec4(cell.x, cell.y, float(0), float(1))).toWriteOnly();
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		const springAtoB = buildSpringKernel(bufferA, bufferB);
+		const springBtoA = buildSpringKernel(bufferB, bufferA);
+		const outputFromA = buildOutputKernel(bufferA);
+		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;
+				if (dt <= 0) return null;
+				const aspect = dimensions.width / Math.max(dimensions.height, 1);
+				const stiffness = uniforms.stiffness.uniform.value;
+				const damping = uniforms.damping.uniform.value;
+				const radius = uniforms.radius.uniform.value * .08;
+				const rawVelX = (params.pointer.x - prevX) / dt;
+				const rawVelY = (params.pointer.y - prevY) / dt;
+				const speed = Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY);
+				const clampedSpeed = Math.min(speed, 3);
+				prevX = params.pointer.x;
+				prevY = params.pointer.y;
+				if (clampedSpeed > .01) lastActiveTime = currentTime;
+				const dampVal = uniforms.damping.uniform.value;
+				const settleMs = dampVal > 0 ? Math.min(3e4, 5e3 / dampVal) : 3e4;
+				if (currentTime - lastActiveTime > settleMs) return null;
+				const subDt = dt / 2;
+				cursorXU.value = params.pointer.x;
+				cursorYU.value = params.pointer.y;
+				dirXU.value = speed > .01 ? rawVelX / speed : 0;
+				dirYU.value = speed > .01 ? rawVelY / speed : 0;
+				clampedSpeedU.value = clampedSpeed;
+				dtU.value = dt;
+				subDtU.value = subDt;
+				stiffnessU.value = stiffness;
+				dampFactorU.value = Math.max(0, Math.min(1, 1 - damping * subDt));
+				radiusU.value = radius;
+				aspectU.value = aspect;
+				return [
+					springAtoB,
+					springBtoA,
+					outputFromA
+				];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions, computeOutputs }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = computeOutputs?.childTexture ?? convertToTexture(childNode);
+		if (!computeOutputs) onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		let displacement;
+		if (computeOutputs?.displacement) {
+			childTexture.sample(screenUV);
+			displacement = texture(computeOutputs.displacement).sample(screenUV).xy;
+		} else {
+			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$1;
+			displacementTexture.minFilter = LinearFilter$1;
+			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 / Math.max(dimensions.height, 1);
+				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, 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, fy = 0;
+						const idxL = idx - 1, idxR = idx + 1;
+						const idxU = idx - GRID_SIZE, 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, idxUR = idx - GRID_SIZE + 1;
+						const idxDL = idx + GRID_SIZE - 1, 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();
+			});
+			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 };

package/dist/core/{Neon-CUKnkAK8.js → Neon-Dg8UfC7P.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, cos, exp, exp2, float, max, mix, pow, screenUV, sin, smoothstep, sqrt, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var _LZ = .7;
 var _INV_LIGHT_LEN = 1 / Math.sqrt(1 + _LZ * _LZ);

package/dist/core/{Polygon-C1y6Nyh4.js → Polygon-DRCs3CYs.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 { c as polygonSdf, t as circleSdf } from "./sdf-Bux00UoZ.js";
+import { c as polygonSdf, t as circleSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, mix, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

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

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

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

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

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

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