shaders 2.2.26 → 2.2.27

package/dist/core/GlassTiles-CA90XrNT.js

@@ -0,0 +1,67 @@
+import { add, convertToTexture, div, floor, mul, screenUV, select, sub, uniform, vec2, vec4 } from "three/tsl";
+const componentDefinition = {
+	name: "GlassTiles",
+	category: "Distortions",
+	description: "Refraction-like distortion in a tile grid pattern",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 1,
+			description: "The intensity of the glass tiles effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Intensity"
+			}
+		},
+		tileCount: {
+			default: 100,
+			description: "Number of tiles across the shortest dimension",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 200,
+				step: 1,
+				label: "Tile Count"
+			}
+		}
+	},
+	uvTransformNode: ({ uv: uv$1, uniforms, viewportSize: viewportSize$1 }) => {
+		const intensity = uniforms.intensity.uniform;
+		const baseTileCount = uniforms.tileCount.uniform;
+		const aspectRatio = viewportSize$1.x.div(viewportSize$1.y);
+		const tileCount = vec2(select(aspectRatio.greaterThanEqual(1), baseTileCount.mul(aspectRatio), baseTileCount), select(aspectRatio.lessThan(1), baseTileCount.div(aspectRatio), baseTileCount));
+		const cellCoord = floor(uv$1.mul(tileCount)).div(tileCount);
+		const localUV = uv$1.sub(cellCoord);
+		const distortionCenter = vec2(.5, .5);
+		const distortionFactor = intensity.mul(.025);
+		const distortion = localUV.div(vec2(1, 1).div(tileCount)).sub(distortionCenter).mul(distortionFactor);
+		return localUV.add(distortion).add(cellCoord);
+	},
+	fragmentNode: ({ uniforms, childNode, dimensions, onCleanup }) => {
+		if (!childNode) {
+			console.error("You must pass a child component into the Glass Tiles shader.");
+			return vec4(0);
+		}
+		const texture$1 = convertToTexture(childNode);
+		onCleanup(() => {
+			if (texture$1?.renderTarget?.dispose) texture$1.renderTarget.dispose();
+		});
+		const aspectRatioUniform = uniform(dimensions.width / dimensions.height);
+		const uvNode = screenUV;
+		const intensity = uniforms.intensity.uniform;
+		const baseTileCount = uniforms.tileCount.uniform;
+		const tileCount = vec2(aspectRatioUniform.greaterThanEqual(1).select(mul(baseTileCount, aspectRatioUniform), baseTileCount), aspectRatioUniform.lessThan(1).select(div(baseTileCount, aspectRatioUniform), baseTileCount));
+		const cellCoord = div(floor(mul(uvNode, tileCount)), tileCount);
+		const localUV = sub(uvNode, cellCoord);
+		const distortionCenter = vec2(.5, .5);
+		const distortionFactor = mul(intensity, .025);
+		const finalUV = add(add(localUV, mul(sub(div(localUV, div(vec2(1), tileCount)), distortionCenter), distortionFactor)), cellCoord);
+		return vec4(texture$1.sample(finalUV));
+	}
+};
+var GlassTiles_default = componentDefinition;
+export { componentDefinition as n, GlassTiles_default as t };

