shaders 2.2.23 → 2.2.25

package/dist/core/TiltShift-0CxNRI6L.js

@@ -0,0 +1,134 @@
+import { n as transformAngle, o as transformPosition } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "TiltShift",
+	category: "Blurs",
+	description: "Selective focus blur mimicking tilt-shift photography",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 50,
+			description: "Maximum blur intensity at edges",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity"
+			}
+		},
+		width: {
+			default: .3,
+			description: "Width of the sharp focus area",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Width"
+			}
+		},
+		falloff: {
+			default: .3,
+			description: "Distance over which blur transitions to full strength",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Falloff"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle of the focus line (in degrees)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point of the focus line",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, radians, cos: cos$1, sin: sin$1, dot: dot$1, abs: abs$1, smoothstep, mix: mix$1, Fn } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const angleRad = radians(uniforms.angle.uniform);
+		const cosAngle = cos$1(angleRad);
+		const perpVector = vec2$1(sin$1(angleRad).negate(), cosAngle);
+		const centerPosition = vec2$1(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const distFromLine = abs$1(dot$1(screenUV$1.sub(centerPosition), perpVector));
+		const focusWidth = uniforms.width.uniform.mul(.5);
+		const falloff = uniforms.falloff.uniform;
+		const blurAmount = smoothstep(focusWidth, focusWidth.add(falloff), distFromLine);
+		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
+		const blurRadius = blurAmount.mul(scaledIntensity);
+		const weights = [
+			.056,
+			.135,
+			.278,
+			.487,
+			.726,
+			.923,
+			1,
+			.923,
+			.726,
+			.487,
+			.278,
+			.135,
+			.056
+		];
+		const weightSum = 6.214;
+		const horizontalTexture = convertToTexture$1(Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const total = vec4$1(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 sample = childTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			return total;
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv = screenUV$1;
+			const pixelSize = vec2$1(1).div(viewportSize$1);
+			const total = vec4$1(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 sample = horizontalTexture.sample(sampleCoord).mul(weight);
+				total.assign(total.add(sample));
+			}
+			const blurred = total;
+			return mix$1(childTexture.sample(uv), blurred, blurAmount);
+		})();
+	}
+};
+var TiltShift_default = componentDefinition;
+export { componentDefinition as n, TiltShift_default as t };

package/dist/core/Tritone-Daa-I5UD.js

@@ -0,0 +1,76 @@
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
+import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Tritone",
+	category: "Adjustments",
+	description: "Map colors to three tones: shadows, midtones, highlights",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		colorA: {
+			default: "#ce1bea",
+			transform: transformColor,
+			description: "First color (used for shadows/darkest areas)",
+			ui: {
+				type: "color",
+				label: "Color A (Shadows)"
+			}
+		},
+		colorB: {
+			default: "#2fff00",
+			transform: transformColor,
+			description: "Second color (used for midtones)",
+			ui: {
+				type: "color",
+				label: "Color B (Midtones)"
+			}
+		},
+		colorC: {
+			default: "#ffff00",
+			transform: transformColor,
+			description: "Third color (used for highlights/brightest areas)",
+			ui: {
+				type: "color",
+				label: "Color C (Highlights)"
+			}
+		},
+		blendMid: {
+			default: .5,
+			description: "Midpoint position between the three colors",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Midpoint"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec3: vec3$1, vec4: vec4$1, dot: dot$1, smoothstep, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const inputColor = childTexture.sample(screenUV$1);
+		const luminance = dot$1(inputColor.rgb, vec3$1(.299, .587, .114));
+		const shadowToMid = smoothstep(uniforms.blendMid.uniform.sub(.25), uniforms.blendMid.uniform, luminance);
+		const lowerBlend = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, shadowToMid, uniforms.colorSpace.uniform);
+		const midToHighlight = smoothstep(uniforms.blendMid.uniform, uniforms.blendMid.uniform.add(.25), luminance);
+		return vec4$1(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, uniforms.colorSpace.uniform), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), uniforms.colorSpace.uniform).rgb, inputColor.a);
+	}
+};
+var Tritone_default = componentDefinition;
+export { componentDefinition as n, Tritone_default as t };

package/dist/core/Twirl-2CJVZEtk.js

