shaders 2.2.26 → 2.2.27

package/dist/core/{AngularBlur-Dl2gwk68.js → AngularBlur-DKFExWUF.js}

@@ -1,5 +1,5 @@
-import { o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { Fn, convertToTexture, cos, float, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "AngularBlur",
 	category: "Blurs",
@@ -32,26 +32,25 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, cos: cos$1, 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 center = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const center = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
 		const angle = uniforms.intensity.uniform.mul(.005);
 		return Fn(() => {
-			const initialCoord = screenUV$1.sub(center);
-			const total = vec4$1(0).toVar();
-			const totalWeight = float$1(0).toVar();
-			const angleStep = angle.div(float$1(31));
+			const initialCoord = screenUV.sub(center);
+			const total = vec4(0).toVar();
+			const totalWeight = float(0).toVar();
+			const angleStep = angle.div(float(31));
 			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 currentAngle = angleStep.mul(float$1(i));
-				const cosAngle = cos$1(currentAngle);
-				const sinAngle = sin$1(currentAngle);
-				const sampleCoord = vec2$1(initialCoord.x.mul(cosAngle).sub(initialCoord.y.mul(sinAngle)), initialCoord.x.mul(sinAngle).add(initialCoord.y.mul(cosAngle))).add(center);
+				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 currentAngle = angleStep.mul(float(i));
+				const cosAngle = cos(currentAngle);
+				const sinAngle = sin(currentAngle);
+				const sampleCoord = vec2(initialCoord.x.mul(cosAngle).sub(initialCoord.y.mul(sinAngle)), initialCoord.x.mul(sinAngle).add(initialCoord.y.mul(cosAngle))).add(center);
 				const sample = childTexture.sample(sampleCoord).mul(weight);
 				total.assign(total.add(sample));
 				totalWeight.assign(totalWeight.add(weight));

package/dist/core/{Ascii-DsuNLJKv.js → Ascii-BRApYlD4.js}

@@ -1,5 +1,5 @@
 import { DataTexture, NearestFilter, RGBAFormat, UnsignedByteType } from "three";
-import * as TSL from "three/tsl";
+import { abs, any, ceil, convertToTexture, dot, float, floor, fract, greaterThan, or, screenUV, select, sqrt, texture, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Ascii",
 	category: "Stylize",
@@ -78,9 +78,8 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup, onBeforeRender }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, floor: floor$1, fract, dot: dot$1, ceil, sqrt: sqrt$1, screenUV: screenUV$1, texture, viewportSize: viewportSize$1, 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();
 		});
@@ -188,9 +187,9 @@ const componentDefinition = {
 		atlasTexture.generateMipmaps = false;
 		atlasTexture.needsUpdate = true;
 		const atlasField = texture(atlasTexture);
-		const charCountUniform = TSL.uniform(atlasData.charCount);
-		const cellSizeUniform = TSL.uniform(atlasData.cellSize);
-		const atlasScaleUniform = TSL.uniform(atlasData.uvScale);
+		const charCountUniform = uniform(atlasData.charCount);
+		const cellSizeUniform = uniform(atlasData.cellSize);
+		const atlasScaleUniform = uniform(atlasData.uvScale);
 		let lastCharacters = initialCharacters;
 		let lastCellSize = initialCellSize;
 		let lastFontFamily = initialFontFamily;
@@ -258,28 +257,28 @@ const componentDefinition = {
 			atlasTexture.dispose();
 		});
 		const effectiveCellSize = cellSizeUniform.mul(1.5);
-		const mainGridSize = viewportSize$1.div(effectiveCellSize);
-		const gridCoords = screenUV$1.mul(mainGridSize);
-		const cellCoords = floor$1(gridCoords);
+		const mainGridSize = viewportSize.div(effectiveCellSize);
+		const gridCoords = screenUV.mul(mainGridSize);
+		const cellCoords = floor(gridCoords);
 		const rawCellUV = fract(gridCoords);
-		const characterSize = uniforms.spacing?.uniform ?? TSL.uniform(initialSpacing);
-		const center = vec2$1(.5);
+		const characterSize = uniforms.spacing?.uniform ?? uniform(initialSpacing);
+		const center = vec2(.5);
 		const centeredUV = rawCellUV.sub(center);
 		const cellUV = centeredUV.div(characterSize).add(center);
-		const isOutsideBounds = TSL.any(TSL.greaterThan(TSL.abs(centeredUV), vec2$1(characterSize.mul(.5))));
-		const cellCenter = cellCoords.add(vec2$1(.5)).div(mainGridSize);
+		const isOutsideBounds = any(greaterThan(abs(centeredUV), vec2(characterSize.mul(.5))));
+		const cellCenter = cellCoords.add(vec2(.5)).div(mainGridSize);
 		const cellColor = childTexture.sample(cellCenter);
-		const rawBrightness = dot$1(cellColor.rgb, vec3$1(.299, .587, .114));
+		const rawBrightness = dot(cellColor.rgb, vec3(.299, .587, .114));
 		const charCount = charCountUniform;
-		const charIndex = floor$1(rawBrightness.mul(.8).add(.1).mul(charCount).min(charCount.sub(1e-4)));
-		const atlasSize = ceil(sqrt$1(charCount));
+		const charIndex = floor(rawBrightness.mul(.8).add(.1).mul(charCount).min(charCount.sub(1e-4)));
+		const atlasSize = ceil(sqrt(charCount));
 		const atlasCol = charIndex.mod(atlasSize);
-		const atlasRow = floor$1(charIndex.div(atlasSize));
-		const atlasCellSize = TSL.float(1).div(atlasSize).mul(atlasScaleUniform);
-		const atlasSampleUV = vec2$1(atlasCol, atlasRow).mul(atlasCellSize).add(cellUV.mul(atlasCellSize));
+		const atlasRow = floor(charIndex.div(atlasSize));
+		const atlasCellSize = float(1).div(atlasSize).mul(atlasScaleUniform);
+		const atlasSampleUV = vec2(atlasCol, atlasRow).mul(atlasCellSize).add(cellUV.mul(atlasCellSize));
 		const asciiChar = atlasField.sample(atlasSampleUV);
-		const isBackground = dot$1(asciiChar.rgb, vec3$1(.299, .587, .114)).lessThan(.1);
-		return vec4$1(asciiChar.rgb.mul(cellColor.rgb), TSL.select(TSL.or(isBackground, isOutsideBounds), TSL.float(0), cellColor.a));
+		const isBackground = dot(asciiChar.rgb, vec3(.299, .587, .114)).lessThan(.1);
+		return vec4(asciiChar.rgb.mul(cellColor.rgb), select(or(isBackground, isOutsideBounds), float(0), cellColor.a));
 	}
 };
 var Ascii_default = componentDefinition;