package/dist/core/{Glow-BluFc9be.js → Glow-D0boDIAW.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { Fn, convertToTexture, dot, float, max, screenUV, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Glow",
 	category: "Stylize",
@@ -41,34 +41,33 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, max: max$1, dot: dot$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, Fn } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
-		const originalColor = childTexture.sample(screenUV$1);
+		const originalColor = childTexture.sample(screenUV);
 		const glowEffect = Fn(() => {
 			const blurRadius = uniforms.size.uniform;
 			const threshold = uniforms.threshold.uniform;
-			const pixelSize = vec2$1(1).div(viewportSize$1);
-			const blurredGlow = vec4$1(0, 0, 0, 0).toVar();
+			const pixelSize = vec2(1).div(viewportSize);
+			const blurredGlow = vec4(0, 0, 0, 0).toVar();
 			const radius = 5;
 			for (let dx = -radius; dx <= radius; dx++) for (let dy = -radius; dy <= radius; dy++) {
-				const offset = vec2$1(float$1(dx), float$1(dy)).mul(pixelSize).mul(blurRadius);
-				const sampleUV = screenUV$1.add(offset);
+				const offset = vec2(float(dx), float(dy)).mul(pixelSize).mul(blurRadius);
+				const sampleUV = screenUV.add(offset);
 				const sampleColor = childTexture.sample(sampleUV);
-				const luminance = dot$1(sampleColor.rgb, vec3$1(.299, .587, .114));
-				const brightnessMask = max$1(float$1(0), luminance.sub(threshold));
+				const luminance = dot(sampleColor.rgb, vec3(.299, .587, .114));
+				const brightnessMask = max(float(0), luminance.sub(threshold));
 				const brightColor = sampleColor.mul(brightnessMask);
 				blurredGlow.assign(blurredGlow.add(brightColor));
 			}
-			const totalSamples = float$1((radius * 2 + 1) * (radius * 2 + 1));
+			const totalSamples = float((radius * 2 + 1) * (radius * 2 + 1));
 			return blurredGlow.div(totalSamples);
 		})();
 		const intensity = uniforms.intensity.uniform;
 		const intensifiedGlow = glowEffect.mul(intensity);
-		return vec4$1(originalColor.rgb.add(intensifiedGlow.rgb), max$1(originalColor.a, intensifiedGlow.a));
+		return vec4(originalColor.rgb.add(intensifiedGlow.rgb), max(originalColor.a, intensifiedGlow.a));
 	}
 };
 var Glow_default = componentDefinition;

package/dist/core/{Godrays-ChLh_vGl.js → Godrays-BQsDwU26.js}

