shaders 2.5.94 → 2.5.96

package/dist/core/TiltShift-CI3FlfYk.js

@@ -0,0 +1,252 @@
+import { l as transformPosition, r as transformAngle } from "./transformations-B5lM6fYX.js";
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { n as createVariableGaussianBlurCompute } from "./computeBlur-C3oX720H.js";
+import { Fn, If, abs, clamp, convertToTexture, cos, dot, float, instanceIndex, int, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } 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", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		width: {
+			default: .3,
+			description: "Width of the sharp focus area",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Width",
+				group: "Effect"
+			}
+		},
+		falloff: {
+			default: .3,
+			description: "Distance over which blur transitions to full strength",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Falloff",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle of the focus line (in degrees)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point of the focus line",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		}
+	},
+	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms }) => {
+		if (!childNode) return null;
+		if (uniforms.angle.mapComputeInfo || uniforms.width.mapComputeInfo || uniforms.falloff.mapComputeInfo) return null;
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const dpr = renderer?.getPixelRatio?.() ?? 1;
+		const texWidth = Math.round(dimensions.width * dpr);
+		const texHeight = Math.round(dimensions.height * dpr);
+		const { computeNodes: blurNodes, outputTexture, blurMapWriteNode } = createVariableGaussianBlurCompute(childTexture, texWidth, texHeight, onCleanup);
+		const angleU = uniform(0);
+		const centerXU = uniform(.5);
+		const centerYU = uniform(.5);
+		const focusWidthU = uniform(.15);
+		const falloffU = uniform(.3);
+		const aspectU = uniform(1);
+		const w = uint(texWidth);
+		const h = uint(texHeight);
+		function readScalar(entry) {
+			return entry.getCpuValue?.() ?? (typeof entry.uniform.value === "number" ? entry.uniform.value : null);
+		}
+		function updateGeometryUniforms() {
+			const angleVal = readScalar(uniforms.angle);
+			if (angleVal !== null) angleU.value = angleVal;
+			const centerXVal = uniforms.center.uniform.value?.x ?? uniforms.center.uniform.x?.value;
+			if (typeof centerXVal === "number") centerXU.value = centerXVal;
+			const centerYVal = uniforms.center.uniform.value?.y ?? uniforms.center.uniform.y?.value;
+			if (typeof centerYVal === "number") centerYU.value = centerYVal;
+			const widthVal = readScalar(uniforms.width);
+			if (widthVal !== null) focusWidthU.value = widthVal * .5;
+			const falloffVal = readScalar(uniforms.falloff);
+			if (falloffVal !== null) falloffU.value = falloffVal;
+			aspectU.value = dimensions.width / dimensions.height;
+		}
+		const intensityMapInfo = uniforms.intensity.mapComputeInfo;
+		if (intensityMapInfo) {
+			const { sourceTexture, channel, inputMin, inputMax, outputMin, outputMax, curve } = intensityMapInfo;
+			const fillBlurMap$1 = Fn(() => {
+				const idx = instanceIndex;
+				const x = idx.mod(w);
+				const y = idx.div(w);
+				If(y.lessThan(h), () => {
+					const u = x.toFloat().add(float(.5)).div(float(texWidth));
+					const v = y.toFloat().add(float(.5)).div(float(texHeight));
+					const angleRad = angleU.mul(float(Math.PI / 180));
+					const perpVector = vec2(angleRad.sin().negate(), angleRad.cos());
+					const centerPos = vec2(centerXU, float(1).sub(centerYU));
+					const centeredUV = vec2(u, v).sub(centerPos);
+					const distFromLine = abs(dot(vec2(centeredUV.x.mul(aspectU), centeredUV.y), perpVector));
+					const blurAmount = smoothstep(focusWidthU, focusWidthU.add(falloffU), distFromLine);
+					const mapSample = textureLoad(sourceTexture, uvec2(x, y), int(0));
+					let raw;
+					if (channel === "alpha") raw = mapSample.a;
+					else if (channel === "alphaInverted") raw = mapSample.a.oneMinus();
+					else if (channel === "luminanceInverted") raw = dot(mapSample.rgb, vec3(.2126, .7152, .0722)).oneMinus();
+					else raw = dot(mapSample.rgb, vec3(.2126, .7152, .0722));
+					const inputRange = inputMax.sub(inputMin).max(float(1e-4));
+					const maxRadius = mix(outputMin, outputMax, pow(clamp(raw.sub(inputMin).div(inputRange), float(0), float(1)), pow(float(2), curve.negate().mul(float(2))))).mul(float(.36));
+					const radius = blurAmount.mul(maxRadius);
+					textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+				});
+			})().compute(texWidth * texHeight, [256]);
+			return {
+				outputs: {
+					childTexture,
+					blurredTexture: outputTexture
+				},
+				getComputeNodes: () => {
+					updateGeometryUniforms();
+					return [fillBlurMap$1, ...blurNodes];
+				}
+			};
+		}
+		const maxRadiusU = uniform(18);
+		const fillBlurMap = Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const u = x.toFloat().add(float(.5)).div(float(texWidth));
+				const v = y.toFloat().add(float(.5)).div(float(texHeight));
+				const angleRad = angleU.mul(float(Math.PI / 180));
+				const perpVector = vec2(angleRad.sin().negate(), angleRad.cos());
+				const centerPos = vec2(centerXU, float(1).sub(centerYU));
+				const centeredUV = vec2(u, v).sub(centerPos);
+				const distFromLine = abs(dot(vec2(centeredUV.x.mul(aspectU), centeredUV.y), perpVector));
+				const radius = smoothstep(focusWidthU, focusWidthU.add(falloffU), distFromLine).mul(maxRadiusU);
+				textureStore(blurMapWriteNode, uvec2(x, y), vec4(radius, float(0), float(0), float(1))).toWriteOnly();
+			});
+		})().compute(texWidth * texHeight, [256]);
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture: outputTexture
+			},
+			getComputeNodes: () => {
+				updateGeometryUniforms();
+				const intensityVal = readScalar(uniforms.intensity);
+				if (intensityVal !== null) maxRadiusU.value = intensityVal * .36;
+				return [fillBlurMap, ...blurNodes];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
+		if (!childNode) return vec4(0, 0, 0, 0);
+		if (computeOutputs?.blurredTexture) {
+			const sharp = computeOutputs.childTexture.sample(screenUV);
+			const blurred = texture(computeOutputs.blurredTexture).sample(screenUV);
+			const propsPin = uniforms.intensity.uniform.mul(float(0)).add(uniforms.width.uniform.mul(float(0))).add(uniforms.falloff.uniform.mul(float(0))).add(uniforms.angle.uniform.mul(float(0)));
+			return unpremultiplyAlpha(vec4(blurred.rgb.add(propsPin), sharp.a));
+		}
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const angleRad = radians(uniforms.angle.uniform);
+		const cosAngle = cos(angleRad);
+		const perpVector = vec2(sin(angleRad).negate(), cosAngle);
+		const centerPosition = vec2(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const centeredUV = screenUV.sub(centerPosition);
+		const distFromLine = abs(dot(vec2(centeredUV.x.mul(aspect), centeredUV.y), 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.21;
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
+			for (let x = -6; x <= 6; x++) {
+				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));
+			}
+			return total;
+		})());
+		onCleanup(() => {
+			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
+		});
+		return Fn(() => {
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
+			for (let y = -6; y <= 6; y++) {
+				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));
+			}
+			const blurred = total;
+			return unpremultiplyAlpha(mix(childTexture.sample(uv$1), blurred, blurAmount));
+		})();
+	}
+};
+var TiltShift_default = componentDefinition;
+export { componentDefinition as n, TiltShift_default as t };