package/dist/core/{Beam-CTN9Ni43.js → Beam-DU7wxmIh.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, 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 { i as transformColorSpace, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { clamp, float, max, mix, pow, screenUV, smoothstep, sqrt, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Beam",
 	category: "Base Layers",
@@ -105,34 +105,33 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, viewportSize: viewportSize$1, sqrt: sqrt$1, max: max$1, smoothstep, mix: mix$1, clamp: clamp$1, pow: pow$1 } = TSL;
-		const baseUV = uvContext ?? screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const startPos = vec2$1(uniforms.startPosition.uniform.x, uniforms.startPosition.uniform.y.oneMinus());
-		const endPos = vec2$1(uniforms.endPosition.uniform.x, uniforms.endPosition.uniform.y.oneMinus());
-		const aspectCorrectedStart = vec2$1(startPos.x.mul(aspect), startPos.y);
-		const aspectCorrectedEnd = vec2$1(endPos.x.mul(aspect), endPos.y);
-		const aspectCorrectedUV = vec2$1(baseUV.x.mul(aspect), baseUV.y);
-		const lineVec = vec2$1(aspectCorrectedEnd.x.sub(aspectCorrectedStart.x), aspectCorrectedEnd.y.sub(aspectCorrectedStart.y));
-		const toPoint = vec2$1(aspectCorrectedUV.x.sub(aspectCorrectedStart.x), aspectCorrectedUV.y.sub(aspectCorrectedStart.y));
+		const baseUV = uvContext ?? screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const startPos = vec2(uniforms.startPosition.uniform.x, uniforms.startPosition.uniform.y.oneMinus());
+		const endPos = vec2(uniforms.endPosition.uniform.x, uniforms.endPosition.uniform.y.oneMinus());
+		const aspectCorrectedStart = vec2(startPos.x.mul(aspect), startPos.y);
+		const aspectCorrectedEnd = vec2(endPos.x.mul(aspect), endPos.y);
+		const aspectCorrectedUV = vec2(baseUV.x.mul(aspect), baseUV.y);
+		const lineVec = vec2(aspectCorrectedEnd.x.sub(aspectCorrectedStart.x), aspectCorrectedEnd.y.sub(aspectCorrectedStart.y));
+		const toPoint = vec2(aspectCorrectedUV.x.sub(aspectCorrectedStart.x), aspectCorrectedUV.y.sub(aspectCorrectedStart.y));
 		const dotProduct = toPoint.x.mul(lineVec.x).add(toPoint.y.mul(lineVec.y));
 		const lineLengthSq = lineVec.x.mul(lineVec.x).add(lineVec.y.mul(lineVec.y));
-		const t = clamp$1(dotProduct.div(max$1(lineLengthSq, float$1(1e-4))), float$1(0), float$1(1));
-		const closestPoint = vec2$1(aspectCorrectedStart.x.add(lineVec.x.mul(t)), aspectCorrectedStart.y.add(lineVec.y.mul(t)));
-		const distVec = vec2$1(aspectCorrectedUV.x.sub(closestPoint.x), aspectCorrectedUV.y.sub(closestPoint.y));
-		const distance = sqrt$1(distVec.x.mul(distVec.x).add(distVec.y.mul(distVec.y)));
-		const thickness = mix$1(uniforms.startThickness.uniform.mul(.25), uniforms.endThickness.uniform.mul(.25), t);
+		const t = clamp(dotProduct.div(max(lineLengthSq, float(1e-4))), float(0), float(1));
+		const closestPoint = vec2(aspectCorrectedStart.x.add(lineVec.x.mul(t)), aspectCorrectedStart.y.add(lineVec.y.mul(t)));
+		const distVec = vec2(aspectCorrectedUV.x.sub(closestPoint.x), aspectCorrectedUV.y.sub(closestPoint.y));
+		const distance$1 = sqrt(distVec.x.mul(distVec.x).add(distVec.y.mul(distVec.y)));
+		const thickness = mix(uniforms.startThickness.uniform.mul(.25), uniforms.endThickness.uniform.mul(.25), t);
 		const startSoft = uniforms.startSoftness.uniform;
 		const endSoft = uniforms.endSoftness.uniform;
-		const softness = mix$1(startSoft, endSoft, t);
-		const normalizedDist = distance.div(max$1(thickness, float$1(1e-4)));
-		const edgeEnd = float$1(1).add(softness);
-		const alpha = pow$1(float$1(1).sub(smoothstep(float$1(1), edgeEnd, normalizedDist)), float$1(1).add(softness.mul(1.5)));
-		const colorT = smoothstep(float$1(1).sub(softness), float$1(1).add(softness), normalizedDist);
+		const softness = mix(startSoft, endSoft, t);
+		const normalizedDist = distance$1.div(max(thickness, float(1e-4)));
+		const edgeEnd = float(1).add(softness);
+		const alpha = pow(float(1).sub(smoothstep(float(1), edgeEnd, normalizedDist)), float(1).add(softness.mul(1.5)));
+		const colorT = smoothstep(float(1).sub(softness), float(1).add(softness), normalizedDist);
 		const insideCol = uniforms.insideColor.uniform;
 		const outsideCol = uniforms.outsideColor.uniform;
 		const beamColorRGB = mixColors(insideCol, outsideCol, colorT, uniforms.colorSpace.uniform).rgb;
-		return vec4$1(beamColorRGB, insideCol.a.add(outsideCol.a).div(float$1(2)).mul(alpha));
+		return vec4(beamColorRGB, insideCol.a.add(outsideCol.a).div(float(2)).mul(alpha));
 	}
 };
 var Beam_default = componentDefinition;

