shaders 2.5.94 → 2.5.95

package/dist/core/{Emboss-nrduRrVs.js → Emboss-ClQV27Mt.js}

@@ -1,5 +1,5 @@
 import { 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, abs, clamp, convertToTexture, cos, float, max, screenUV, sin, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var _INV_LIGHT_LEN = 1 / Math.sqrt(1.49);
 var _LZN = .7 * _INV_LIGHT_LEN;

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

package/dist/core/{Glass-CRfTkmRy.js → Glass-gQCmJlsQ.js}

@@ -1,6 +1,7 @@
 import { a as transformColor, l as transformPosition } from "./transformations-B5lM6fYX.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-Bux00UoZ.js";
-import { Fn, clamp, convertToTexture, dot, exp2, float, max, mix, pow, screenUV, smoothstep, sqrt, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
+import { t as createGaussianBlurCompute } from "./computeBlur-B0KA4n89.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { Fn, clamp, convertToTexture, dot, exp2, float, max, mix, pow, screenUV, smoothstep, sqrt, texture, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var GOLDEN_ANGLE = 2.3999632297286535;
 var BLUR_SAMPLE_COUNT = 9;
 const BLUR_DISK = [];
@@ -10,7 +11,7 @@ for (let i = 0; i < BLUR_SAMPLE_COUNT; i++) {
 	BLUR_DISK.push([Math.cos(angle) * r, Math.sin(angle) * r]);
 }
 var INV_HLEN_GLASS = 1 / Math.sqrt(5);
-function applyGlassEffect(childTexture, sdfSampler, uniforms, onBeforeRender) {
+function applyGlassEffect(childTexture, sdfSampler, uniforms, onBeforeRender, blurredTexture) {
 	const lx = uniform(0);
 	const ly = uniform(0);
 	const updateLightAngle = () => {
@@ -48,7 +49,21 @@ function applyGlassEffect(childTexture, sdfSampler, uniforms, onBeforeRender) {
 		const blurEnabled = typeof uniforms.blur.uniform.value === "number" ? uniforms.blur.uniform.value > 0 : true;
 		const aberrationEnabled = typeof uniforms.aberration.uniform.value === "number" ? uniforms.aberration.uniform.value > 0 : true;
 		let blurred;
-		if (!blurEnabled && !aberrationEnabled) blurred = childTexture.sample(lensUV);
+		if (blurredTexture && blurEnabled) {
+			const blurTex = texture(blurredTexture);
+			if (!aberrationEnabled) blurred = blurTex.sample(lensUV);
+			else {
+				const chrScale = uniforms.aberration.uniform.mul(float(.06));
+				const chrOffX = offsetX.mul(chrScale);
+				const chrOffY = offsetY.mul(chrScale);
+				const rUV = lensUV.add(vec2(chrOffX, chrOffY));
+				const bUV = lensUV.sub(vec2(chrOffX, chrOffY));
+				const rSample = blurTex.sample(rUV);
+				const gSample = blurTex.sample(lensUV);
+				const bSample = blurTex.sample(bUV);
+				blurred = vec4(rSample.r, gSample.g, bSample.b, gSample.a);
+			}
+		} else if (!blurEnabled && !aberrationEnabled) blurred = childTexture.sample(lensUV);
 		else if (!blurEnabled && aberrationEnabled) {
 			const chrScale = uniforms.aberration.uniform.mul(float(.06));
 			const chrOffX = offsetX.mul(chrScale);
@@ -368,12 +383,35 @@ const componentDefinition = {
 			description: "Active SDF shape type — triggers recompile when shape is switched. When empty, derived from shape JSON at mount time."
 		}
 	},
-	fragmentNode: ({ uniforms, childNode, onCleanup, onBeforeRender }) => {
-		if (!childNode) return vec4(0);
+	computeNode: ({ uniforms, childNode, onCleanup, dimensions, renderer }) => {
+		if (!childNode) return null;
+		const blurValue = uniforms.blur.uniform.value;
+		if (typeof blurValue === "number" && blurValue <= 0) 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 currentBlur = uniforms.blur.uniform.value;
+				updateRadius(currentBlur * 2);
+				return computeNodes;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, onBeforeRender, computeOutputs }) => {
+		if (!childNode) return vec4(0);
+		const childTexture = computeOutputs?.childTexture ?? convertToTexture(childNode);
+		if (!computeOutputs) onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const blurredTexture = computeOutputs?.blurredTexture;
 		const shapeSdfUrl = uniforms.shapeSdfUrl.uniform.value;
 		const initialConfig = (() => {
 			const val = uniforms.shape.uniform.value;
@@ -389,8 +427,8 @@ const componentDefinition = {
 				};
 			}
 		})();
-		if (shapeSdfUrl) return applyGlassEffect(childTexture, createSvgSdfSampler(shapeSdfUrl, onBeforeRender, onCleanup), uniforms, onBeforeRender);
-		else return applyGlassEffect(childTexture, createAnalyticSdfSampler(uniforms.shapeType.uniform.value || initialConfig.type || "circleSDF", initialConfig, uniforms.shape, onBeforeRender), uniforms, onBeforeRender);
+		if (shapeSdfUrl) return applyGlassEffect(childTexture, createSvgSdfSampler(shapeSdfUrl, onBeforeRender, onCleanup), uniforms, onBeforeRender, blurredTexture);
+		else return applyGlassEffect(childTexture, createAnalyticSdfSampler(uniforms.shapeType.uniform.value || initialConfig.type || "circleSDF", initialConfig, uniforms.shape, onBeforeRender), uniforms, onBeforeRender, blurredTexture);
 	}
 };
 var Glass_default = componentDefinition;

package/dist/core/{Glow-CKWIRcBt.js → Glow-DvN-WnB4.js}

@@ -1,5 +1,6 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { Fn, convertToTexture, dot, float, max, screenUV, vec2, vec3, vec4, viewportSize } from "three/tsl";
+import { t as createGaussianBlurCompute } from "./computeBlur-B0KA4n89.js";
+import { Fn, convertToTexture, dot, float, max, screenUV, texture, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Glow",
 	category: "Stylize",
@@ -44,8 +45,37 @@ 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 size = uniforms.size.uniform.value;
+				updateRadius(size);
+				return computeNodes;
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const originalColor$1 = computeOutputs.childTexture.sample(screenUV);
+			const blurredColor = texture(computeOutputs.blurredTexture).sample(screenUV);
+			const luminance = dot(originalColor$1.rgb, vec3(.299, .587, .114));
+			const brightnessMask = max(float(0), luminance.sub(uniforms.threshold.uniform));
+			const intensity$1 = uniforms.intensity.uniform;
+			const glow = blurredColor.mul(brightnessMask).mul(intensity$1);
+			return unpremultiplyAlpha(vec4(originalColor$1.rgb.add(glow.rgb), max(originalColor$1.a, glow.a)));
+		}
 		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();

package/dist/core/GridDistortion-DtaRNrTZ.js

@@ -0,0 +1,278 @@
+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, 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$1;
+		dataTexture.minFilter = LinearFilter$1;
+		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"
+			}
+		}
+	},
+	computeNode: ({ uniforms, onCleanup, dimensions }) => {
+		const GRID_SIZE = uniforms?.gridSize?.uniform?.value ? Math.max(8, Math.min(128, Math.floor(uniforms.gridSize.uniform.value))) : DEFAULT_GRID_SIZE;
+		const buffer = 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 mouseVelXU = uniform(0);
+		const mouseVelYU = uniform(0);
+		const dtU = uniform(.016);
+		const decayU = uniform(3);
+		const intensityU = uniform(1);
+		const radiusU = uniform(.05);
+		const aspectU = uniform(1);
+		const gs = uint(GRID_SIZE);
+		const updatePass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const cell = buffer.element(idx);
+			const dx = cell.x.mul(float(1).sub(decayU.mul(dtU))).toVar();
+			const dy = cell.y.mul(float(1).sub(decayU.mul(dtU))).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 radius2 = radiusU.mul(float(2));
+			If(distSq.lessThan(radius2.mul(radius2)).and(mouseVelXU.abs().add(mouseVelYU.abs()).greaterThan(float(.01))), () => {
+				const influence = distSq.negate().div(radiusU.mul(radiusU)).exp();
+				dx.assign(dx.add(mouseVelXU.mul(influence).mul(intensityU).mul(dtU).mul(float(.5))));
+				dy.assign(dy.add(mouseVelYU.mul(influence).mul(intensityU).mul(dtU).mul(float(.5))));
+			});
+			dx.assign(dx.clamp(float(-1), float(1)));
+			dy.assign(dy.clamp(float(-1), float(1)));
+			buffer.element(idx).assign(vec4(dx, dy, float(0), float(0)));
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		const outputPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const cell = buffer.element(idx);
+			textureStore(dispTexNode, uvec2(j, i), vec4(cell.x, cell.y, float(0), float(1))).toWriteOnly();
+		})().compute(GRID_SIZE * GRID_SIZE, [256]);
+		let prevX = .5;
+		let prevY = .5;
+		let lastTime = Date.now();
+		let lastActiveTime = Date.now();
+		let smoothVelX = 0;
+		let smoothVelY = 0;
+		return {
+			outputs: {
+				displacement: dispTex,
+				gridSize: GRID_SIZE
+			},
+			getComputeNodes: (params) => {
+				const currentTime = Date.now();
+				const dt = Math.min((currentTime - lastTime) / 1e3, .016);
+				lastTime = currentTime;
+				const aspect = dimensions.width / Math.max(dimensions.height, 1);
+				const velX = dt > 0 ? (params.pointer.x - prevX) / dt : 0;
+				const velY = dt > 0 ? (params.pointer.y - prevY) / dt : 0;
+				smoothVelX = smoothVelX * .85 + velX * .15;
+				smoothVelY = smoothVelY * .85 + velY * .15;
+				prevX = params.pointer.x;
+				prevY = params.pointer.y;
+				if (Math.abs(velX) + Math.abs(velY) > .01) lastActiveTime = currentTime;
+				const decayVal = uniforms.decay.uniform.value;
+				const settleTime = decayVal > 0 ? Math.min(3e4, Math.log(1e-4) / Math.log(Math.max(1e-6, 1 - decayVal * .016)) * 16.67) : 3e4;
+				if (currentTime - lastActiveTime > settleTime) return null;
+				cursorXU.value = params.pointer.x;
+				cursorYU.value = params.pointer.y;
+				mouseVelXU.value = smoothVelX;
+				mouseVelYU.value = smoothVelY;
+				dtU.value = dt;
+				decayU.value = uniforms.decay.uniform.value;
+				intensityU.value = uniforms.intensity.uniform.value;
+				radiusU.value = uniforms.radius.uniform.value * .05;
+				aspectU.value = aspect;
+				return [updatePass, outputPass];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup, dimensions, computeOutputs }) => {
+		let displacementField;
+		let GRID_SIZE;
+		if (computeOutputs?.displacement) {
+			displacementField = texture(computeOutputs.displacement);
+			GRID_SIZE = computeOutputs.gridSize;
+		} else {
+			const state = getOrCreateDisplacementState(uniforms);
+			displacementField = state.tslNode;
+			GRID_SIZE = state.gridSize;
+			const { dataTexture: displacementTexture, data: displacementData } = state;
+			const mouseVelX = uniform(0);
+			const mouseVelY = uniform(0);
+			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$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 clampedDisplacement = displacement.clamp(vec2(maxDisplacement.negate(), maxDisplacement.negate()), 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 };