@@ -1,5 +1,5 @@
-import { o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { o as transformPosition, r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { Fn, PI, abs, atan, clamp, float, length, mix, pow, screenUV, sin, smoothstep, time, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Godrays",
 	category: "Base Layers",
@@ -83,61 +83,60 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, sin: sin$1, atan: atan$1, length, pow: pow$1, smoothstep, mix: mix$1, clamp: clamp$1, screenUV: screenUV$1, time, PI, Fn } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
-		const shapeUV = uv.sub(centerPos);
+		const uv$1 = uvContext ?? screenUV;
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const shapeUV = uv$1.sub(centerPos);
 		const valueNoise = Fn(([st]) => {
 			const i = st.floor();
 			const f = st.fract();
 			const hash = (p) => {
-				return sin$1(p.x.mul(127.1).add(p.y.mul(311.7))).mul(43758.5453).fract();
+				return sin(p.x.mul(127.1).add(p.y.mul(311.7))).mul(43758.5453).fract();
 			};
 			const a = hash(i);
-			const b = hash(i.add(vec2$1(1, 0)));
-			const c = hash(i.add(vec2$1(0, 1)));
-			const d = hash(i.add(vec2$1(1, 1)));
+			const b = hash(i.add(vec2(1, 0)));
+			const c = hash(i.add(vec2(0, 1)));
+			const d = hash(i.add(vec2(1, 1)));
 			const u = f.mul(f).mul(f.mul(-2).add(3));
-			return mix$1(mix$1(a, b, u.x), mix$1(c, d, u.x), u.y);
+			return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
 		});
-		const raysShape = Fn(([uv$1, r, freq, intensity]) => {
-			const a = atan$1(uv$1.y, uv$1.x);
-			const left = vec2$1(a.mul(freq), r);
-			const right = vec2$1(a.mod(PI.mul(2)).mul(freq), r);
-			const nLeft = pow$1(valueNoise(left), intensity);
-			return mix$1(pow$1(valueNoise(right), intensity), nLeft, smoothstep(-.15, .15, uv$1.x));
+		const raysShape = Fn(([uv$2, r, freq, intensity]) => {
+			const a = atan(uv$2.y, uv$2.x);
+			const left = vec2(a.mul(freq), r);
+			const right = vec2(a.mod(PI.mul(2)).mul(freq), r);
+			const nLeft = pow(valueNoise(left), intensity);
+			return mix(pow(valueNoise(right), intensity), nLeft, smoothstep(-.15, .15, uv$2.x));
 		});
 		const rayEffect = Fn(() => {
 			const animTime = time.mul(uniforms.speed.uniform).mul(.2);
 			const radius = length(shapeUV);
-			const spots = float$1(6.5).mul(TSL.abs(uniforms.spotty.uniform));
-			const intensityCalc = float$1(4).sub(float$1(3).mul(clamp$1(uniforms.intensity.uniform, 0, 1)));
-			const density = float$1(6).mul(uniforms.density.uniform);
-			const accumRay = float$1(0).toVar();
+			const spots = float(6.5).mul(abs(uniforms.spotty.uniform));
+			const intensityCalc = float(4).sub(float(3).mul(clamp(uniforms.intensity.uniform, 0, 1)));
+			const density = float(6).mul(uniforms.density.uniform);
+			const accumRay = float(0).toVar();
 			const r1 = radius.mul(1).sub(animTime.mul(3));
-			const r2 = radius.mul(.5).mul(float$1(1).add(spots)).sub(animTime.mul(2));
+			const r2 = radius.mul(.5).mul(float(1).add(spots)).sub(animTime.mul(2));
 			const f1 = density.mul(5);
 			const ray = raysShape(shapeUV, r1, f1, intensityCalc).toVar();
 			ray.assign(ray.mul(raysShape(shapeUV, r2, f1.mul(4), intensityCalc)));
 			accumRay.assign(accumRay.add(ray));
 			const r3 = radius.mul(1.4).sub(animTime.mul(2.5));
-			const r4 = radius.mul(.7).mul(float$1(1).add(spots)).sub(animTime.mul(1.8));
+			const r4 = radius.mul(.7).mul(float(1).add(spots)).sub(animTime.mul(1.8));
 			const f2 = density.mul(4.5);
 			const ray2 = raysShape(shapeUV, r3, f2, intensityCalc).toVar();
 			ray2.assign(ray2.mul(raysShape(shapeUV, r4, f2.mul(3.5), intensityCalc)));
 			accumRay.assign(accumRay.add(ray2.mul(.7)));
-			return clamp$1(accumRay, 0, 1);
+			return clamp(accumRay, 0, 1);
 		})();
 		const rayColorRGB = uniforms.rayColor.uniform.rgb;
 		const rayColorA = uniforms.rayColor.uniform.a;
 		const bgColorRGB = uniforms.backgroundColor.uniform.rgb;
 		const bgColorA = uniforms.backgroundColor.uniform.a;
 		const rayAlpha = rayEffect.mul(rayColorA);
-		const finalAlpha = rayAlpha.add(bgColorA.mul(float$1(1).sub(rayAlpha)));
-		const safeAlpha = clamp$1(finalAlpha, .001, 1);
+		const finalAlpha = rayAlpha.add(bgColorA.mul(float(1).sub(rayAlpha)));
+		const safeAlpha = clamp(finalAlpha, .001, 1);
 		const rayContribution = rayColorRGB.mul(rayAlpha);
-		const bgContribution = bgColorRGB.mul(bgColorA).mul(float$1(1).sub(rayAlpha));
-		return vec4$1(rayContribution.add(bgContribution).div(safeAlpha), finalAlpha);
+		const bgContribution = bgColorRGB.mul(bgColorA).mul(float(1).sub(rayAlpha));
+		return vec4(rayContribution.add(bgContribution).div(safeAlpha), finalAlpha);
 	}
 };
 var Godrays_default = componentDefinition;

package/dist/core/{Grid-DgyDa4H1.js → Grid-CWHxwO7R.js}

@@ -1,5 +1,5 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { fract, fwidth, max, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Grid",
 	category: "Base Layers",
@@ -39,10 +39,9 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, fract, max: max$1, screenUV: screenUV$1, viewportSize: viewportSize$1, fwidth, smoothstep } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const correctedUV = vec2$1(uv.x.mul(aspect), uv.y.oneMinus());
+		const uv$1 = uvContext ?? screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const correctedUV = vec2(uv$1.x.mul(aspect), uv$1.y.oneMinus());
 		const cells = uniforms.cells.uniform;
 		const gridUV = correctedUV.mul(cells);
 		const gridFract = fract(gridUV);
@@ -50,8 +49,8 @@ const componentDefinition = {
 		const distToLineX = gridFract.x.min(gridFract.x.oneMinus());
 		const distToLineY = gridFract.y.min(gridFract.y.oneMinus());
 		const pixelSize = fwidth(gridUV);
-		const gridMask = max$1(smoothstep(lineWidth.add(pixelSize.x), lineWidth, distToLineX), smoothstep(lineWidth.add(pixelSize.y), lineWidth, distToLineY));
-		return vec4$1(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(gridMask));
+		const gridMask = max(smoothstep(lineWidth.add(pixelSize.x), lineWidth, distToLineX), smoothstep(lineWidth.add(pixelSize.y), lineWidth, distToLineY));
+		return vec4(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(gridMask));
 	}
 };
 var Grid_default = componentDefinition;

package/dist/core/{GridDistortion-BAspCYvp.js → GridDistortion-CZB9w-rv.js}

@@ -1,27 +1,27 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges } from "./transformations-DxfQXZWi.js";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges } from "./transformations-Dv5JW9ck.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
-import * as TSL from "three/tsl";
+import { convertToTexture, float, screenUV, texture, uniform, vec2, vec4 } 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.texture.dispose();
+		state.dataTexture.dispose();
 		state = void 0;
 		displacementStateCache.delete(uniforms);
 	}
 	if (!state) {
 		const data = new Float32Array(gridSize * gridSize * 2);
-		const texture = new DataTexture(data, gridSize, gridSize, RGFormat, FloatType);
-		texture.magFilter = LinearFilter;
-		texture.minFilter = LinearFilter;
-		texture.needsUpdate = true;
+		const dataTexture = new DataTexture(data, gridSize, gridSize, RGFormat, FloatType);
+		dataTexture.magFilter = LinearFilter;
+		dataTexture.minFilter = LinearFilter;
+		dataTexture.needsUpdate = true;
 		state = {
-			texture,
+			dataTexture,
 			data,
-			tslNode: TSL.texture(texture),
+			tslNode: texture(dataTexture),
 			gridSize
 		};
 		displacementStateCache.set(uniforms, state);
@@ -119,10 +119,9 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, uniform: uniform$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
-		const { texture: displacementTexture, data: displacementData, tslNode: displacementField, gridSize: GRID_SIZE } = getOrCreateDisplacementState(uniforms);
-		const mouseVelX = uniform$1(0);
-		const mouseVelY = uniform$1(0);
+		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();
@@ -168,19 +167,19 @@ const componentDefinition = {
 			displacementTexture.dispose();
 			displacementStateCache.delete(uniforms);
 		});
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
 		const gridSizeUniform = uniforms.gridSize.uniform;