package/dist/core/{Blob-CxFDZovO.js → Blob-nssNzEgN.js}

@@ -1,7 +1,7 @@
 import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
-import { i as transformColorSpace, 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 { i as transformColorSpace, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { dot, float, length, max, normalize, pow, reflect, screenUV, sin, smoothstep, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Blob",
 	category: "Base Layers",
@@ -159,8 +159,7 @@ const componentDefinition = {
 	},
 	fragmentNode: (params) => {
 		const { uniforms, uvContext } = params;
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, smoothstep, sin: sin$1, length, viewportSize: viewportSize$1, pow: pow$1, max: max$1, normalize, dot: dot$1, reflect } = TSL;
-		const baseUV = uvContext ?? screenUV$1;
+		const baseUV = uvContext ?? screenUV;
 		const animTime = createAnimatedTime(params, uniforms.speed, uniforms.seed);
 		const colorA = uniforms.colorA.uniform;
 		const colorB = uniforms.colorB.uniform;
@@ -172,46 +171,46 @@ const componentDefinition = {
 		const highlightY = uniforms.highlightY.uniform;
 		const highlightZ = uniforms.highlightZ.uniform;
 		const highlightColor = uniforms.highlightColor.uniform;
-		const edgeWidth = softness.mul(float$1(.3));
-		const edgeCurve = softness.mul(float$1(2)).add(float$1(.5));
-		const edgeComplexity = float$1(.5);
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(baseUV.x.mul(aspect), baseUV.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
-		const uv = aspectCorrectedUV.sub(centerPos);
-		const dist = length(uv);
+		const edgeWidth = softness.mul(float(.3));
+		const edgeCurve = softness.mul(float(2)).add(float(.5));
+		const edgeComplexity = float(.5);
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(baseUV.x.mul(aspect), baseUV.y);
+		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const uv$1 = aspectCorrectedUV.sub(centerPos);
+		const dist = length(uv$1);
 		const baseRadius = size;
-		const noiseScale = float$1(4);
-		const noise1 = sin$1(uv.x.mul(noiseScale.mul(float$1(.8))).add(animTime.mul(float$1(.8)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(.7))).add(animTime.mul(float$1(.6))))).add(sin$1(uv.x.mul(noiseScale.mul(float$1(1.2))).sub(uv.y.mul(noiseScale.mul(float$1(.9))).add(animTime.mul(float$1(.4)))))).mul(float$1(.15)).mul(deformation);
-		const noise2 = sin$1(uv.x.mul(noiseScale.mul(float$1(1.4))).sub(animTime.mul(float$1(.5)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(1.1))).add(animTime.mul(float$1(.7))))).mul(float$1(.12)).mul(deformation).mul(smoothstep(float$1(.15), float$1(.25), edgeComplexity));
-		const noise3 = sin$1(uv.x.mul(noiseScale.mul(float$1(1.8))).add(uv.y.mul(noiseScale.mul(float$1(1.6))).add(animTime.mul(float$1(.3))))).add(sin$1(uv.x.mul(noiseScale.mul(float$1(.6))).sub(animTime.mul(float$1(.9))))).mul(float$1(.1)).mul(deformation).mul(smoothstep(float$1(.3), float$1(.4), edgeComplexity));
-		const noise4 = sin$1(uv.x.mul(noiseScale.mul(float$1(2.2))).add(animTime.mul(float$1(.2)))).mul(sin$1(uv.y.mul(noiseScale.mul(float$1(1.9))).sub(animTime.mul(float$1(.8))))).mul(float$1(.08)).mul(deformation).mul(smoothstep(float$1(.45), float$1(.55), edgeComplexity));
-		const noise5 = sin$1(uv.x.mul(noiseScale.mul(float$1(2.8))).sub(uv.y.mul(noiseScale.mul(float$1(2.4))).add(animTime.mul(float$1(.6))))).mul(float$1(.06)).mul(deformation).mul(smoothstep(float$1(.6), float$1(.7), edgeComplexity));
-		const noise6 = sin$1(uv.x.mul(noiseScale.mul(float$1(3.2))).add(animTime.mul(float$1(1.1)))).add(sin$1(uv.y.mul(noiseScale.mul(float$1(3.5))).sub(animTime.mul(float$1(.4))))).mul(float$1(.04)).mul(deformation).mul(smoothstep(float$1(.75), float$1(.85), edgeComplexity));
+		const noiseScale = float(4);
+		const noise1 = sin(uv$1.x.mul(noiseScale.mul(float(.8))).add(animTime.mul(float(.8)))).mul(sin(uv$1.y.mul(noiseScale.mul(float(.7))).add(animTime.mul(float(.6))))).add(sin(uv$1.x.mul(noiseScale.mul(float(1.2))).sub(uv$1.y.mul(noiseScale.mul(float(.9))).add(animTime.mul(float(.4)))))).mul(float(.15)).mul(deformation);
+		const noise2 = sin(uv$1.x.mul(noiseScale.mul(float(1.4))).sub(animTime.mul(float(.5)))).mul(sin(uv$1.y.mul(noiseScale.mul(float(1.1))).add(animTime.mul(float(.7))))).mul(float(.12)).mul(deformation).mul(smoothstep(float(.15), float(.25), edgeComplexity));
+		const noise3 = sin(uv$1.x.mul(noiseScale.mul(float(1.8))).add(uv$1.y.mul(noiseScale.mul(float(1.6))).add(animTime.mul(float(.3))))).add(sin(uv$1.x.mul(noiseScale.mul(float(.6))).sub(animTime.mul(float(.9))))).mul(float(.1)).mul(deformation).mul(smoothstep(float(.3), float(.4), edgeComplexity));
+		const noise4 = sin(uv$1.x.mul(noiseScale.mul(float(2.2))).add(animTime.mul(float(.2)))).mul(sin(uv$1.y.mul(noiseScale.mul(float(1.9))).sub(animTime.mul(float(.8))))).mul(float(.08)).mul(deformation).mul(smoothstep(float(.45), float(.55), edgeComplexity));
+		const noise5 = sin(uv$1.x.mul(noiseScale.mul(float(2.8))).sub(uv$1.y.mul(noiseScale.mul(float(2.4))).add(animTime.mul(float(.6))))).mul(float(.06)).mul(deformation).mul(smoothstep(float(.6), float(.7), edgeComplexity));
+		const noise6 = sin(uv$1.x.mul(noiseScale.mul(float(3.2))).add(animTime.mul(float(1.1)))).add(sin(uv$1.y.mul(noiseScale.mul(float(3.5))).sub(animTime.mul(float(.4))))).mul(float(.04)).mul(deformation).mul(smoothstep(float(.75), float(.85), edgeComplexity));
 		const noiseAmount = noise1.add(noise2).add(noise3).add(noise4).add(noise5).add(noise6);
 		const organicRadius = baseRadius.add(noiseAmount);
-		const blobMask = pow$1(smoothstep(organicRadius.add(edgeWidth), organicRadius.sub(edgeWidth), dist), edgeCurve);
-		const distFromCenter = length(uv);
+		const blobMask = pow(smoothstep(organicRadius.add(edgeWidth), organicRadius.sub(edgeWidth), dist), edgeCurve);
+		const distFromCenter = length(uv$1);
 		const sphereRadius = organicRadius;
-		const normalTilt = smoothstep(float$1(0), sphereRadius, distFromCenter);
-		const fakeZ = float$1(1).sub(normalTilt.mul(float$1(.1)));
-		const surfaceNormal = normalize(vec3$1(uv.x.mul(normalTilt.add(float$1(.2))), uv.y.mul(normalTilt.add(float$1(.2))), fakeZ));
-		const lightDir = normalize(vec3$1(highlightX, highlightY, highlightZ));
-		const viewDir = vec3$1(float$1(0), float$1(0), float$1(1));
+		const normalTilt = smoothstep(float(0), sphereRadius, distFromCenter);
+		const fakeZ = float(1).sub(normalTilt.mul(float(.1)));
+		const surfaceNormal = normalize(vec3(uv$1.x.mul(normalTilt.add(float(.2))), uv$1.y.mul(normalTilt.add(float(.2))), fakeZ));
+		const lightDir = normalize(vec3(highlightX, highlightY, highlightZ));
+		const viewDir = vec3(float(0), float(0), float(1));
 		const reflectDir = reflect(lightDir.negate(), surfaceNormal);
-		const specularPower = float$1(32);
-		const specular = pow$1(max$1(float$1(0), dot$1(reflectDir, viewDir)), specularPower);
-		const curvatureBoost = normalTilt.mul(float$1(.5)).add(float$1(.5));
+		const specularPower = float(32);
+		const specular = pow(max(float(0), dot(reflectDir, viewDir)), specularPower);
+		const curvatureBoost = normalTilt.mul(float(.5)).add(float(.5));
 		const finalHighlight = specular.mul(curvatureBoost).mul(highlightIntensity).mul(blobMask);
-		const posX = uv.x.mul(float$1(3));
-		const posY = uv.y.mul(float$1(3));
-		const colorNoise1 = sin$1(posX.add(animTime.mul(float$1(.4)))).mul(sin$1(posY.add(animTime.mul(float$1(.3))))).add(sin$1(posX.mul(float$1(.7)).add(posY.mul(float$1(.8))).add(animTime.mul(float$1(.2))))).mul(float$1(.5)).add(float$1(.5));
-		const colorNoise2 = sin$1(posX.mul(float$1(1.3)).sub(animTime.mul(float$1(.5)))).mul(sin$1(posY.mul(float$1(1.1)).add(animTime.mul(float$1(.6))))).add(sin$1(posX.mul(float$1(.5)).sub(posY.mul(float$1(.6)).sub(animTime.mul(float$1(.3)))))).mul(float$1(.5)).add(float$1(.5));
-		const combinedNoise = colorNoise1.mul(float$1(.6)).add(colorNoise2.mul(float$1(.4)));
-		const finalColorRGB = mixColors(colorA, colorB, smoothstep(float$1(.1), float$1(.9), combinedNoise), uniforms.colorSpace.uniform).rgb;
-		const avgAlpha = colorA.a.add(colorB.a).div(float$1(2));
+		const posX = uv$1.x.mul(float(3));
+		const posY = uv$1.y.mul(float(3));
+		const colorNoise1 = sin(posX.add(animTime.mul(float(.4)))).mul(sin(posY.add(animTime.mul(float(.3))))).add(sin(posX.mul(float(.7)).add(posY.mul(float(.8))).add(animTime.mul(float(.2))))).mul(float(.5)).add(float(.5));
+		const colorNoise2 = sin(posX.mul(float(1.3)).sub(animTime.mul(float(.5)))).mul(sin(posY.mul(float(1.1)).add(animTime.mul(float(.6))))).add(sin(posX.mul(float(.5)).sub(posY.mul(float(.6)).sub(animTime.mul(float(.3)))))).mul(float(.5)).add(float(.5));
+		const combinedNoise = colorNoise1.mul(float(.6)).add(colorNoise2.mul(float(.4)));
+		const finalColorRGB = mixColors(colorA, colorB, smoothstep(float(.1), float(.9), combinedNoise), uniforms.colorSpace.uniform).rgb;
+		const avgAlpha = colorA.a.add(colorB.a).div(float(2));
 		const highlightContribution = highlightColor.rgb.mul(finalHighlight);
-		return vec4$1(finalColorRGB.add(highlightContribution), avgAlpha.mul(blobMask));
+		return vec4(finalColorRGB.add(highlightContribution), avgAlpha.mul(blobMask));
 	}
 };
 var Blob_default = componentDefinition;

package/dist/core/{Blur-Y2FsmFk_.js → Blur-k37gOaRA.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { Fn, convertToTexture, float, screenUV, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Blur",
 	category: "Blurs",
@@ -17,9 +17,8 @@ const componentDefinition = {
 		}
 	} },
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$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();
 		});