package/dist/core/{Trapezoid-Cr61vRvN.js → Trapezoid-BX_hmeZJ.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { f as trapezoidSdf } from "./sdf-Bux00UoZ.js";
+import { f as trapezoidSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Vesica-AXTA8DJU.js → Vesica-DU0f85NG.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { p as vesicaSdf } from "./sdf-Bux00UoZ.js";
+import { p as vesicaSdf } from "./sdf-DyC2H_qS.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{VideoTexture-BobyGZGr.js → VideoTexture-DJrkry82.js}

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

package/dist/core/{WebcamTexture-BXj7sqND.js → WebcamTexture-Cf8J7JB1.js}

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

package/dist/core/computeBlur-C3oX720H.js

@@ -0,0 +1,141 @@
+import { StorageTexture } from "three/webgpu";
+import { FloatType } from "three";
+import { Fn, If, float, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniformArray, uvec2, vec4 } from "three/tsl";
+var HALF_KERNEL = 24;
+var KERNEL_SIZE = HALF_KERNEL * 2 + 1;
+var VAR_SIGMA = HALF_KERNEL / 3;
+var FIXED_WEIGHTS = [];
+var fixedWeightSum = 0;
+for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+	const w = Math.exp(-(i * i) / (2 * VAR_SIGMA * VAR_SIGMA));
+	FIXED_WEIGHTS.push(w);
+	fixedWeightSum += w;
+}
+for (let i = 0; i < KERNEL_SIZE; i++) FIXED_WEIGHTS[i] /= fixedWeightSum;
+function createGaussianBlurCompute(inputTexture, width, height, onCleanup) {
+	const intermediateTex = new StorageTexture(width, height);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(width, height);
+	outputTex.type = FloatType;
+	onCleanup(() => {
+		intermediateTex.dispose();
+		outputTex.dispose();
+	});
+	const intermediateWriteNode = storageTexture(intermediateTex);
+	const intermediateReadNode = storageTexture(intermediateTex).toReadOnly();
+	const outputNode = storageTexture(outputTex);
+	const weights = uniformArray(new Array(KERNEL_SIZE).fill(0), "float");
+	let lastRadius = -1;
+	const w = uint(width);
+	const h = uint(height);
+	const wm1 = int(width - 1);
+	const hm1 = int(height - 1);
+	const horizontalPass = Fn(() => {
+		const idx = instanceIndex;
+		const x = idx.mod(w);
+		const y = idx.div(w);
+		If(y.lessThan(h), () => {
+			const sum = vec4(0).toVar();
+			const xi = x.toInt();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(inputTexture, uvec2(xi.add(int(i)).clamp(int(0), wm1).toUint(), y), int(0));
+				sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(intermediateWriteNode, uvec2(x, y), sum).toWriteOnly();
+		});
+	})().compute(width * height, [256]);
+	const verticalPass = Fn(() => {
+		const idx = instanceIndex;
+		const x = idx.mod(w);
+		const y = idx.div(w);
+		If(y.lessThan(h), () => {
+			const sum = vec4(0).toVar();
+			for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+				const texel = textureLoad(intermediateReadNode, uvec2(x, y.toInt().add(int(i)).clamp(int(0), hm1).toUint()), int(0));
+				sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+			}
+			textureStore(outputNode, uvec2(x, y), sum).toWriteOnly();
+		});
+	})().compute(width * height, [256]);
+	function updateRadius(pixelRadius) {
+		if (Math.abs(pixelRadius - lastRadius) < .01) return;
+		lastRadius = pixelRadius;
+		const sigma = Math.max(pixelRadius * .5, .001);
+		const newWeights = new Array(KERNEL_SIZE);
+		let total = 0;
+		for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+			const w$1 = Math.exp(-(i * i) / (2 * sigma * sigma));
+			newWeights[i + HALF_KERNEL] = w$1;
+			total += w$1;
+		}
+		for (let i = 0; i < KERNEL_SIZE; i++) newWeights[i] /= total;
+		weights.array = newWeights;
+	}
+	updateRadius(4);
+	return {
+		computeNodes: [horizontalPass, verticalPass],
+		outputTexture: outputTex,
+		updateRadius
+	};
+}
+function createVariableGaussianBlurCompute(inputTexture, width, height, onCleanup) {
+	const blurMapTex = new StorageTexture(width, height);
+	blurMapTex.type = FloatType;
+	const blurMapWriteNode = storageTexture(blurMapTex);
+	const blurMapReadNode = storageTexture(blurMapTex).toReadOnly();
+	const intermediateTex = new StorageTexture(width, height);
+	intermediateTex.type = FloatType;
+	const outputTex = new StorageTexture(width, height);
+	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 w = uint(width);
+	const h = uint(height);
+	const wm1 = int(width - 1);
+	const hm1 = int(height - 1);
+	const invHalf = float(1 / HALF_KERNEL);
+	return {
+		computeNodes: [Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(x, y), int(0)).r;
+				const sum = vec4(0).toVar();
+				const xi = x.toInt();
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = float(i).mul(invHalf).mul(blurRadius);
+					const texel = textureLoad(inputTexture, uvec2(xi.add(offset.round().toInt()).clamp(int(0), wm1).toUint(), y), int(0));
+					sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+				}
+				textureStore(intermediateWriteNode, uvec2(x, y), sum).toWriteOnly();
+			});
+		})().compute(width * height, [256]), Fn(() => {
+			const idx = instanceIndex;
+			const x = idx.mod(w);
+			const y = idx.div(w);
+			If(y.lessThan(h), () => {
+				const blurRadius = textureLoad(blurMapReadNode, uvec2(x, y), int(0)).r;
+				const sum = vec4(0).toVar();
+				const yi = y.toInt();
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = float(i).mul(invHalf).mul(blurRadius);
+					const texel = textureLoad(intermediateReadNode, uvec2(x, yi.add(offset.round().toInt()).clamp(int(0), hm1).toUint()), int(0));
+					sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
+				}
+				textureStore(outputNode, uvec2(x, y), sum).toWriteOnly();
+			});
+		})().compute(width * height, [256])],
+		outputTexture: outputTex,
+		blurMapTexture: blurMapTex,
+		blurMapWriteNode
+	};
+}
+export { createVariableGaussianBlurCompute as n, createGaussianBlurCompute as t };