-		const gridScale = float$1(1).div(gridSizeUniform);
-		const gridCellUV = screenUV$1.div(gridScale).floor().mul(gridScale).add(gridScale.mul(.5));
+		const gridScale = float(1).div(gridSizeUniform);
+		const gridCellUV = screenUV.div(gridScale).floor().mul(gridScale).add(gridScale.mul(.5));
 		const displacement = displacementField.sample(gridCellUV).xy;
-		const maxDisplacement = float$1(.1);
-		const negMaxDisplacement = float$1(-.1);
-		const clampedDisplacement = displacement.clamp(vec2$1(negMaxDisplacement, negMaxDisplacement), vec2$1(maxDisplacement, maxDisplacement));
-		const distortedUV = screenUV$1.sub(clampedDisplacement);
+		const maxDisplacement = float(.1);
+		const negMaxDisplacement = float(-.1);
+		const clampedDisplacement = displacement.clamp(vec2(negMaxDisplacement, negMaxDisplacement), vec2(maxDisplacement, maxDisplacement));
+		const distortedUV = screenUV.sub(clampedDisplacement);
 		return applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Group-Dul7PUBl.js → Group-C0AknFDS.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Group",
 	category: "Utilities",
@@ -6,8 +6,7 @@ const componentDefinition = {
 	requiresChild: true,
 	props: {},
 	fragmentNode: ({ childNode }) => {
-		const { vec4: vec4$1 } = TSL;
-		return childNode || vec4$1(0);
+		return childNode || vec4(0);
 	}
 };
 var Group_default = componentDefinition;

