shaders 2.5.110 → 2.5.111

package/dist/core/{Bulge-Chpbxxzj.js → Bulge-6gRUYqZS.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { convertToTexture, float, length, max, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{ConcentricSpin-Crfxti93.js → ConcentricSpin-Fegtvhl6.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";

package/dist/core/{CursorRipples-D-cfjHY5.js → CursorRipples-BqtHgpEq.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { StorageTexture } from "three/webgpu";

package/dist/core/{DiffuseBlur-eyM1v3ad.js → DiffuseBlur-B-Vki4ab.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { convertToTexture, dot, fract, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{FlowField-RyqiRxyI.js → FlowField-CTWyjeXm.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";

package/dist/core/FlutedGlass-B4FlyBOn.js

@@ -0,0 +1,320 @@
+import { n as applyEdgeToUV } from "./edges-CX_lJB9R.js";
+import { a as transformColor, c as transformEdges } from "./transformations-B5lM6fYX.js";
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { PI, abs, convertToTexture, cos, exp2, float, fract, mix, pow, screenUV, sign, sin, sqrt, step, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "FlutedGlass",
+	category: "Distortions",
+	description: "Full-screen fluted glass effect — refracts content through repeating cylindrical bars",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		shape: {
+			default: "bars",
+			description: "Cross-section shape of each flute",
+			compileTime: true,
+			transform: (value) => {
+				return {
+					"bars": 0,
+					"rounded": 1,
+					"waves": 2
+				}[value] ?? 0;
+			},
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Bars",
+						value: "bars"
+					},
+					{
+						label: "Rounded",
+						value: "rounded"
+					},
+					{
+						label: "Waves",
+						value: "waves"
+					}
+				],
+				label: "Shape",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			description: "Direction of the flutes in degrees (0 = vertical bars)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		frequency: {
+			default: 10,
+			description: "Number of flutes across the longest viewport axis",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 20,
+				step: 1,
+				label: "Frequency",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: .5,
+			description: "How smoothly distortion fades from each flute centre to its edge (0 = flat middle / sharp seams, 1 = gentle curve)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		waveAmplitude: {
+			default: .06,
+			description: "How far each flute sways horizontally as it travels (Waves shape only)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .5,
+				step: .01,
+				label: "Wave Amplitude",
+				group: "Effect",
+				condition: { shape: "waves" }
+			}
+		},
+		waveFrequency: {
+			default: 1.5,
+			description: "How many sways fit along each flute (Waves shape only)",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Wave Frequency",
+				group: "Effect",
+				condition: { shape: "waves" }
+			}
+		},
+		speed: {
+			default: 0,
+			description: "Animation speed — drifts the flute pattern over time and flows wave perturbations",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .05,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		refraction: {
+			default: 1.5,
+			description: "How aggressively each flute bends content beneath it",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 4,
+				step: .01,
+				label: "Refraction",
+				group: "Effect"
+			}
+		},
+		aberration: {
+			default: .2,
+			description: "Chromatic aberration — splits RGB along the refraction direction at flute seams",
+			compileTimeWhen: (prev, next) => prev > 0 !== next > 0,
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Aberration",
+				group: "Effect"
+			}
+		},
+		lightAngle: {
+			default: 30,
+			description: "Direction the light source is coming from (0 = head-on, 90 = grazing)",
+			ui: {
+				type: "range",
+				min: -90,
+				max: 90,
+				step: 1,
+				label: "Light Angle",
+				group: "Highlight"
+			}
+		},
+		highlight: {
+			default: .2,
+			description: "Strength of the specular reflection on each flute",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Highlight",
+				group: "Highlight"
+			}
+		},
+		highlightSoftness: {
+			default: .3,
+			description: "Spread of the specular peak (0 = pin-tight, 1 = broad sheen)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Highlight Softness",
+				group: "Highlight"
+			}
+		},
+		highlightColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the specular highlight",
+			ui: {
+				type: "color",
+				label: "Highlight Color",
+				group: "Highlight"
+			}
+		},
+		edges: {
+			default: "mirror",
+			description: "How to handle edges when distortion samples beyond the canvas",
+			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: (params) => {
+		const { uniforms, childNode, onCleanup, onBeforeRender } = params;
+		if (!childNode) return vec4(0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const uvCoord = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const t = createAnimatedTime(params, uniforms.speed).negate();
+		let cosA, sinA;
+		if (uniforms.angle.uniform.isUniformNode) {
+			const cu = uniform(1);
+			const su = uniform(0);
+			const updateAngle = () => {
+				const r = uniforms.angle.uniform.value * Math.PI / 180;
+				cu.value = Math.cos(r);
+				su.value = Math.sin(r);
+			};
+			updateAngle();
+			onBeforeRender(updateAngle);
+			cosA = cu;
+			sinA = su;
+		} else {
+			const r = uniforms.angle.uniform.mul(PI).div(180);
+			cosA = cos(r);
+			sinA = sin(r);
+		}
+		const hx = uniform(0);
+		const hy = uniform(1);
+		const updateLight = () => {
+			const half = uniforms.lightAngle.uniform.value * Math.PI / 360;
+			hx.value = Math.sin(half);
+			hy.value = Math.cos(half);
+		};
+		updateLight();
+		onBeforeRender(updateLight);
+		const centered = uvCoord.sub(vec2(.5, .5));
+		const aspCorr = vec2(centered.x.mul(aspect), centered.y);
+		const u = aspCorr.x.mul(cosA).add(aspCorr.y.mul(sinA));
+		const v = aspCorr.x.mul(sinA).negate().add(aspCorr.y.mul(cosA));
+		const shapeId = uniforms.shape.uniform.value;
+		const cellPos = fract((shapeId === 2 ? u.add(sin(v.mul(uniforms.waveFrequency.uniform).mul(PI.mul(2)).add(t.mul(2))).mul(uniforms.waveAmplitude.uniform)) : u).mul(uniforms.frequency.uniform).add(t)).sub(.5).mul(2);
+		const softness = uniforms.softness.uniform;
+		const absCell = abs(cellPos).max(float(1e-4));
+		let slope;
+		switch (shapeId) {
+			case 0: {
+				const exp$1 = mix(float(16), float(4), softness);
+				slope = sign(cellPos).mul(pow(absCell, exp$1));
+				break;
+			}
+			default: {
+				const exp$1 = mix(float(8), float(3), softness);
+				slope = sign(cellPos).mul(pow(absCell, exp$1));
+			}
+		}
+		const halfCell = float(.5).div(uniforms.frequency.uniform.max(float(.001)));
+		const refrU = slope.mul(uniforms.refraction.uniform).mul(halfCell).negate();
+		const refrOffsetX = refrU.mul(cosA).div(aspect);
+		const refrOffsetY = refrU.mul(sinA);
+		const refractedUV = vec2(uvCoord.x.add(refrOffsetX), uvCoord.y.add(refrOffsetY));
+		const aberrationEnabled = typeof uniforms.aberration.uniform.value === "number" ? uniforms.aberration.uniform.value > 0 : true;
+		const chrU = refrU.mul(uniforms.aberration.uniform).mul(.5);
+		const chrOffX = chrU.mul(cosA).div(aspect);
+		const chrOffY = chrU.mul(sinA);
+		const edgeMode = uniforms.edges.uniform.value;
+		const sampleAt = (uv$1) => {
+			if (edgeMode === 1) {
+				const inX = step(float(0), uv$1.x).mul(step(uv$1.x, float(1)));
+				const inY = step(float(0), uv$1.y).mul(step(uv$1.y, float(1)));
+				return childTexture.sample(uv$1).mul(inX.mul(inY));
+			}
+			return childTexture.sample(applyEdgeToUV(uv$1, edgeMode));
+		};
+		let sampled;
+		if (!aberrationEnabled) sampled = sampleAt(refractedUV);
+		else {
+			const rUV = vec2(refractedUV.x.add(chrOffX), refractedUV.y.add(chrOffY));
+			const bUV = vec2(refractedUV.x.sub(chrOffX), refractedUV.y.sub(chrOffY));
+			const rS = sampleAt(rUV);
+			const gS = sampleAt(refractedUV);
+			const bS = sampleAt(bUV);
+			sampled = vec4(rS.r, gS.g, bS.b, gS.a);
+		}
+		const straight = unpremultiplyAlpha(sampled);
+		const baseRgb = vec3(straight.r, straight.g, straight.b);
+		const slopeSq = slope.mul(slope).min(float(1));
+		const nz = sqrt(float(1).sub(slopeSq));
+		const nDotH = slope.mul(hx).add(nz.mul(hy)).max(float(0));
+		const shininess = exp2(float(8).sub(uniforms.highlightSoftness.uniform.mul(float(7))));
+		const fresnel = pow(float(1).sub(nz), float(5));
+		const fresnelMix = float(.04).add(float(.96).mul(fresnel));
+		const spec = pow(nDotH, shininess).mul(fresnelMix).mul(uniforms.highlight.uniform);
+		const hlCol = uniforms.highlightColor.uniform;
+		const specA = spec.mul(straight.a);
+		const lit = vec3(baseRgb.x.add(hlCol.x.mul(specA)), baseRgb.y.add(hlCol.y.mul(specA)), baseRgb.z.add(hlCol.z.mul(specA)));
+		return vec4(lit.x, lit.y, lit.z, straight.a);
+	}
+};
+var FlutedGlass_default = componentDefinition;
+export { componentDefinition as n, FlutedGlass_default as t };

package/dist/core/{GridDistortion-SRyevgsp.js → GridDistortion-CVpebl48.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { StorageTexture } from "three/webgpu";

package/dist/core/{Kaleidoscope-CFWtKisp.js → Kaleidoscope-B0_OCrob.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { atan, convertToTexture, cos, float, length, mod, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{Liquify-p-_qcb1f.js → Liquify-ZMAyGUIb.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { StorageTexture } from "three/webgpu";

package/dist/core/{Mirror-B7XmfGdw.js → Mirror-Gb0fugtF.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { convertToTexture, cos, mix, screenUV, sin, step, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{Perspective-BN_OpTZq.js → Perspective-SBZzprC5.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { convertToTexture, cos, float, max, screenUV, sin, tan, vec2, vec4 } from "three/tsl";

package/dist/core/{PolarCoordinates-CMYCFT4S.js → PolarCoordinates-Ckvb1eG0.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { PI, atan, convertToTexture, length, mix, screenUV, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{RectangularCoordinates-8Sa2GaDy.js → RectangularCoordinates-r0fTwVuL.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { PI, convertToTexture, cos, mix, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{Shatter-ByKkCYTR.js → Shatter-CC3EFcP9.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { StorageTexture } from "three/webgpu";

package/dist/core/{Stretch--GV6hbru.js → Stretch-CJUUU-I1.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { clamp, convertToTexture, cos, float, mix, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{Twirl-v8pLqUTN.js → Twirl-CgRyZdT1.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { convertToTexture, cos, length, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{VideoTexture-BMSdfLf_.js → VideoTexture-Cr1f0IOE.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-CsOpQ0L_.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{WaveDistortion-BGdgj3Iz.js → WaveDistortion-iyTUI1lj.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as createAnimatedTime } from "./time-DUqSFWvT.js";

package/dist/core/{WebcamTexture-Ds9IrtRn.js → WebcamTexture-BQJpZvC5.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-CsOpQ0L_.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{edges-CfGcQniB.js → edges-CX_lJB9R.js}

@@ -1,4 +1,16 @@
 import { abs, float, fract, mod, select, step, vec2, vec4 } from "three/tsl";
+const applyEdgeToUV = (uv$1, edgeMode) => {
+	switch (edgeMode) {
+		case 1: return uv$1;
+		case 2: {
+			const mirrorX = mod(abs(uv$1.x), float(2));
+			const mirrorY = mod(abs(uv$1.y), float(2));
+			return vec2(select(step(float(1), mirrorX), float(2).sub(mirrorX), mirrorX), select(step(float(1), mirrorY), float(2).sub(mirrorY), mirrorY));
+		}
+		case 3: return fract(uv$1);
+		default: return uv$1.clamp(vec2(0, 0), vec2(1, 1));
+	}
+};
 const applyEdgeHandling = (distortedUV, sampledColor, childTexture, edgeMode) => {
 	switch (edgeMode) {
 		case 1: {
@@ -22,4 +34,4 @@ const applyEdgeHandling = (distortedUV, sampledColor, childTexture, edgeMode) =>
 		default: return sampledColor;
 	}
 };
-export { applyEdgeHandling as t };
+export { applyEdgeToUV as n, applyEdgeHandling as t };