package/dist/core/effects/glass.d.ts

@@ -61,5 +61,5 @@ export interface GlassEffectUniforms {
         uniform: any;
     };
 }
-export declare function applyGlassEffect(childTexture: any, sdfSampler: (uv: any) => any, uniforms: GlassEffectUniforms & UniformsMap, onBeforeRender?: (callback: () => void) => void): Node;
+export declare function applyGlassEffect(childTexture: any, sdfSampler: (uv: any) => any, uniforms: GlassEffectUniforms & UniformsMap, onBeforeRender?: (callback: () => void) => void, blurredTexture?: any): Node;
 //# sourceMappingURL=glass.d.ts.map

package/dist/core/effects/glass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glass.d.ts","sourceRoot":"","sources":["../../src/effects/glass.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAA;AAMzC,eAAO,MAAM,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAO,CAAA;AAO/C,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,IAAI,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,aAAa,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC/B,sBAAsB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxC,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,cAAc,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAChC,iBAAiB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACnC,OAAO,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACzB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,eAAe,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;CAC9B;AAgBD,wBAAgB,gBAAgB,CAC5B,YAAY,EAAE,GAAG,EACjB,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,EAC5B,QAAQ,EAAE,mBAAmB,GAAG,WAAW,EAC3C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,GAChD,IAAI,CAmLN"}
+{"version":3,"file":"glass.d.ts","sourceRoot":"","sources":["../../src/effects/glass.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAA;AAMzC,eAAO,MAAM,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAO,CAAA;AAO/C,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,IAAI,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,aAAa,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC/B,sBAAsB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxC,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,cAAc,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAChC,iBAAiB,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACnC,OAAO,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACzB,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,eAAe,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACjC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;CAC9B;AAgBD,wBAAgB,gBAAgB,CAC5B,YAAY,EAAE,GAAG,EACjB,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,EAC5B,QAAQ,EAAE,mBAAmB,GAAG,WAAW,EAC3C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,EAC/C,cAAc,CAAC,EAAE,GAAG,GACrB,IAAI,CAqMN"}