package/dist/core/{Halftone-Ifv5F_FT.js → Halftone-MMcLMRpL.js}

@@ -1,5 +1,5 @@
-import { n as transformAngle } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { n as transformAngle } from "./transformations-Dv5JW9ck.js";
+import { cos, dot, fract, length, radians, screenUV, sin, smoothstep, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Halftone",
 	category: "Stylize",
@@ -42,23 +42,22 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, sin: sin$1, cos: cos$1, fract, length, smoothstep, dot: dot$1, screenUV: screenUV$1, viewportSize: viewportSize$1, radians } = TSL;
-		if (!childNode) return vec4$1(0);
-		const _uv = screenUV$1;
+		if (!childNode) return vec4(0);
+		const _uv = screenUV;
 		const frequency = uniforms.frequency.uniform;
 		const angleDegrees = uniforms.angle.uniform;
 		const smoothness = uniforms.smoothness.uniform;
 		const angle = radians(angleDegrees);
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(_uv.x.mul(aspect), _uv.y);
-		const c = cos$1(angle);
-		const s = sin$1(angle);
-		const gridUV = fract(vec2$1(dot$1(aspectCorrectedUV, vec2$1(c, s.negate())), dot$1(aspectCorrectedUV, vec2$1(s, c))).mul(frequency)).sub(.5);
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(_uv.x.mul(aspect), _uv.y);
+		const c = cos(angle);
+		const s = sin(angle);
+		const gridUV = fract(vec2(dot(aspectCorrectedUV, vec2(c, s.negate())), dot(aspectCorrectedUV, vec2(s, c))).mul(frequency)).sub(.5);
 		const originalColor = childNode;
-		const dotSize = dot$1(originalColor.rgb, vec3$1(.299, .587, .114)).mul(.7).add(.15);
+		const dotSize = dot(originalColor.rgb, vec3(.299, .587, .114)).mul(.7).add(.15);
 		const dist = length(gridUV);
 		const dotPattern = smoothstep(dotSize.add(smoothness), dotSize.sub(smoothness), dist);
-		return vec4$1(originalColor.rgb.mul(dotPattern), originalColor.a.mul(dotPattern));
+		return vec4(originalColor.rgb.mul(dotPattern), originalColor.a.mul(dotPattern));
 	}
 };
 var Halftone_default = componentDefinition;

package/dist/core/{ImageTexture-DvYcQgJB.js → ImageTexture-D9OMwqAs.js}

@@ -1,5 +1,5 @@
 import { SRGBColorSpace, Texture, TextureLoader } from "three/webgpu";
-import * as TSL from "three/tsl";
+import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ImageTexture",
 	category: "Base Layers",
@@ -55,17 +55,16 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, onCleanup, onBeforeRender, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, texture, screenUV: screenUV$1, viewportSize: viewportSize$1, step: step$1, min: min$1, max: max$1 } = TSL;
-		const baseUV = uvContext ?? screenUV$1;
+		const baseUV = uvContext ?? screenUV;
 		const loader = new TextureLoader();
 		let currentUrl = "";
 		let isLoading = false;
 		const placeholderTexture = new Texture();
 		placeholderTexture.colorSpace = SRGBColorSpace;
 		const textureNode = texture(placeholderTexture);