@@ -0,0 +1,96 @@
+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";
+const componentDefinition = {
+	name: "Twirl",
+	category: "Distortions",
+	description: "Rotate and twist content around a center point",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the twirl effect",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "The strength of the twirl effect",
+			ui: {
+				type: "range",
+				min: -5,
+				max: 5,
+				step: .1,
+				label: "Intensity"
+			}
+		},
+		edges: {
+			default: "stretch",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms }) => {
+		const { vec2: vec2$1, cos: cos$1, sin: sin$1, length } = TSL;
+		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const delta = uv.sub(centerPos);
+		const angle = uniforms.intensity.uniform.mul(length(delta));
+		const cosAngle = cos$1(angle);
+		const sinAngle = sin$1(angle);
+		const rotatedX = cosAngle.mul(delta.x).sub(sinAngle.mul(delta.y));
+		const rotatedY = sinAngle.mul(delta.x).add(cosAngle.mul(delta.y));
+		return vec2$1(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, sin: sin$1, length, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) {
+			console.error("You must pass a child component into the Twirl shader.");
+			return vec4$1(0);
+		}
+		const texture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (texture?.renderTarget?.dispose) texture.renderTarget.dispose();
+		});
+		const uvNode = screenUV$1;
+		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const delta = uvNode.sub(centerPos);
+		const angle = uniforms.intensity.uniform.mul(length(delta));
+		const cosAngle = cos$1(angle);
+		const sinAngle = sin$1(angle);
+		const rotatedX = cosAngle.mul(delta.x).sub(sinAngle.mul(delta.y));
+		const rotatedY = sinAngle.mul(delta.x).add(cosAngle.mul(delta.y));
+		const twistedUV = vec2$1(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
+		return applyEdgeHandling(twistedUV, texture.sample(twistedUV), texture, uniforms.edges.uniform);
+	}
+};
+var Twirl_default = componentDefinition;
+export { componentDefinition as n, Twirl_default as t };

package/dist/core/Vibrance-DRtecEvb.js

