shaders 2.5.109 → 2.5.111

package/dist/core/{Tritone-C9Yx69Tw.js → Tritone-LX-qUAGy.js}

@@ -1,12 +1,10 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { convertToTexture, dot, screenUV, smoothstep, vec3, vec4 } from "three/tsl";
+import { dot, smoothstep, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Tritone",
 	category: "Adjustments",
 	description: "Map colors to three tones: shadows, midtones, highlights",
-	requiresRTT: true,
 	requiresChild: true,
 	props: {
 		colorA: {
@@ -64,19 +62,14 @@ const componentDefinition = {
 			}
 		}
 	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+	fragmentNode: ({ uniforms, childNode }) => {
 		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const inputColor = unpremultiplyAlpha(childTexture.sample(screenUV));
-		const luminance = dot(inputColor.rgb, vec3(.299, .587, .114));
+		const luminance = dot(vec3(childNode.r, childNode.g, childNode.b), vec3(.299, .587, .114));
 		const shadowToMid = smoothstep(uniforms.blendMid.uniform.sub(.25), uniforms.blendMid.uniform, luminance);
 		const csMode = uniforms.colorSpace.uniform.value;
 		const lowerBlend = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, shadowToMid, csMode);
 		const midToHighlight = smoothstep(uniforms.blendMid.uniform, uniforms.blendMid.uniform.add(.25), luminance);
-		return vec4(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, csMode), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), csMode).rgb, inputColor.a);
+		return vec4(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, csMode), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), csMode).rgb, childNode.a);
 	}
 };
 var Tritone_default = componentDefinition;

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

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

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

@@ -1,6 +1,6 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-CsOpQ0L_.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
-import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
+import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "VideoTexture",
 	category: "Textures",
@@ -27,6 +27,7 @@ const componentDefinition = {
 					"none": 4
 				}[value] ?? 0;
 			},
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -175,22 +176,34 @@ const componentDefinition = {
 		});
 		const uv$1 = baseUV;
 		const viewportAspect = viewportSize.x.div(viewportSize.y);
-		const objectFitMode = uniforms.objectFit.uniform;
-		const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
-		const coverUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
-		const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
-		const containUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
-		const fillUVScale = vec2(1, 1);
-		const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
-		const scaleDownUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
-		const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
-		const noneUVScale = vec2(videoAspectUniform.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 objectFitMode = uniforms.objectFit.uniform.value;
+		let uvScale;
+		switch (objectFitMode) {
+			case 1: {
+				const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
+				break;
+			}
+			case 2:
+				uvScale = vec2(1, 1);
+				break;
+			case 3: {
+				const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+				break;
+			}
+			case 4: {
+				const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+				break;
+			}
+			case 0:
+			default: {
+				const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+				break;
+			}
+		}
 		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);

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

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

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

@@ -1,6 +1,6 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-CsOpQ0L_.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
-import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
+import { float, max, min, or, screenUV, select, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "WebcamTexture",
 	category: "Textures",
@@ -18,6 +18,7 @@ const componentDefinition = {
 					"none": 4
 				}[value] ?? 0;
 			},
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -159,22 +160,34 @@ const componentDefinition = {
 		});
 		const uv$1 = baseUV;
 		const viewportAspect = viewportSize.x.div(viewportSize.y);