-		const imageAspectUniform = TSL.uniform(1);
-		const imageWidthUniform = TSL.uniform(0);
-		const imageHeightUniform = TSL.uniform(0);
+		const imageAspectUniform = uniform(1);
+		const imageWidthUniform = uniform(0);
+		const imageHeightUniform = uniform(0);
 		const loadImage = (url) => {
 			if (!url || url.trim() === "" || isLoading) return;
 			isLoading = true;
@@ -114,29 +113,29 @@ const componentDefinition = {
 		onCleanup(() => {
 			placeholderTexture.dispose();
 		});
-		const uv = baseUV;
-		const viewportAspect = viewportSize$1.x.div(viewportSize$1.y);
+		const uv$1 = baseUV;
+		const viewportAspect = viewportSize.x.div(viewportSize.y);
 		const objectFitMode = uniforms.objectFit.uniform;
-		const coverScale = max$1(viewportAspect.div(imageAspectUniform), float$1(1));
-		const coverUVScale = vec2$1(imageAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
-		const containScale = min$1(viewportAspect.div(imageAspectUniform), float$1(1));
-		const containUVScale = vec2$1(imageAspectUniform.div(viewportAspect).mul(containScale), containScale);
-		const fillUVScale = vec2$1(1, 1);
-		const scaleDownScale = min$1(min$1(viewportAspect.div(imageAspectUniform), float$1(1)), min$1(viewportSize$1.x.div(imageWidthUniform), viewportSize$1.y.div(imageHeightUniform)));
-		const scaleDownUVScale = vec2$1(imageAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
-		const noneScale = min$1(viewportSize$1.x.div(imageWidthUniform), viewportSize$1.y.div(imageHeightUniform));
-		const noneUVScale = vec2$1(imageAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
-		const isCover = step$1(objectFitMode, float$1(.5));
-		const isContain = step$1(float$1(.5), objectFitMode).mul(step$1(objectFitMode, float$1(1.5)));
-		const isFill = step$1(float$1(1.5), objectFitMode).mul(step$1(objectFitMode, float$1(2.5)));
-		const isScaleDown = step$1(float$1(2.5), objectFitMode).mul(step$1(objectFitMode, float$1(3.5)));
-		const isNone = step$1(float$1(3.5), objectFitMode);
-		const uvScale = vec2$1(0).add(coverUVScale.mul(isCover)).add(containUVScale.mul(isContain)).add(fillUVScale.mul(isFill)).add(scaleDownUVScale.mul(isScaleDown)).add(noneUVScale.mul(isNone));
-		const adjustedUV = uv.sub(vec2$1(.5)).div(uvScale).add(vec2$1(.5));
-		const finalUV = vec2$1(adjustedUV.x, float$1(1).sub(adjustedUV.y));
+		const coverScale = max(viewportAspect.div(imageAspectUniform), float(1));
+		const coverUVScale = vec2(imageAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+		const containScale = min(viewportAspect.div(imageAspectUniform), float(1));
+		const containUVScale = vec2(imageAspectUniform.div(viewportAspect).mul(containScale), containScale);
+		const fillUVScale = vec2(1, 1);
+		const scaleDownScale = min(min(viewportAspect.div(imageAspectUniform), float(1)), min(viewportSize.x.div(imageWidthUniform), viewportSize.y.div(imageHeightUniform)));
+		const scaleDownUVScale = vec2(imageAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+		const noneScale = min(viewportSize.x.div(imageWidthUniform), viewportSize.y.div(imageHeightUniform));
+		const noneUVScale = vec2(imageAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+		const isCover = step(objectFitMode, float(.5));
+		const isContain = step(float(.5), objectFitMode).mul(step(objectFitMode, float(1.5)));
+		const isFill = step(float(1.5), objectFitMode).mul(step(objectFitMode, float(2.5)));
+		const isScaleDown = step(float(2.5), objectFitMode).mul(step(objectFitMode, float(3.5)));
+		const isNone = step(float(3.5), objectFitMode);
+		const uvScale = vec2(0).add(coverUVScale.mul(isCover)).add(containUVScale.mul(isContain)).add(fillUVScale.mul(isFill)).add(scaleDownUVScale.mul(isScaleDown)).add(noneUVScale.mul(isNone));
+		const adjustedUV = uv$1.sub(vec2(.5)).div(uvScale).add(vec2(.5));
+		const finalUV = vec2(adjustedUV.x, float(1).sub(adjustedUV.y));
 		const sampledColor = textureNode.sample(finalUV);
-		const isOutOfBounds = TSL.or(TSL.or(finalUV.x.lessThan(0), finalUV.x.greaterThan(1)), TSL.or(finalUV.y.lessThan(0), finalUV.y.greaterThan(1)));
-		return vec4$1(sampledColor.rgb, TSL.select(isOutOfBounds, float$1(0), sampledColor.a));
+		const isOutOfBounds = or(or(finalUV.x.lessThan(0), finalUV.x.greaterThan(1)), or(finalUV.y.lessThan(0), finalUV.y.greaterThan(1)));
+		return vec4(sampledColor.rgb, select(isOutOfBounds, float(0), sampledColor.a));
 	}
 };
 var ImageTexture_default = componentDefinition;

package/dist/core/{Invert-Fz0NtIJc.js → Invert-Bmjbp6g6.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Invert",
 	category: "Adjustments",
@@ -6,15 +6,14 @@ const componentDefinition = {
 	requiresChild: true,
 	props: {},
 	fragmentNode: ({ childNode }) => {
-		const { vec4: vec4$1, vec3: vec3$1 } = TSL;
 		if (!childNode) {
 			console.error("You must pass a child component into the Invert shader.");
-			return vec4$1(0);
+			return vec4(0);
 		}
-		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
+		const sourceColor = childNode || vec4(0, 0, 0, 0);
 		const alpha = sourceColor.a;
-		const unpremultiplied = alpha.greaterThan(0).select(sourceColor.rgb.div(alpha), vec3$1(0, 0, 0));
-		return vec4$1(vec3$1(1, 1, 1).sub(unpremultiplied).mul(alpha), alpha);
+		const unpremultiplied = alpha.greaterThan(0).select(sourceColor.rgb.div(alpha), vec3(0, 0, 0));
+		return vec4(vec3(1, 1, 1).sub(unpremultiplied).mul(alpha), alpha);
 	}
 };
 var Invert_default = componentDefinition;

package/dist/core/{LinearBlur-LmhnQoA4.js → LinearBlur-B-Ikurxt.js}

@@ -1,5 +1,5 @@
-import { n as transformAngle } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { n as transformAngle } from "./transformations-Dv5JW9ck.js";
+import { Fn, convertToTexture, cos, float, radians, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "LinearBlur",
 	category: "Blurs",
@@ -32,24 +32,23 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, viewportSize: viewportSize$1, sin: sin$1, cos: cos$1, radians, Fn, convertToTexture: convertToTexture$1 } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
 		const angleRad = radians(uniforms.angle.uniform);
-		const blurDirection = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		const blurDirection = vec2(cos(angleRad), sin(angleRad));
 		return Fn(() => {
-			const uv = screenUV$1;
-			const texel = vec2$1(1).div(viewportSize$1);
+			const uv$1 = screenUV;
+			const texel = vec2(1).div(viewportSize);
 			const blurVector = blurDirection.mul(uniforms.intensity.uniform).mul(texel).mul(2);
-			const total = vec4$1(0).toVar();
-			const totalWeight = float$1(0).toVar();
+			const total = vec4(0).toVar();
+			const totalWeight = float(0).toVar();
 			for (let i = 0; i < 32; i++) {
-				const t = float$1(i).div(float$1(31)).sub(.5).mul(2);
-				const weight = float$1(1).div(float$1(2.506628)).mul(float$1(-.5).mul(t).mul(t).div(float$1(.64)).exp());
-				const coord = uv.add(blurVector.mul(t.mul(.5)));
+				const t = float(i).div(float(31)).sub(.5).mul(2);
+				const weight = float(1).div(float(2.506628)).mul(float(-.5).mul(t).mul(t).div(float(.64)).exp());
+				const coord = uv$1.add(blurVector.mul(t.mul(.5)));
 				const sample = childTexture.sample(coord).mul(weight);
 				total.assign(total.add(sample));
 				totalWeight.assign(totalWeight.add(weight));

package/dist/core/{LinearGradient-xbloQjzt.js → LinearGradient-DV6UkhZk.js}

@@ -1,6 +1,6 @@
-import { a as transformEdges, i as transformColorSpace, n as transformAngle, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
-import * as TSL from "three/tsl";
+import { a as transformEdges, i as transformColorSpace, n as transformAngle, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { abs, cos, dot, float, fract, length, mod, normalize, radians, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "LinearGradient",
 	category: "Base Layers",
@@ -100,33 +100,32 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, cos: cos$1, sin: sin$1, dot: dot$1, radians, screenUV: screenUV$1, length, normalize, abs: abs$1, mod, fract } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const startPos = vec2$1(uniforms.start.uniform[0], uniforms.start.uniform[1].oneMinus());
-		const endPos = vec2$1(uniforms.end.uniform[0], uniforms.end.uniform[1].oneMinus());
+		const uv$1 = uvContext ?? screenUV;
+		const startPos = vec2(uniforms.start.uniform[0], uniforms.start.uniform[1].oneMinus());
+		const endPos = vec2(uniforms.end.uniform[0], uniforms.end.uniform[1].oneMinus());
 		const gradientVector = endPos.sub(startPos);
 		const gradientLength = length(gradientVector);
 		const gradientDir = normalize(gradientVector);
 		const angleRad = radians(uniforms.angle.uniform).negate();
-		const cosAngle = cos$1(angleRad);
-		const sinAngle = sin$1(angleRad);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
 		const midpoint = startPos.add(endPos).mul(.5);
-		const centeredUV = uv.sub(midpoint);
-		const t = dot$1(vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
+		const centeredUV = uv$1.sub(midpoint);
+		const t = dot(vec2(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
 		const edgeMode = uniforms.edges.uniform;
-		const stretchT = t.clamp(float$1(0), float$1(1));
-		const inBoundsX = t.greaterThanEqual(float$1(0)).select(float$1(1), float$1(0));
-		const inBoundsY = t.lessThanEqual(float$1(1)).select(float$1(1), float$1(0));
+		const stretchT = t.clamp(float(0), float(1));
+		const inBoundsX = t.greaterThanEqual(float(0)).select(float(1), float(0));
+		const inBoundsY = t.lessThanEqual(float(1)).select(float(1), float(0));
 		const inBounds = inBoundsX.mul(inBoundsY);
-		const mirrorT = mod(abs$1(t), float$1(2));
-		const finalMirrorT = mirrorT.greaterThan(float$1(1)).select(float$1(2).sub(mirrorT), mirrorT);
+		const mirrorT = mod(abs(t), float(2));
+		const finalMirrorT = mirrorT.greaterThan(float(1)).select(float(2).sub(mirrorT), mirrorT);
 		const wrapT = fract(t);
-		const isMode1OrHigher = edgeMode.greaterThanEqual(float$1(.5));
-		const isMode2OrHigher = edgeMode.greaterThanEqual(float$1(1.5));
-		const finalT = edgeMode.greaterThanEqual(float$1(2.5)).select(wrapT, isMode2OrHigher.select(finalMirrorT, isMode1OrHigher.select(t, stretchT)));
-		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float$1(0), float$1(1)), uniforms.colorSpace.uniform);
-		const finalAlpha = isMode1OrHigher.and(edgeMode.lessThan(float$1(1.5))).select(mixedColor.w.mul(inBounds), mixedColor.w);
-		return vec4$1(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
+		const isMode1OrHigher = edgeMode.greaterThanEqual(float(.5));
+		const isMode2OrHigher = edgeMode.greaterThanEqual(float(1.5));
+		const finalT = edgeMode.greaterThanEqual(float(2.5)).select(wrapT, isMode2OrHigher.select(finalMirrorT, isMode1OrHigher.select(t, stretchT)));
+		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float(0), float(1)), uniforms.colorSpace.uniform);
+		const finalAlpha = isMode1OrHigher.and(edgeMode.lessThan(float(1.5))).select(mixedColor.w.mul(inBounds), mixedColor.w);
+		return vec4(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
 	}
 };
 var LinearGradient_default = componentDefinition;