@@ -0,0 +1,30 @@
+import * as TSL from "three/tsl";
+import { vibrance } from "three/src/nodes/display/ColorAdjustment";
+const componentDefinition = {
+	name: "Vibrance",
+	category: "Adjustments",
+	description: "Selective saturation adjustment protecting skin tones",
+	requiresChild: true,
+	props: { intensity: {
+		default: 0,
+		description: "The intensity of the vibrance effect",
+		ui: {
+			type: "range",
+			min: -2,
+			max: 2,
+			step: .01,
+			label: "Intensity"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode }) => {
+		const { vec4: vec4$1 } = TSL;
+		if (!childNode) {
+			console.error("You must pass a child component into the Vibrance shader.");
+			return vec4$1(0);
+		}
+		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
+		return vec4$1(vibrance(sourceColor.rgb, uniforms.intensity.uniform).rgb, sourceColor.a);
+	}
+};
+var Vibrance_default = componentDefinition;
+export { componentDefinition as n, Vibrance_default as t };

package/dist/core/WaveDistortion-BscXN2rs.js

@@ -0,0 +1,173 @@
+import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
+import { a as transformEdges } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "WaveDistortion",
+	category: "Distortions",
+	description: "Wave-based distortion with multiple waveform types",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		strength: {
+			default: .3,
+			description: "Distortion intensity",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Strength"
+			}
+		},
+		frequency: {
+			default: 1,
+			description: "Number of bends/waves",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Frequency"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed"
+			}
+		},
+		angle: {
+			default: 0,
+			description: "Direction of wave distortion in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		waveType: {
+			default: "sine",
+			description: "Shape of the distortion wave",
+			transform: (value) => {
+				return {
+					"sine": 0,
+					"triangle": 1,
+					"square": 2,
+					"sawtooth": 3
+				}[value] ?? 0;
+			},
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Sine",
+						value: "sine"
+					},
+					{
+						label: "Triangle",
+						value: "triangle"
+					},
+					{
+						label: "Square",
+						value: "square"
+					},
+					{
+						label: "Sawtooth",
+						value: "sawtooth"
+					}
+				],
+				label: "Wave Type"
+			}
+		},
+		edges: {
+			default: "stretch",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms }) => {
+		const { vec2: vec2$1, sin: sin$1, cos: cos$1, abs: abs$1, fract, step: step$1, float: float$1, PI, time } = TSL;
+		const t = time.mul(uniforms.speed.uniform).mul(.5);
+		const angleRad = uniforms.angle.uniform.mul(PI).div(180);
+		const cosAngle = cos$1(angleRad);
+		const sinAngle = sin$1(angleRad);
+		const centeredUV = uv.sub(vec2$1(.5, .5));
+		const phase = vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2$1(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
+		const normalizedPhase = fract(phase.div(PI.mul(2)));
+		const sineWave = sin$1(phase);
+		const triangleWave = abs$1(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
+		const squareWave = step$1(float$1(.5), normalizedPhase).mul(2).sub(1);
+		const sawtoothWave = normalizedPhase.mul(2).sub(1);
+		const waveTypeValue = uniforms.waveType.uniform;
+		const isSine = step$1(waveTypeValue, float$1(.5));
+		const isTriangle = step$1(float$1(.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(1.5)));
+		const isSquare = step$1(float$1(1.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(2.5)));
+		const isSawtooth = step$1(float$1(2.5), waveTypeValue);
+		const displacement = sineWave.mul(isSine).add(triangleWave.mul(isTriangle)).add(squareWave.mul(isSquare)).add(sawtoothWave.mul(isSawtooth)).mul(uniforms.strength.uniform).mul(.5);
+		const displacementX = displacement.mul(cosAngle);
+		const displacementY = displacement.mul(sinAngle);
+		return vec2$1(uv.x.add(displacementX), uv.y.add(displacementY));
+	},
+	fragmentNode: (params) => {
+		const { uniforms, childNode, onCleanup } = params;
+		const { vec2: vec2$1, vec4: vec4$1, sin: sin$1, cos: cos$1, abs: abs$1, fract, step: step$1, convertToTexture: convertToTexture$1, screenUV: screenUV$1, float: float$1, PI, time } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const uvCoord = screenUV$1;
+		const t = time.mul(uniforms.speed.uniform).mul(.5);
+		const angleRad = uniforms.angle.uniform.mul(PI).div(180);
+		const cosAngle = cos$1(angleRad);
+		const sinAngle = sin$1(angleRad);
+		const centeredUV = uvCoord.sub(vec2$1(.5, .5));
+		const phase = vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2$1(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
+		const normalizedPhase = fract(phase.div(PI.mul(2)));
+		const sineWave = sin$1(phase);
+		const triangleWave = abs$1(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
+		const squareWave = step$1(float$1(.5), normalizedPhase).mul(2).sub(1);
+		const sawtoothWave = normalizedPhase.mul(2).sub(1);
+		const waveTypeValue = uniforms.waveType.uniform;
+		const isSine = step$1(waveTypeValue, float$1(.5));
+		const isTriangle = step$1(float$1(.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(1.5)));
+		const isSquare = step$1(float$1(1.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(2.5)));
+		const isSawtooth = step$1(float$1(2.5), waveTypeValue);
+		const displacement = sineWave.mul(isSine).add(triangleWave.mul(isTriangle)).add(squareWave.mul(isSquare)).add(sawtoothWave.mul(isSawtooth)).mul(uniforms.strength.uniform).mul(.5);
+		const displacementX = displacement.mul(cosAngle);
+		const displacementY = displacement.mul(sinAngle);
+		const distortedUV = vec2$1(uvCoord.x.add(displacementX), uvCoord.y.add(displacementY));
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		return applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform);
+	}
+};
+var WaveDistortion_default = componentDefinition;
+export { componentDefinition as n, WaveDistortion_default as t };

package/dist/core/ZoomBlur-CAqK0Kju.js

@@ -0,0 +1,62 @@
+import { o as transformPosition } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "ZoomBlur",
+	category: "Blurs",
+	description: "Radial zoom blur expanding from a center point",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 30,
+			description: "Intensity of the zoom blur effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point of the zoom blur",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, Fn, convertToTexture: convertToTexture$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const center = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const radius = uniforms.intensity.uniform.mul(.01);
+		return Fn(() => {
+			const uv = screenUV$1;
+			const total = vec4$1(0).toVar();
+			const totalWeight = float$1(0).toVar();
+			for (let i = 0; i < 32; i++) {
+				const t = float$1(i).div(float$1(31));
+				const weightT = t.sub(.5).mul(2);
+				const weight = float$1(1).div(float$1(2.506628)).mul(float$1(-.5).mul(weightT).mul(weightT).div(float$1(.64)).exp());
+				const scale = float$1(1).add(radius.mul(t));
+				const scaledCoord = uv.sub(center).div(scale).add(center);
+				const sample = childTexture.sample(scaledCoord).mul(weight);
+				total.assign(total.add(sample));
+				totalWeight.assign(totalWeight.add(weight));
+			}
+			return total.div(totalWeight);
+		})();
+	}
+};
+var ZoomBlur_default = componentDefinition;
+export { componentDefinition as n, ZoomBlur_default as t };