@@ -40,15 +39,15 @@ const componentDefinition = {
 		];
 		const weightSum = 6.214;
 		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
-		const horizontalTexture = convertToTexture$1(Fn(() => {
-			const uv = screenUV$1;
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
 			const blurRadius = scaledIntensity;
-			const pixelSize = vec2$1(1).div(viewportSize$1);
-			const total = vec4$1(0).toVar();
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
 			for (let x = -6; x <= 6; x++) {
-				const weight = float$1(weights[x + 6] / weightSum);
-				const offset = vec2$1(float$1(x), float$1(0)).mul(blurRadius).mul(pixelSize);
-				const sampleCoord = uv.add(offset);
+				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));
 			}
@@ -58,14 +57,14 @@ const componentDefinition = {
 			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
 		});
 		return Fn(() => {
-			const uv = screenUV$1;
+			const uv$1 = screenUV;
 			const blurRadius = scaledIntensity;
-			const pixelSize = vec2$1(1).div(viewportSize$1);
-			const total = vec4$1(0).toVar();
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
 			for (let y = -6; y <= 6; y++) {
-				const weight = float$1(weights[y + 6] / weightSum);
-				const offset = vec2$1(float$1(0), float$1(y)).mul(blurRadius).mul(pixelSize);
-				const sampleCoord = uv.add(offset);
+				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));
 			}