-		const objectFitMode = uniforms.objectFit.uniform;
-		const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
-		const coverUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
-		const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
-		const containUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
-		const fillUVScale = vec2(1, 1);
-		const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
-		const scaleDownUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
-		const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
-		const noneUVScale = vec2(videoAspectUniform.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 objectFitMode = uniforms.objectFit.uniform.value;
+		let uvScale;
+		switch (objectFitMode) {
+			case 1: {
+				const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
+				break;
+			}
+			case 2:
+				uvScale = vec2(1, 1);
+				break;
+			case 3: {
+				const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+				break;
+			}
+			case 4: {
+				const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+				break;
+			}
+			case 0:
+			default: {
+				const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
+				uvScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+				break;
+			}
+		}
 		const adjustedUV = uv$1.sub(vec2(.5)).div(uvScale).add(vec2(.5));
 		const mirrorMode = uniforms.mirror.uniform;
 		const finalUV = vec2(select(mirrorMode, float(1).sub(adjustedUV.x), adjustedUV.x), float(1).sub(adjustedUV.y));

package/dist/core/computeBlur-DCRhuYEi.js

@@ -0,0 +1,209 @@
+import { StorageTexture } from "three/webgpu";
+import { FloatType } from "three";
+import { Fn, If, float, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniform, uniformArray, uvec2, vec4 } from "three/tsl";
+var DEFAULT_HALF_KERNEL = 24;
+const DEFAULT_COMPUTE_WIDTH = 1024;
+const DEFAULT_COMPUTE_HEIGHT = 640;
+function buildFixedWeights(halfKernel) {
+	const sigma = halfKernel / 3;
+	const size = halfKernel * 2 + 1;
+	const weights = [];
+	let sum = 0;
+	for (let i = -halfKernel; i <= halfKernel; i++) {
+		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+		weights.push(w);
+		sum += w;
+	}
+	for (let i = 0; i < size; i++) weights[i] /= sum;
+	return weights;
+}
+var PASSTHROUGH_THRESHOLD = .5;
+function createGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+	const KERNEL_SIZE = halfKernel * 2 + 1;
+	const HALF_KERNEL = halfKernel;
+	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(computeWidth, computeHeight);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weightsH = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	const weightsV = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	let lastRadius = -1;
+	const inputWidthU = uniform(inputWidth);
+	const inputHeightU = uniform(inputHeight);
+	let scaleY = inputHeight / computeHeight;
+	const cw = uint(computeWidth);
+	const ch = uint(computeHeight);
+	const computeHm1 = int(computeHeight - 1);
+	const inputWm1 = int(inputWidthU.sub(1));
+	const inputHm1 = int(inputHeightU.sub(1));
+	const horizontalPass = Fn(() => {
+		const idx = instanceIndex;
+		const cx = idx.mod(cw);
+		const cy = idx.div(cw);
+		If(cy.lessThan(ch), () => {
+			const sum = vec4(0).toVar();
+			const inputCx = cx.toFloat().add(float(.5)).mul(inputWidthU).div(float(computeWidth)).sub(float(.5));
+			const inputCy = cy.toFloat().add(float(.5)).mul(inputHeightU).div(float(computeHeight)).sub(float(.5));
+			const inputCxI = inputCx.round().toInt();
+			const inputCyI = inputCy.round().toInt().clamp(int(0), inputHm1);
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(inputTexture, uvec2(inputCxI.add(int(i)).clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weightsH.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(intermediateWriteNode, uvec2(cx, cy), sum).toWriteOnly();
+		});
+	})().compute(computeWidth * computeHeight, [256]);
+	const verticalPass = Fn(() => {
+		const idx = instanceIndex;
+		const cx = idx.mod(cw);
+		const cy = idx.div(cw);
+		If(cy.lessThan(ch), () => {
+			const sum = vec4(0).toVar();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(intermediateReadNode, uvec2(cx, cy.toInt().add(int(i)).clamp(int(0), computeHm1).toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weightsV.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(outputNode, uvec2(cx, cy), sum).toWriteOnly();
+		});
+	})().compute(computeWidth * computeHeight, [256]);
+	function updateWeights() {
+		const pixelRadius = lastRadius < 0 ? 4 : lastRadius;
+		const sigmaH = Math.max(pixelRadius * .5, .001);
+		const sigmaV = Math.max(sigmaH / scaleY, .001);
+		const newH = new Array(KERNEL_SIZE);
+		const newV = new Array(KERNEL_SIZE);
+		let totalH = 0, totalV = 0;
+		for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+			const h = Math.exp(-(i * i) / (2 * sigmaH * sigmaH));
+			const v = Math.exp(-(i * i) / (2 * sigmaV * sigmaV));
+			newH[i + HALF_KERNEL] = h;
+			newV[i + HALF_KERNEL] = v;
+			totalH += h;
+			totalV += v;
+		}
+		for (let i = 0; i < KERNEL_SIZE; i++) {
+			newH[i] /= totalH;
+			newV[i] /= totalV;
+		}
+		weightsH.array = newH;
+		weightsV.array = newV;
+	}
+	function updateRadius(pixelRadius) {
+		if (Math.abs(pixelRadius - lastRadius) < .01) return;
+		lastRadius = pixelRadius;
+		updateWeights();
+	}
+	updateRadius(4);
+	return {
+		computeNodes: [horizontalPass, verticalPass],
+		outputTexture: outputTex,
+		updateRadius,
+		computeWidth,
+		computeHeight,
+		setInputDimensions: (newW, newH) => {
+			inputWidthU.value = newW;
+			inputHeightU.value = newH;
+			const newScaleY = newH / computeHeight;
+			if (Math.abs(newScaleY - scaleY) > .001) {
+				scaleY = newScaleY;
+				updateWeights();
+			}
+		}
+	};
+}
+function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+	const HALF_KERNEL = halfKernel;
+	const FIXED_WEIGHTS = buildFixedWeights(HALF_KERNEL);
+	const blurMapTex = new StorageTexture(computeWidth, computeHeight);
+	blurMapTex.type = FloatType;
+	const blurMapWriteNode = storageTexture(blurMapTex);
+	const blurMapReadNode = storageTexture(blurMapTex).toReadOnly();
+	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(computeWidth, computeHeight);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		blurMapTex.dispose();
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weights = uniformArray(FIXED_WEIGHTS, "float");
+	const inputWidthU = uniform(inputWidth);
+	const inputHeightU = uniform(inputHeight);
+	const scaleYU = uniform(inputHeight / computeHeight);
+	const cw = uint(computeWidth);
+	const ch = uint(computeHeight);
+	const computeHm1 = int(computeHeight - 1);
+	const inputWm1 = int(inputWidthU.sub(1));
+	const inputHm1 = int(inputHeightU.sub(1));
+	const invHalf = float(1 / HALF_KERNEL);
+	const passthroughThreshold = float(PASSTHROUGH_THRESHOLD);
+	return {
+		computeNodes: [Fn(() => {
+			const idx = instanceIndex;
+			const cx = idx.mod(cw);
+			const cy = idx.div(cw);
+			If(cy.lessThan(ch), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(cx, cy), int(0)).r;
+				const inputCx = cx.toFloat().add(float(.5)).mul(inputWidthU).div(float(computeWidth)).sub(float(.5));
+				const inputCy = cy.toFloat().add(float(.5)).mul(inputHeightU).div(float(computeHeight)).sub(float(.5));
+				const inputCxF = inputCx;
+				const inputCyI = inputCy.round().toInt().clamp(int(0), inputHm1);
+				If(blurRadius.lessThan(passthroughThreshold), () => {
+					const texel = textureLoad(inputTexture, uvec2(inputCxF.round().toInt().clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+					textureStore(intermediateWriteNode, uvec2(cx, cy), texel).toWriteOnly();
+				}).Else(() => {
+					const sum = vec4(0).toVar();
+					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+						const offset = float(i).mul(invHalf).mul(blurRadius);
+						const texel = textureLoad(inputTexture, uvec2(inputCxF.add(offset).round().toInt().clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
+						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+					}
+					textureStore(intermediateWriteNode, uvec2(cx, cy), sum).toWriteOnly();
+				});
+			});
+		})().compute(computeWidth * computeHeight, [256]), Fn(() => {
+			const idx = instanceIndex;
+			const cx = idx.mod(cw);
+			const cy = idx.div(cw);
+			If(cy.lessThan(ch), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(cx, cy), int(0)).r;
+				If(blurRadius.lessThan(passthroughThreshold), () => {
+					const texel = textureLoad(intermediateReadNode, uvec2(cx, cy), int(0));
+					textureStore(outputNode, uvec2(cx, cy), texel).toWriteOnly();
+				}).Else(() => {
+					const sum = vec4(0).toVar();
+					const yi = cy.toInt();
+					const radiusComputeY = blurRadius.div(scaleYU);
+					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+						const offset = float(i).mul(invHalf).mul(radiusComputeY);
+						const texel = textureLoad(intermediateReadNode, uvec2(cx, yi.add(offset.round().toInt()).clamp(int(0), computeHm1).toUint()), int(0));
+						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+					}
+					textureStore(outputNode, uvec2(cx, cy), sum).toWriteOnly();
+				});
+			});
+		})().compute(computeWidth * computeHeight, [256])],
+		outputTexture: outputTex,
+		blurMapTexture: blurMapTex,
+		blurMapWriteNode,
+		computeWidth,
+		computeHeight,
+		setInputDimensions: (newW, newH) => {
+			inputWidthU.value = newW;
+			inputHeightU.value = newH;
+			scaleYU.value = newH / computeHeight;
+		}
+	};
+}
+export { createVariableGaussianBlurCompute as i, DEFAULT_COMPUTE_WIDTH as n, createGaussianBlurCompute as r, DEFAULT_COMPUTE_HEIGHT as t };

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

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