package/dist/core/colorMixing-BXiTAqJU.js

@@ -0,0 +1,69 @@
+import * as TSL from "three/tsl";
+var { vec3: vec3$1, vec4: vec4$1, float: float$1, pow: pow$1, sqrt: sqrt$1, atan: atan$1, cos: cos$1, sin: sin$1 } = TSL;
+var p3ToSRGB = (p3) => {
+	return vec3$1(p3.x.mul(1.2249401).sub(p3.y.mul(.2249404)).sub(p3.z.mul(0)), p3.x.mul(-.0420569).add(p3.y.mul(1.0420571)).add(p3.z.mul(0)), p3.x.mul(-.0196376).sub(p3.y.mul(.0786361)).add(p3.z.mul(1.0982735)));
+};
+var sRGBToP3 = (srgb) => {
+	return vec3$1(srgb.x.mul(.8224621).add(srgb.y.mul(.177538)).add(srgb.z.mul(0)), srgb.x.mul(.0331941).add(srgb.y.mul(.9668058)).add(srgb.z.mul(0)), srgb.x.mul(.0170826).add(srgb.y.mul(.0723974)).add(srgb.z.mul(.9105199)));
+};
+var rgbToOklab = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const l = r.mul(.4122214708).add(g.mul(.5363325363)).add(b.mul(.0514459929));
+	const m = r.mul(.2119034982).add(g.mul(.6806995451).add(b.mul(.1073969566)));
+	const s = r.mul(.0883024619).add(g.mul(.2817188376)).add(b.mul(.6299787005));
+	const l_ = pow$1(l, float$1(1 / 3));
+	const m_ = pow$1(m, float$1(1 / 3));
+	const s_ = pow$1(s, float$1(1 / 3));
+	return vec3$1(l_.mul(.2104542553).add(m_.mul(.793617785)).sub(s_.mul(.0040720468)), l_.mul(1.9779984951).sub(m_.mul(2.428592205)).add(s_.mul(.4505937099)), l_.mul(.0259040371).add(m_.mul(.7827717662)).sub(s_.mul(.808675766)));
+};
+var oklabToRgb = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	const l_ = L.add(a.mul(.3963377774)).add(b.mul(.2158037573));
+	const m_ = L.sub(a.mul(.1055613458)).sub(b.mul(.0638541728));
+	const s_ = L.sub(a.mul(.0894841775)).sub(b.mul(1.291485548));
+	const l = pow$1(l_, float$1(3));
+	const m = pow$1(m_, float$1(3));
+	const s = pow$1(s_, float$1(3));
+	return vec3$1(l.mul(4.0767416621).sub(m.mul(3.3077115913)).add(s.mul(.2309699292)), l.mul(-1.2684380046).add(m.mul(2.6097574011)).sub(s.mul(.3413193965)), l.mul(-.0041960863).sub(m.mul(.7034186147)).add(s.mul(1.707614701)));
+};
+var oklabToOklch = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	return vec3$1(L, sqrt$1(a.mul(a).add(b.mul(b))), atan$1(b, a));
+};
+var oklchToOklab = (lch) => {
+	const L = lch.x;
+	const C = lch.y;
+	const h = lch.z;
+	return vec3$1(L, C.mul(cos$1(h)), C.mul(sin$1(h)));
+};
+const mixColors = (colorA, colorB, t, colorSpaceMode) => {
+	const p3A = vec3$1(colorA.x, colorA.y, colorA.z);
+	const p3B = vec3$1(colorB.x, colorB.y, colorB.z);
+	const alphaA = colorA.w;
+	const alphaB = colorB.w;
+	const weightA = alphaA.mul(float$1(1).sub(t));
+	const weightB = alphaB.mul(t);
+	const totalWeight = weightA.add(weightB);
+	const safeWeight = TSL.max(totalWeight, float$1(.001));
+	const alphaWeightedMix = (rgbA, rgbB) => {
+		return rgbA.mul(weightA).add(rgbB.mul(weightB)).div(safeWeight);
+	};
+	const linearMix = alphaWeightedMix(p3A, p3B);
+	const srgbA = p3ToSRGB(p3A);
+	const srgbB = p3ToSRGB(p3B);
+	const oklabA = rgbToOklab(srgbA);
+	const oklabB = rgbToOklab(srgbB);
+	const oklchResult = sRGBToP3(oklabToRgb(oklchToOklab(alphaWeightedMix(oklabToOklch(oklabA), oklabToOklch(oklabB)))));
+	const oklabResult = sRGBToP3(oklabToRgb(alphaWeightedMix(oklabA, oklabB)));
+	const isMode1OrHigher = colorSpaceMode.greaterThanEqual(float$1(.5));
+	const rgb = colorSpaceMode.greaterThanEqual(float$1(1.5)).select(oklabResult, isMode1OrHigher.select(oklchResult, linearMix));
+	const alpha = totalWeight;
+	return vec4$1(rgb.x, rgb.y, rgb.z, alpha);
+};
+export { mixColors as t };

