shaders 2.5.94 → 2.5.96

package/dist/core/ProgressiveBlur-B8xwWyTM.js

@@ -0,0 +1,236 @@
+import { l as transformPosition, r as transformAngle } from "./transformations-B5lM6fYX.js";
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { n as createVariableGaussianBlurCompute } from "./computeBlur-C3oX720H.js";
+import { Fn, If, clamp, convertToTexture, cos, dot, float, instanceIndex, int, max, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "ProgressiveBlur",
+	category: "Blurs",
+	description: "Blur that increases progressively in one direction",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 50,
+			description: "Maximum intensity of the blur effect",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Direction of the blur gradient (in degrees)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: 0,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point where blur begins",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		falloff: {
+			default: 1,
+			description: "Distance over which blur transitions to full strength",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Falloff",
+				group: "Effect"
+			}
+		}
+	},
+	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms }) => {
+		if (!childNode) return null;
+		if (uniforms.angle.mapComputeInfo || uniforms.falloff.mapComputeInfo) 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 aspectU = uniform(1);
+		const w = uint(texWidth);
+		const h = uint(texHeight);
+		function readScalar(entry) {
+			return entry.getCpuValue?.() ?? (typeof entry.uniform.value === "number" ? entry.uniform.value : null);
+		}
+		function updateGeometryUniforms() {
+			const angleVal = readScalar(uniforms.angle);
+			if (angleVal !== null) angleU.value = angleVal;
+			const centerXVal = uniforms.center.uniform.value?.x ?? uniforms.center.uniform.x?.value;
+			if (typeof centerXVal === "number") centerXU.value = centerXVal;
+			const centerYVal = uniforms.center.uniform.value?.y ?? uniforms.center.uniform.y?.value;
+			if (typeof centerYVal === "number") centerYU.value = centerYVal;
+			const falloffVal = readScalar(uniforms.falloff);
+			if (falloffVal !== null) falloffU.value = falloffVal;
+			aspectU.value = dimensions.width / dimensions.height;
+		}
+		const intensityMapInfo = uniforms.intensity.mapComputeInfo;
+		if (intensityMapInfo) {
+			const { sourceTexture, channel, inputMin, inputMax, outputMin, outputMax, curve } = intensityMapInfo;
+			const fillBlurMap$1 = 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 direction = vec2(angleRad.cos().div(aspectU), angleRad.sin());
+					const centerPos = vec2(centerXU, float(1).sub(centerYU));
+					const centeredUV = vec2(u, v).sub(centerPos);
+					const directionalDist = max(float(0), centeredUV.dot(direction));
+					const blurAmount = smoothstep(float(0), falloffU, directionalDist);
+					const mapSample = textureLoad(sourceTexture, uvec2(x, y), int(0));
+					let raw;
+					if (channel === "alpha") raw = mapSample.a;
+					else if (channel === "alphaInverted") raw = mapSample.a.oneMinus();
+					else if (channel === "luminanceInverted") raw = dot(mapSample.rgb, vec3(.2126, .7152, .0722)).oneMinus();
+					else raw = dot(mapSample.rgb, vec3(.2126, .7152, .0722));
+					const inputRange = inputMax.sub(inputMin).max(float(1e-4));
+					const maxRadius = 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));
+					const radius = blurAmount.mul(maxRadius);
+					textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+				});
+			})().compute(texWidth * texHeight, [256]);
+			return {
+				outputs: {
+					childTexture,
+					blurredTexture: outputTexture
+				},
+				getComputeNodes: () => {
+					updateGeometryUniforms();
+					return [fillBlurMap$1, ...blurNodes];
+				}
+			};
+		}
+		const maxRadiusU = uniform(18);
+		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 direction = vec2(angleRad.cos().div(aspectU), angleRad.sin());
+				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: () => {
+				updateGeometryUniforms();
+				const intensityVal = readScalar(uniforms.intensity);
+				if (intensityVal !== null) maxRadiusU.value = intensityVal * .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);
+			const blurred = texture(computeOutputs.blurredTexture).sample(screenUV);
+			const propsPin = uniforms.intensity.uniform.mul(float(0)).add(uniforms.angle.uniform.mul(float(0))).add(uniforms.falloff.uniform.mul(float(0)));
+			return unpremultiplyAlpha(vec4(blurred.rgb.add(propsPin), sharp.a));
+		}
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const angleRad = radians(uniforms.angle.uniform);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
+		const direction = vec2(cosAngle.div(aspect), sinAngle);
+		const centerPosition = vec2(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const centeredUV = screenUV.sub(centerPosition);
+		const directionalDist = max(float(0), centeredUV.dot(direction));
+		const falloff = max(float(.001), uniforms.falloff.uniform);
+		const blurAmount = smoothstep(float(0), falloff, directionalDist);
+		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
+		const blurRadius = blurAmount.mul(scaledIntensity);
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
+			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 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 ProgressiveBlur_default = componentDefinition;
+export { componentDefinition as n, ProgressiveBlur_default as t };

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 {

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 {