package/dist/core/{Bulge-Cb-t0xqI.js → Bulge-Dm02_fG6.js}

@@ -1,6 +1,6 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges, o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges, o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { convertToTexture, float, length, max, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Bulge",
 	category: "Distortions",
@@ -81,50 +81,48 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
-		const { vec2: vec2$1, length, smoothstep, float: float$1, max: max$1 } = TSL;
+	uvTransformNode: ({ uv: uv$1, uniforms, viewportSize: viewportSize$1 }) => {
 		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(uv.x.mul(aspect), uv.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const aspectCorrectedUV = vec2(uv$1.x.mul(aspect), uv$1.y);
+		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
 		const delta = aspectCorrectedUV.sub(centerPos);
-		const distance = length(delta);
+		const distance$1 = length(delta);
 		const effectRadius = uniforms.radius.uniform.mul(.5);
 		const falloffAmount = uniforms.falloff.uniform;
-		const smoothFalloff = smoothstep(effectRadius.mul(float$1(1).sub(falloffAmount).sub(float$1(.001)).max(float$1(0))), effectRadius, distance).oneMinus();
-		const normalizedDist = distance.div(effectRadius);
+		const smoothFalloff = smoothstep(effectRadius.mul(float(1).sub(falloffAmount).sub(float(.001)).max(float(0))), effectRadius, distance$1).oneMinus();
+		const normalizedDist = distance$1.div(effectRadius);
 		const distSq = normalizedDist.mul(normalizedDist);
-		const quadraticFalloff = max$1(float$1(0), float$1(1).sub(distSq));
+		const quadraticFalloff = max(float(0), float(1).sub(distSq));
 		const falloff = smoothFalloff.mul(quadraticFalloff);
 		const displacementAmount = uniforms.strength.uniform.negate().mul(falloff);
-		const scaleFactor = float$1(1).add(displacementAmount);
+		const scaleFactor = float(1).add(displacementAmount);
 		const bulgedDelta = delta.mul(scaleFactor);
 		const bulgedUV = centerPos.add(bulgedDelta);
-		return vec2$1(bulgedUV.x.div(aspect), bulgedUV.y);
+		return vec2(bulgedUV.x.div(aspect), bulgedUV.y);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, length, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, smoothstep } = 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 aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(screenUV$1.x.mul(aspect), screenUV$1.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(screenUV.x.mul(aspect), screenUV.y);
+		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
 		const delta = aspectCorrectedUV.sub(centerPos);
-		const distance = length(delta);
+		const distance$1 = length(delta);
 		const effectRadius = uniforms.radius.uniform.mul(.5);
 		const falloffAmount = uniforms.falloff.uniform;
-		const smoothFalloff = smoothstep(effectRadius.mul(TSL.float(1).sub(falloffAmount).sub(TSL.float(.001)).max(TSL.float(0))), effectRadius, distance).oneMinus();
-		const normalizedDist = distance.div(effectRadius);
+		const smoothFalloff = smoothstep(effectRadius.mul(float(1).sub(falloffAmount).sub(float(.001)).max(float(0))), effectRadius, distance$1).oneMinus();
+		const normalizedDist = distance$1.div(effectRadius);
 		const distSq = normalizedDist.mul(normalizedDist);
-		const quadraticFalloff = TSL.max(TSL.float(0), TSL.float(1).sub(distSq));
+		const quadraticFalloff = max(float(0), float(1).sub(distSq));
 		const falloff = smoothFalloff.mul(quadraticFalloff);
 		const displacementAmount = uniforms.strength.uniform.negate().mul(falloff);
-		const scaleFactor = TSL.float(1).add(displacementAmount);
+		const scaleFactor = float(1).add(displacementAmount);
 		const bulgedDelta = delta.mul(scaleFactor);
 		const bulgedUV = centerPos.add(bulgedDelta);
-		const finalUV = vec2$1(bulgedUV.x.div(aspect), bulgedUV.y);
+		const finalUV = vec2(bulgedUV.x.div(aspect), bulgedUV.y);
 		return applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{CRTScreen-CtERsenz.js → CRTScreen-DLy8Rig6.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { convertToTexture, float, fract, length, screenUV, sin, smoothstep, vec2, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "CRTScreen",
 	category: "Stylize",
@@ -74,9 +74,8 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, fract, smoothstep, length, 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();
 		});
@@ -86,26 +85,26 @@ const componentDefinition = {
 		const scanlineFrequency = uniforms.scanlineFrequency.uniform;
 		const brightness = uniforms.brightness.uniform;
 		const contrast = uniforms.contrast.uniform;
-		const scaledColorShift = colorShift.mul(float$1(.002));
-		const redUV = screenUV$1.add(vec2$1(scaledColorShift, float$1(0)));
-		const greenUV = screenUV$1;
-		const blueUV = screenUV$1.sub(vec2$1(scaledColorShift, float$1(0)));
+		const scaledColorShift = colorShift.mul(float(.002));
+		const redUV = screenUV.add(vec2(scaledColorShift, float(0)));
+		const greenUV = screenUV;
+		const blueUV = screenUV.sub(vec2(scaledColorShift, float(0)));
 		const redSample = childTexture.sample(redUV).r;
 		const greenSample = childTexture.sample(greenUV).g;
 		const blueSample = childTexture.sample(blueUV).b;
-		const adjustedColor = vec3$1(redSample, greenSample, blueSample).sub(float$1(.5)).mul(contrast).add(float$1(.5)).mul(brightness);
-		const scanlineWave = sin$1(screenUV$1.y.mul(scanlineFrequency).mul(float$1(3.14159 * 2)));
-		const scanlineEffect = float$1(1).sub(scanlineIntensity.mul(scanlineWave.mul(float$1(.5)).add(float$1(.5))));
+		const adjustedColor = vec3(redSample, greenSample, blueSample).sub(float(.5)).mul(contrast).add(float(.5)).mul(brightness);
+		const scanlineWave = sin(screenUV.y.mul(scanlineFrequency).mul(float(3.14159 * 2)));
+		const scanlineEffect = float(1).sub(scanlineIntensity.mul(scanlineWave.mul(float(.5)).add(float(.5))));
 		const scanlinedColor = adjustedColor.mul(scanlineEffect);
-		const phosphorScale = pixelSize.mul(float$1(.5));
-		const pixelPhase = fract(screenUV$1.mul(phosphorScale));
-		const redMask = sin$1(pixelPhase.x.mul(float$1(6.28318))).mul(float$1(.1)).add(float$1(.95));
-		const greenMask = sin$1(pixelPhase.x.mul(float$1(6.28318)).add(float$1(2.09))).mul(float$1(.1)).add(float$1(.95));
-		const blueMask = sin$1(pixelPhase.x.mul(float$1(6.28318)).add(float$1(4.18))).mul(float$1(.1)).add(float$1(.95));
-		const phosphorColor = vec3$1(scanlinedColor.r.mul(redMask), scanlinedColor.g.mul(greenMask), scanlinedColor.b.mul(blueMask));
-		const vignetteDistance = length(screenUV$1.sub(vec2$1(.5, .5)));
-		const vignette = smoothstep(float$1(.8), float$1(.3), vignetteDistance);
-		return vec4$1(phosphorColor.mul(vignette), float$1(1));
+		const phosphorScale = pixelSize.mul(float(.5));
+		const pixelPhase = fract(screenUV.mul(phosphorScale));
+		const redMask = sin(pixelPhase.x.mul(float(6.28318))).mul(float(.1)).add(float(.95));
+		const greenMask = sin(pixelPhase.x.mul(float(6.28318)).add(float(2.09))).mul(float(.1)).add(float(.95));
+		const blueMask = sin(pixelPhase.x.mul(float(6.28318)).add(float(4.18))).mul(float(.1)).add(float(.95));
+		const phosphorColor = vec3(scanlinedColor.r.mul(redMask), scanlinedColor.g.mul(greenMask), scanlinedColor.b.mul(blueMask));
+		const vignetteDistance = length(screenUV.sub(vec2(.5, .5)));
+		const vignette = smoothstep(float(.8), float(.3), vignetteDistance);
+		return vec4(phosphorColor.mul(vignette), float(1));
 	}
 };
 var CRTScreen_default = componentDefinition;

package/dist/core/ChannelBlur-BPOGOQXl.js

@@ -0,0 +1,117 @@
+import { Fn, convertToTexture, float, screenUV, vec2, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "ChannelBlur",
+	category: "Blurs",
+	description: "Independent blur for red, green, and blue channels",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		redIntensity: {
+			default: 0,
+			description: "Blur intensity for red channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Red Intensity"
+			}
+		},
+		greenIntensity: {
+			default: 20,
+			description: "Blur intensity for green channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Green Intensity"
+			}
+		},
+		blueIntensity: {
+			default: 40,
+			description: "Blur intensity for blue channel",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Blue Intensity"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const redRadius = uniforms.redIntensity.uniform.mul(.1);
+		const greenRadius = uniforms.greenIntensity.uniform.mul(.1);
+		const blueRadius = uniforms.blueIntensity.uniform.mul(.1);
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const redTotal = float(0).toVar();
+			const greenTotal = float(0).toVar();
+			const blueTotal = float(0).toVar();
+			for (let x = -6; x <= 6; x++) {
+				const weight = float(weights[x + 6] / weightSum);
+				const xOffset = float(x).mul(pixelSize.x);
+				const redOffset = vec2(xOffset.mul(redRadius), float(0));
+				const greenOffset = vec2(xOffset.mul(greenRadius), float(0));
+				const blueOffset = vec2(xOffset.mul(blueRadius), float(0));
+				const redSample = childTexture.sample(uv$1.add(redOffset)).r.mul(weight);
+				const greenSample = childTexture.sample(uv$1.add(greenOffset)).g.mul(weight);
+				const blueSample = childTexture.sample(uv$1.add(blueOffset)).b.mul(weight);
+				redTotal.assign(redTotal.add(redSample));
+				greenTotal.assign(greenTotal.add(greenSample));
+				blueTotal.assign(blueTotal.add(blueSample));
+			}
+			return vec4(redTotal, greenTotal, blueTotal, float(1));
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const redTotal = float(0).toVar();
+			const greenTotal = float(0).toVar();
+			const blueTotal = float(0).toVar();
+			for (let y = -6; y <= 6; y++) {
+				const weight = float(weights[y + 6] / weightSum);
+				const yOffset = float(y).mul(pixelSize.y);
+				const redOffset = vec2(float(0), yOffset.mul(redRadius));
+				const greenOffset = vec2(float(0), yOffset.mul(greenRadius));
+				const blueOffset = vec2(float(0), yOffset.mul(blueRadius));
+				const redSample = horizontalTexture.sample(uv$1.add(redOffset)).r.mul(weight);
+				const greenSample = horizontalTexture.sample(uv$1.add(greenOffset)).g.mul(weight);
+				const blueSample = horizontalTexture.sample(uv$1.add(blueOffset)).b.mul(weight);
+				redTotal.assign(redTotal.add(redSample));
+				greenTotal.assign(greenTotal.add(greenSample));
+				blueTotal.assign(blueTotal.add(blueSample));
+			}
+			const originalAlpha = childTexture.sample(uv$1).a;
+			return vec4(redTotal, greenTotal, blueTotal, originalAlpha);
+		})();
+	}
+};
+var ChannelBlur_default = componentDefinition;
+export { componentDefinition as n, ChannelBlur_default as t };