package/dist/core/edges-Bn_OIa_h.js

@@ -0,0 +1,26 @@
+import * as TSL from "three/tsl";
+var { vec2: vec2$1, vec4: vec4$1, step: step$1, abs: abs$1, mod, fract, float: float$1, select } = TSL;
+const applyEdgeToUV = (uv, edgeModeUniform) => {
+	const stretchedUV = uv.clamp(vec2$1(0, 0), vec2$1(1, 1));
+	const transparentUV = uv;
+	const mirrorX = mod(abs$1(uv.x), float$1(2));
+	const mirrorY = mod(abs$1(uv.y), float$1(2));
+	const mirroredUV = vec2$1(select(step$1(float$1(1), mirrorX), float$1(2).sub(mirrorX), mirrorX), select(step$1(float$1(1), mirrorY), float$1(2).sub(mirrorY), mirrorY));
+	const wrappedUV = fract(uv);
+	return select(step$1(float$1(.5), edgeModeUniform), select(step$1(float$1(1.5), edgeModeUniform), select(step$1(float$1(2.5), edgeModeUniform), wrappedUV, mirroredUV), transparentUV), stretchedUV);
+};
+const applyEdgeHandling = (distortedUV, sampledColor, childTexture, edgeModeUniform) => {
+	const inBoundsX = step$1(float$1(0), distortedUV.x).mul(step$1(distortedUV.x, float$1(1)));
+	const inBoundsY = step$1(float$1(0), distortedUV.y).mul(step$1(distortedUV.y, float$1(1)));
+	const inBounds = inBoundsX.mul(inBoundsY);
+	const transparentColor = vec4$1(sampledColor.rgb, sampledColor.a.mul(inBounds));
+	if (!childTexture) return select(step$1(float$1(.5), edgeModeUniform), transparentColor, sampledColor);
+	const mirrorX = mod(abs$1(distortedUV.x), float$1(2));
+	const mirrorY = mod(abs$1(distortedUV.y), float$1(2));
+	const mirroredUV = vec2$1(select(step$1(float$1(1), mirrorX), float$1(2).sub(mirrorX), mirrorX), select(step$1(float$1(1), mirrorY), float$1(2).sub(mirrorY), mirrorY));
+	const mirrorColor = childTexture.sample(mirroredUV);
+	const wrappedUV = vec2$1(fract(distortedUV.x), fract(distortedUV.y));
+	const wrapColor = childTexture.sample(wrappedUV);
+	return select(step$1(float$1(.5), edgeModeUniform), select(step$1(float$1(1.5), edgeModeUniform), select(step$1(float$1(2.5), edgeModeUniform), wrapColor, mirrorColor), transparentColor), sampledColor);
+};
+export { applyEdgeToUV as n, applyEdgeHandling as t };