shaders 3.2.474 → 4.0.0

package/dist/core/glass-ABppDbYG.js

@@ -1,2532 +0,0 @@
-import { Br as struct, Cr as sin, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Ot as unpremultiplyAlpha, Tr as sqrt, _r as mix, ar as clamp, cr as dot, ct as call, er as select, ft as floatE, gr as min, hr as max, jr as vec3f, mt as vec4, or as cos, qr as f32, st as asLocal, ti as __export, ur as exp2, wr as smoothstep, yr as pow } from "./lower-Bd2jez_2.js";
-var glass_exports = /* @__PURE__ */ __export({
-	BLUR_DISK: () => BLUR_DISK,
-	GlassLensUVs: () => GlassLensUVs,
-	applyGlassEffect: () => applyGlassEffect,
-	glassBlurOffset: () => glassBlurOffset,
-	glassBorderHighlight: () => glassBorderHighlight,
-	glassComposite: () => glassComposite,
-	glassFresnelRim: () => glassFresnelRim,
-	glassGradient: () => glassGradient,
-	glassLensUVs: () => glassLensUVs,
-	glassRefrStrength: () => glassRefrStrength,
-	glassSpecular: () => glassSpecular,
-	glassTint: () => glassTint,
-	offsetUV: () => offsetUV,
-	sdfSpaceUV: () => sdfSpaceUV
-});
-var DEG_TO_RAD = .017453292519943295;
-var INV_HLEN_GLASS = .4472135954999579;
-var GOLDEN_ANGLE = 2.3999632297286535;
-var BLUR_SAMPLE_COUNT = 9;
-const BLUR_DISK = [];
-for (let i = 0; i < BLUR_SAMPLE_COUNT; i++) {
-	const angle = i * GOLDEN_ANGLE;
-	const r = Math.sqrt(i / BLUR_SAMPLE_COUNT);
-	BLUR_DISK.push([Math.cos(angle) * r, Math.sin(angle) * r]);
-}
-const sdfSpaceUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	vec2f,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, rotation, uv, aspect) => {
-	"use gpu";
-	const centerX = center.x;
-	const centerY = __tsover_sub(1, center.y);
-	const dxAc = __tsover_mul(__tsover_sub(uv.x, centerX), aspect);
-	const dy = __tsover_sub(uv.y, centerY);
-	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = cos(rotRad);
-	const sinR = sin(rotRad);
-	const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
-	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
-	return vec2f(__tsover_add(__tsover_div(rdx, scale), .5), __tsover_add(__tsover_div(rdy, scale), .5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "rotation"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"centerX",
-				[
-					7,
-					"center",
-					"x"
-				]
-			],
-			[
-				13,
-				"centerY",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"center",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"dxAc",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"-",
-						"centerX"
-					],
-					"*",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"-",
-					"centerY"
-				]
-			],
-			[
-				13,
-				"rotRad",
-				[
-					1,
-					"rotation",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"std.sin",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"rdx",
-				[
-					1,
-					[
-						1,
-						"dxAc",
-						"*",
-						"cosR"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[
-				13,
-				"rdy",
-				[
-					1,
-					[
-						1,
-						"dy",
-						"*",
-						"cosR"
-					],
-					"-",
-					[
-						1,
-						"dxAc",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"rdx",
-						"/",
-						"scale"
-					],
-					"+",
-					[5, "0.5"]
-				], [
-					1,
-					[
-						1,
-						"rdy",
-						"/",
-						"scale"
-					],
-					"+",
-					[5, "0.5"]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const offsetUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
-	"use gpu";
-	return vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					7,
-					"uv",
-					"x"
-				],
-				"+",
-				"ox"
-			], [
-				1,
-				[
-					7,
-					"uv",
-					"y"
-				],
-				"+",
-				"oy"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const glassGradient = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfRaw, sdfX, sdfY) => {
-	"use gpu";
-	const eps = .01;
-	return vec2f(__tsover_div(__tsover_sub(sdfX, sdfRaw), eps), __tsover_div(__tsover_sub(sdfY, sdfRaw), eps));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sdfRaw"
-			},
-			{
-				"type": "i",
-				"name": "sdfX"
-			},
-			{
-				"type": "i",
-				"name": "sdfY"
-			}
-		],
-		"body": [0, [[
-			13,
-			"eps",
-			[5, "0.01"]
-		], [10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					1,
-					"sdfX",
-					"-",
-					"sdfRaw"
-				],
-				"/",
-				"eps"
-			], [
-				1,
-				[
-					1,
-					"sdfY",
-					"-",
-					"sdfRaw"
-				],
-				"/",
-				"eps"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const glassRefrStrength = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, thickness, volumetric) => {
-	"use gpu";
-	const thicknessRange = max(__tsover_mul(thickness, .3), .005);
-	const depthNorm = clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
-	const vol = smoothstep(0, 1, depthNorm);
-	return select(__tsover_mul(__tsover_sub(1, depthNorm), __tsover_sub(1, depthNorm)), vol, volumetric > .5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sdf"
-			},
-			{
-				"type": "i",
-				"name": "thickness"
-			},
-			{
-				"type": "i",
-				"name": "volumetric"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"thicknessRange",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"thickness",
-						"*",
-						[5, "0.3"]
-					], [5, "0.005"]]
-				]
-			],
-			[
-				13,
-				"depthNorm",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"sdf",
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"/",
-							"thicknessRange"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"vol",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0"],
-						[5, "1"],
-						"depthNorm"
-					]
-				]
-			],
-			[
-				13,
-				"flat",
-				[
-					1,
-					[
-						1,
-						[5, "1"],
-						"-",
-						"depthNorm"
-					],
-					"*",
-					[
-						1,
-						[5, "1"],
-						"-",
-						"depthNorm"
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					"flat",
-					"vol",
-					[
-						1,
-						"volumetric",
-						">",
-						[5, "0.5"]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"std.smoothstep": () => smoothstep,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const GlassLensUVs = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	lensUV: vec2f,
-	rUV: vec2f,
-	bUV: vec2f
-}), "GlassLensUVs");
-const glassLensUVs = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], GlassLensUVs)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, center, sdfRaw, scale, gradX, gradY, refraction, innerZoom, thickness, aberration, aspect, volumetric) => {
-	"use gpu";
-	const refrStrength = glassRefrStrength(__tsover_div(sdfRaw, scale), thickness, volumetric);
-	const refrScale = __tsover_mul(refraction, .15);
-	const slopeLen = max(sqrt(__tsover_add(__tsover_mul(gradX, gradX), __tsover_mul(gradY, gradY))), 1e-4);
-	const slopeScale = min(f32(1), __tsover_div(12, slopeLen));
-	const offsetX = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(gradX, slopeScale), -1), refrScale), refrStrength), aspect);
-	const offsetY = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(gradY, slopeScale), -1), refrScale), refrStrength);
-	const centerX = center.x;
-	const centerY = __tsover_sub(1, center.y);
-	const zoomedX = __tsover_add(centerX, __tsover_div(__tsover_sub(uv.x, centerX), innerZoom));
-	const zoomedY = __tsover_add(centerY, __tsover_div(__tsover_sub(uv.y, centerY), innerZoom));
-	const lensX = __tsover_add(zoomedX, offsetX);
-	const lensY = __tsover_add(zoomedY, offsetY);
-	const chrScale = __tsover_mul(aberration, .06);
-	const chrOffX = __tsover_mul(offsetX, chrScale);
-	const chrOffY = __tsover_mul(offsetY, chrScale);
-	return GlassLensUVs({
-		lensUV: vec2f(lensX, lensY),
-		rUV: vec2f(__tsover_add(lensX, chrOffX), __tsover_add(lensY, chrOffY)),
-		bUV: vec2f(__tsover_sub(lensX, chrOffX), __tsover_sub(lensY, chrOffY))
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "sdfRaw"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "gradX"
-			},
-			{
-				"type": "i",
-				"name": "gradY"
-			},
-			{
-				"type": "i",
-				"name": "refraction"
-			},
-			{
-				"type": "i",
-				"name": "innerZoom"
-			},
-			{
-				"type": "i",
-				"name": "thickness"
-			},
-			{
-				"type": "i",
-				"name": "aberration"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "volumetric"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"sdf",
-				[
-					1,
-					"sdfRaw",
-					"/",
-					"scale"
-				]
-			],
-			[
-				13,
-				"refrStrength",
-				[
-					6,
-					"glassRefrStrength",
-					[
-						"sdf",
-						"thickness",
-						"volumetric"
-					]
-				]
-			],
-			[
-				13,
-				"refrScale",
-				[
-					1,
-					"refraction",
-					"*",
-					[5, "0.15"]
-				]
-			],
-			[
-				13,
-				"slopeLen",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								"gradX",
-								"*",
-								"gradX"
-							],
-							"+",
-							[
-								1,
-								"gradY",
-								"*",
-								"gradY"
-							]
-						]]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"slopeScale",
-				[
-					6,
-					"std.min",
-					[[
-						6,
-						"d.f32",
-						[[5, "1"]]
-					], [
-						1,
-						[5, "12"],
-						"/",
-						"slopeLen"
-					]]
-				]
-			],
-			[
-				13,
-				"offsetX",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"gradX",
-									"*",
-									"slopeScale"
-								],
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"*",
-							"refrScale"
-						],
-						"*",
-						"refrStrength"
-					],
-					"/",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"offsetY",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"gradY",
-								"*",
-								"slopeScale"
-							],
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						],
-						"*",
-						"refrScale"
-					],
-					"*",
-					"refrStrength"
-				]
-			],
-			[
-				13,
-				"centerX",
-				[
-					7,
-					"center",
-					"x"
-				]
-			],
-			[
-				13,
-				"centerY",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"center",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"zoomedX",
-				[
-					1,
-					"centerX",
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"uv",
-								"x"
-							],
-							"-",
-							"centerX"
-						],
-						"/",
-						"innerZoom"
-					]
-				]
-			],
-			[
-				13,
-				"zoomedY",
-				[
-					1,
-					"centerY",
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"uv",
-								"y"
-							],
-							"-",
-							"centerY"
-						],
-						"/",
-						"innerZoom"
-					]
-				]
-			],
-			[
-				13,
-				"lensX",
-				[
-					1,
-					"zoomedX",
-					"+",
-					"offsetX"
-				]
-			],
-			[
-				13,
-				"lensY",
-				[
-					1,
-					"zoomedY",
-					"+",
-					"offsetY"
-				]
-			],
-			[
-				13,
-				"chrScale",
-				[
-					1,
-					"aberration",
-					"*",
-					[5, "0.06"]
-				]
-			],
-			[
-				13,
-				"chrOffX",
-				[
-					1,
-					"offsetX",
-					"*",
-					"chrScale"
-				]
-			],
-			[
-				13,
-				"chrOffY",
-				[
-					1,
-					"offsetY",
-					"*",
-					"chrScale"
-				]
-			],
-			[10, [
-				6,
-				"GlassLensUVs",
-				[[104, {
-					"lensUV": [
-						6,
-						"d.vec2f",
-						["lensX", "lensY"]
-					],
-					"rUV": [
-						6,
-						"d.vec2f",
-						[[
-							1,
-							"lensX",
-							"+",
-							"chrOffX"
-						], [
-							1,
-							"lensY",
-							"+",
-							"chrOffY"
-						]]
-					],
-					"bUV": [
-						6,
-						"d.vec2f",
-						[[
-							1,
-							"lensX",
-							"-",
-							"chrOffX"
-						], [
-							1,
-							"lensY",
-							"-",
-							"chrOffY"
-						]]
-					]
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"glassRefrStrength": () => glassRefrStrength,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt,
-		"std.min": () => min,
-		"d.f32": () => f32,
-		"GlassLensUVs": () => GlassLensUVs,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const glassBlurOffset = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((viewportSize, blur, ox, oy) => {
-	"use gpu";
-	const m = __tsover_mul(blur, 2);
-	return vec2f(__tsover_mul(__tsover_div(ox, viewportSize.x), m), __tsover_mul(__tsover_div(oy, viewportSize.y), m));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "viewportSize"
-			},
-			{
-				"type": "i",
-				"name": "blur"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[
-			13,
-			"m",
-			[
-				1,
-				"blur",
-				"*",
-				[5, "2"]
-			]
-		], [10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					1,
-					"ox",
-					"/",
-					[
-						7,
-						"viewportSize",
-						"x"
-					]
-				],
-				"*",
-				"m"
-			], [
-				1,
-				[
-					1,
-					"oy",
-					"/",
-					[
-						7,
-						"viewportSize",
-						"y"
-					]
-				],
-				"*",
-				"m"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const glassTint = typegpu_default.fn([
-	vec3f,
-	vec3f,
-	f32,
-	f32
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, tintColor, tintIntensity, preserveLum) => {
-	"use gpu";
-	const lumWeights = vec3f(.299, .587, .114);
-	const origLum = dot(rgb, lumWeights);
-	const tinted = mix(rgb, tintColor, tintIntensity);
-	const tintedLum = dot(tinted, lumWeights);
-	return mix(tinted, tinted.mul(__tsover_div(origLum, max(tintedLum, 1e-4))), select(f32(0), f32(1), preserveLum > .5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "rgb"
-			},
-			{
-				"type": "i",
-				"name": "tintColor"
-			},
-			{
-				"type": "i",
-				"name": "tintIntensity"
-			},
-			{
-				"type": "i",
-				"name": "preserveLum"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"lumWeights",
-				[
-					6,
-					"d.vec3f",
-					[
-						[5, "0.299"],
-						[5, "0.587"],
-						[5, "0.114"]
-					]
-				]
-			],
-			[
-				13,
-				"origLum",
-				[
-					6,
-					"std.dot",
-					["rgb", "lumWeights"]
-				]
-			],
-			[
-				13,
-				"tinted",
-				[
-					6,
-					"std.mix",
-					[
-						"rgb",
-						"tintColor",
-						"tintIntensity"
-					]
-				]
-			],
-			[
-				13,
-				"tintedLum",
-				[
-					6,
-					"std.dot",
-					["tinted", "lumWeights"]
-				]
-			],
-			[
-				13,
-				"lumPreserved",
-				[
-					6,
-					[
-						7,
-						"tinted",
-						"mul"
-					],
-					[[
-						1,
-						"origLum",
-						"/",
-						[
-							6,
-							"std.max",
-							["tintedLum", [5, "0.0001"]]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"preserveFactor",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							1,
-							"preserveLum",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.mix",
-				[
-					"tinted",
-					"lumPreserved",
-					"preserveFactor"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.dot": () => dot,
-		"std.mix": () => mix,
-		"std.max": () => max,
-		"std.select": () => select,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-const glassBorderHighlight = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, edgeSoftness, pxH, gradX, gradY, lightAngle, highlight) => {
-	"use gpu";
-	const sharp = max(__tsover_mul(edgeSoftness, .5), .001);
-	const w2 = max(__tsover_mul(sharp, .0625), __tsover_mul(pxH, 1.5));
-	const sdfOuter = __tsover_sub(sdf, pxH);
-	const rb2base = __tsover_sub(clamp(__tsover_div(__tsover_mul(sdfOuter, -1), w2), 0, 1), clamp(__tsover_div(__tsover_mul(sdf, -1), w2), 0, 1));
-	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const normalDotLight = __tsover_add(__tsover_mul(gradX, lx), __tsover_mul(gradY, ly));
-	const lightFacing = clamp(__tsover_add(__tsover_mul(normalDotLight, .5), .5), 0, 1);
-	return __tsover_mul(__tsover_mul(rb2base, lightFacing), highlight);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sdf"
-			},
-			{
-				"type": "i",
-				"name": "edgeSoftness"
-			},
-			{
-				"type": "i",
-				"name": "pxH"
-			},
-			{
-				"type": "i",
-				"name": "gradX"
-			},
-			{
-				"type": "i",
-				"name": "gradY"
-			},
-			{
-				"type": "i",
-				"name": "lightAngle"
-			},
-			{
-				"type": "i",
-				"name": "highlight"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"sharp",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"edgeSoftness",
-						"*",
-						[5, "0.5"]
-					], [5, "0.001"]]
-				]
-			],
-			[
-				13,
-				"w2",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"sharp",
-						"*",
-						[5, "0.0625"]
-					], [
-						1,
-						"pxH",
-						"*",
-						[5, "1.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"sdfOuter",
-				[
-					1,
-					"sdf",
-					"-",
-					"pxH"
-				]
-			],
-			[
-				13,
-				"rb2base",
-				[
-					1,
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									1,
-									"sdfOuter",
-									"*",
-									[
-										4,
-										"-",
-										[5, "1"]
-									]
-								],
-								"/",
-								"w2"
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					],
-					"-",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									1,
-									"sdf",
-									"*",
-									[
-										4,
-										"-",
-										[5, "1"]
-									]
-								],
-								"/",
-								"w2"
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"lx",
-				[
-					6,
-					"std.cos",
-					[[
-						1,
-						"lightAngle",
-						"*",
-						"DEG_TO_RAD"
-					]]
-				]
-			],
-			[
-				13,
-				"ly",
-				[
-					6,
-					"std.sin",
-					[[
-						1,
-						"lightAngle",
-						"*",
-						"DEG_TO_RAD"
-					]]
-				]
-			],
-			[
-				13,
-				"normalDotLight",
-				[
-					1,
-					[
-						1,
-						"gradX",
-						"*",
-						"lx"
-					],
-					"+",
-					[
-						1,
-						"gradY",
-						"*",
-						"ly"
-					]
-				]
-			],
-			[
-				13,
-				"lightFacing",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"normalDotLight",
-								"*",
-								[5, "0.5"]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					"rb2base",
-					"*",
-					"lightFacing"
-				],
-				"*",
-				"highlight"
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"std.cos": () => cos,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.sin": () => sin
-	}
-}) && $.f)({}));
-const glassSpecular = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gradX, gradY, lightAngle, highlight, highlightSoftness, refrStrength) => {
-	"use gpu";
-	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const nz = f32(2);
-	const nLen = sqrt(__tsover_add(__tsover_add(__tsover_mul(gradX, gradX), __tsover_mul(gradY, gradY)), __tsover_mul(nz, nz)));
-	const nx = __tsover_div(gradX, nLen);
-	const ny = __tsover_div(gradY, nLen);
-	const nnz = __tsover_div(nz, nLen);
-	const nDotH = __tsover_add(__tsover_add(__tsover_mul(nx, __tsover_mul(lx, INV_HLEN_GLASS)), __tsover_mul(ny, __tsover_mul(ly, INV_HLEN_GLASS))), __tsover_mul(nnz, __tsover_mul(2, INV_HLEN_GLASS)));
-	const shininess = exp2(__tsover_sub(8, __tsover_mul(highlightSoftness, 7)));
-	return __tsover_mul(__tsover_mul(pow(clamp(nDotH, 0, 1), shininess), highlight), refrStrength);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "gradX"
-			},
-			{
-				"type": "i",
-				"name": "gradY"
-			},
-			{
-				"type": "i",
-				"name": "lightAngle"
-			},
-			{
-				"type": "i",
-				"name": "highlight"
-			},
-			{
-				"type": "i",
-				"name": "highlightSoftness"
-			},
-			{
-				"type": "i",
-				"name": "refrStrength"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"lx",
-				[
-					6,
-					"std.cos",
-					[[
-						1,
-						"lightAngle",
-						"*",
-						"DEG_TO_RAD"
-					]]
-				]
-			],
-			[
-				13,
-				"ly",
-				[
-					6,
-					"std.sin",
-					[[
-						1,
-						"lightAngle",
-						"*",
-						"DEG_TO_RAD"
-					]]
-				]
-			],
-			[
-				13,
-				"nz",
-				[
-					6,
-					"d.f32",
-					[[5, "2"]]
-				]
-			],
-			[
-				13,
-				"nLen",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							[
-								1,
-								"gradX",
-								"*",
-								"gradX"
-							],
-							"+",
-							[
-								1,
-								"gradY",
-								"*",
-								"gradY"
-							]
-						],
-						"+",
-						[
-							1,
-							"nz",
-							"*",
-							"nz"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"nx",
-				[
-					1,
-					"gradX",
-					"/",
-					"nLen"
-				]
-			],
-			[
-				13,
-				"ny",
-				[
-					1,
-					"gradY",
-					"/",
-					"nLen"
-				]
-			],
-			[
-				13,
-				"nnz",
-				[
-					1,
-					"nz",
-					"/",
-					"nLen"
-				]
-			],
-			[
-				13,
-				"nDotH",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"nx",
-							"*",
-							[
-								1,
-								"lx",
-								"*",
-								"INV_HLEN_GLASS"
-							]
-						],
-						"+",
-						[
-							1,
-							"ny",
-							"*",
-							[
-								1,
-								"ly",
-								"*",
-								"INV_HLEN_GLASS"
-							]
-						]
-					],
-					"+",
-					[
-						1,
-						"nnz",
-						"*",
-						[
-							1,
-							[5, "2"],
-							"*",
-							"INV_HLEN_GLASS"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"shininess",
-				[
-					6,
-					"std.exp2",
-					[[
-						1,
-						[5, "8"],
-						"-",
-						[
-							1,
-							"highlightSoftness",
-							"*",
-							[5, "7"]
-						]
-					]]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					[
-						6,
-						"std.pow",
-						[[
-							6,
-							"std.clamp",
-							[
-								"nDotH",
-								[5, "0"],
-								[5, "1"]
-							]
-						], "shininess"]
-					],
-					"*",
-					"highlight"
-				],
-				"*",
-				"refrStrength"
-			]]
-		]]
-	},
-	externals: {
-		"std.cos": () => cos,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.sin": () => sin,
-		"d.f32": () => f32,
-		"std.sqrt": () => sqrt,
-		"INV_HLEN_GLASS": () => INV_HLEN_GLASS,
-		"std.exp2": () => exp2,
-		"std.pow": () => pow,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const glassFresnelRim = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, gradX, gradY, fresnel, fresnelSoftness, rb1, volumetric) => {
-	"use gpu";
-	const slopeSq = __tsover_add(__tsover_mul(gradX, gradX), __tsover_mul(gradY, gradY));
-	const cosView = __tsover_div(1, sqrt(__tsover_add(slopeSq, 1)));
-	const exponent = mix(6, 1.5, clamp(fresnelSoftness, 0, 1));
-	const volRim = __tsover_mul(__tsover_mul(__tsover_mul(pow(__tsover_sub(1, cosView), exponent), fresnel), 2), rb1);
-	const fresnelWidth = max(__tsover_mul(fresnelSoftness, .06), .001);
-	const fresnelDepth = clamp(__tsover_div(__tsover_mul(sdf, -1), fresnelWidth), 0, 1);
-	return select(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(1, fresnelDepth), __tsover_sub(1, fresnelDepth)), fresnel), rb1), volRim, volumetric > .5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sdf"
-			},
-			{
-				"type": "i",
-				"name": "gradX"
-			},
-			{
-				"type": "i",
-				"name": "gradY"
-			},
-			{
-				"type": "i",
-				"name": "fresnel"
-			},
-			{
-				"type": "i",
-				"name": "fresnelSoftness"
-			},
-			{
-				"type": "i",
-				"name": "rb1"
-			},
-			{
-				"type": "i",
-				"name": "volumetric"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"slopeSq",
-				[
-					1,
-					[
-						1,
-						"gradX",
-						"*",
-						"gradX"
-					],
-					"+",
-					[
-						1,
-						"gradY",
-						"*",
-						"gradY"
-					]
-				]
-			],
-			[
-				13,
-				"cosView",
-				[
-					1,
-					[5, "1"],
-					"/",
-					[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							"slopeSq",
-							"+",
-							[5, "1"]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"exponent",
-				[
-					6,
-					"std.mix",
-					[
-						[5, "6"],
-						[5, "1.5"],
-						[
-							6,
-							"std.clamp",
-							[
-								"fresnelSoftness",
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"volRim",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"std.pow",
-								[[
-									1,
-									[5, "1"],
-									"-",
-									"cosView"
-								], "exponent"]
-							],
-							"*",
-							"fresnel"
-						],
-						"*",
-						[5, "2"]
-					],
-					"*",
-					"rb1"
-				]
-			],
-			[
-				13,
-				"fresnelWidth",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"fresnelSoftness",
-						"*",
-						[5, "0.06"]
-					], [5, "0.001"]]
-				]
-			],
-			[
-				13,
-				"fresnelDepth",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"sdf",
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"/",
-							"fresnelWidth"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"flatRim",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[5, "1"],
-								"-",
-								"fresnelDepth"
-							],
-							"*",
-							[
-								1,
-								[5, "1"],
-								"-",
-								"fresnelDepth"
-							]
-						],
-						"*",
-						"fresnel"
-					],
-					"*",
-					"rb1"
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					"flatRim",
-					"volRim",
-					[
-						1,
-						"volumetric",
-						">",
-						[5, "0.5"]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.mix": () => mix,
-		"std.clamp": () => clamp,
-		"std.pow": () => pow,
-		"std.max": () => max,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const glassComposite = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32,
-	f32,
-	f32,
-	f32,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	vec3f,
-	f32,
-	f32,
-	vec3f,
-	f32,
-	f32,
-	vec3f,
-	f32,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseColor, blurred, sdfRaw, scale, gradX, gradY, viewportSize, edgeSoftness, lightAngle, highlight, highlightColor, highlightSoftness, fresnel, fresnelColor, fresnelSoftness, thickness, tintColor, tintIntensity, tintPreserveLuminosity, cutout, volumetric) => {
-	"use gpu";
-	const sharp = max(__tsover_mul(edgeSoftness, .5), .001);
-	const pxH = __tsover_div(1, viewportSize.y);
-	const sdf = __tsover_div(sdfRaw, scale);
-	const w1 = max(__tsover_mul(sharp, .03125), __tsover_mul(pxH, 1.5));
-	const rb1 = clamp(__tsover_div(__tsover_mul(sdf, -1), w1), 0, 1);
-	const refrStrength = glassRefrStrength(sdf, thickness, volumetric);
-	const rb2 = glassBorderHighlight(sdf, edgeSoftness, pxH, gradX, gradY, lightAngle, highlight);
-	const tintedRgb = glassTint(vec3f(blurred.x, blurred.y, blurred.z), tintColor, tintIntensity, tintPreserveLuminosity);
-	const specGlint = glassSpecular(gradX, gradY, lightAngle, highlight, highlightSoftness, refrStrength);
-	const fresnelRim = glassFresnelRim(sdf, gradX, gradY, fresnel, fresnelSoftness, rb1, volumetric);
-	const lighting = vec4f(__tsover_add(__tsover_add(__tsover_add(tintedRgb.x, __tsover_mul(highlightColor.x, rb2)), __tsover_mul(highlightColor.x, specGlint)), __tsover_mul(fresnelColor.x, fresnelRim)), __tsover_add(__tsover_add(__tsover_add(tintedRgb.y, __tsover_mul(highlightColor.y, rb2)), __tsover_mul(highlightColor.y, specGlint)), __tsover_mul(fresnelColor.y, fresnelRim)), __tsover_add(__tsover_add(__tsover_add(tintedRgb.z, __tsover_mul(highlightColor.z, rb2)), __tsover_mul(highlightColor.z, specGlint)), __tsover_mul(fresnelColor.z, fresnelRim)), __tsover_add(blurred.w, rb2));
-	const transition = smoothstep(0, 1, rb1);
-	const composited = mix(baseColor, lighting, transition);
-	const cutoutAlpha = select(f32(1), transition, cutout > .5);
-	return vec4f(composited.x, composited.y, composited.z, __tsover_mul(composited.w, cutoutAlpha));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "baseColor"
-			},
-			{
-				"type": "i",
-				"name": "blurred"
-			},
-			{
-				"type": "i",
-				"name": "sdfRaw"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "gradX"
-			},
-			{
-				"type": "i",
-				"name": "gradY"
-			},
-			{
-				"type": "i",
-				"name": "viewportSize"
-			},
-			{
-				"type": "i",
-				"name": "edgeSoftness"
-			},
-			{
-				"type": "i",
-				"name": "lightAngle"
-			},
-			{
-				"type": "i",
-				"name": "highlight"
-			},
-			{
-				"type": "i",
-				"name": "highlightColor"
-			},
-			{
-				"type": "i",
-				"name": "highlightSoftness"
-			},
-			{
-				"type": "i",
-				"name": "fresnel"
-			},
-			{
-				"type": "i",
-				"name": "fresnelColor"
-			},
-			{
-				"type": "i",
-				"name": "fresnelSoftness"
-			},
-			{
-				"type": "i",
-				"name": "thickness"
-			},
-			{
-				"type": "i",
-				"name": "tintColor"
-			},
-			{
-				"type": "i",
-				"name": "tintIntensity"
-			},
-			{
-				"type": "i",
-				"name": "tintPreserveLuminosity"
-			},
-			{
-				"type": "i",
-				"name": "cutout"
-			},
-			{
-				"type": "i",
-				"name": "volumetric"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"sharp",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"edgeSoftness",
-						"*",
-						[5, "0.5"]
-					], [5, "0.001"]]
-				]
-			],
-			[
-				13,
-				"pxH",
-				[
-					1,
-					[5, "1"],
-					"/",
-					[
-						7,
-						"viewportSize",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"sdf",
-				[
-					1,
-					"sdfRaw",
-					"/",
-					"scale"
-				]
-			],
-			[
-				13,
-				"w1",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"sharp",
-						"*",
-						[5, "0.03125"]
-					], [
-						1,
-						"pxH",
-						"*",
-						[5, "1.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"rb1",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"sdf",
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"/",
-							"w1"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"refrStrength",
-				[
-					6,
-					"glassRefrStrength",
-					[
-						"sdf",
-						"thickness",
-						"volumetric"
-					]
-				]
-			],
-			[
-				13,
-				"rb2",
-				[
-					6,
-					"glassBorderHighlight",
-					[
-						"sdf",
-						"edgeSoftness",
-						"pxH",
-						"gradX",
-						"gradY",
-						"lightAngle",
-						"highlight"
-					]
-				]
-			],
-			[
-				13,
-				"blurredRgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"blurred",
-							"x"
-						],
-						[
-							7,
-							"blurred",
-							"y"
-						],
-						[
-							7,
-							"blurred",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"tintedRgb",
-				[
-					6,
-					"glassTint",
-					[
-						"blurredRgb",
-						"tintColor",
-						"tintIntensity",
-						"tintPreserveLuminosity"
-					]
-				]
-			],
-			[
-				13,
-				"specGlint",
-				[
-					6,
-					"glassSpecular",
-					[
-						"gradX",
-						"gradY",
-						"lightAngle",
-						"highlight",
-						"highlightSoftness",
-						"refrStrength"
-					]
-				]
-			],
-			[
-				13,
-				"fresnelRim",
-				[
-					6,
-					"glassFresnelRim",
-					[
-						"sdf",
-						"gradX",
-						"gradY",
-						"fresnel",
-						"fresnelSoftness",
-						"rb1",
-						"volumetric"
-					]
-				]
-			],
-			[
-				13,
-				"litR",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"tintedRgb",
-								"x"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"highlightColor",
-									"x"
-								],
-								"*",
-								"rb2"
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"highlightColor",
-								"x"
-							],
-							"*",
-							"specGlint"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"fresnelColor",
-							"x"
-						],
-						"*",
-						"fresnelRim"
-					]
-				]
-			],
-			[
-				13,
-				"litG",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"tintedRgb",
-								"y"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"highlightColor",
-									"y"
-								],
-								"*",
-								"rb2"
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"highlightColor",
-								"y"
-							],
-							"*",
-							"specGlint"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"fresnelColor",
-							"y"
-						],
-						"*",
-						"fresnelRim"
-					]
-				]
-			],
-			[
-				13,
-				"litB",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"tintedRgb",
-								"z"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"highlightColor",
-									"z"
-								],
-								"*",
-								"rb2"
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"highlightColor",
-								"z"
-							],
-							"*",
-							"specGlint"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"fresnelColor",
-							"z"
-						],
-						"*",
-						"fresnelRim"
-					]
-				]
-			],
-			[
-				13,
-				"litA",
-				[
-					1,
-					[
-						7,
-						"blurred",
-						"w"
-					],
-					"+",
-					"rb2"
-				]
-			],
-			[
-				13,
-				"lighting",
-				[
-					6,
-					"d.vec4f",
-					[
-						"litR",
-						"litG",
-						"litB",
-						"litA"
-					]
-				]
-			],
-			[
-				13,
-				"transition",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0"],
-						[5, "1"],
-						"rb1"
-					]
-				]
-			],
-			[
-				13,
-				"composited",
-				[
-					6,
-					"std.mix",
-					[
-						"baseColor",
-						"lighting",
-						"transition"
-					]
-				]
-			],
-			[
-				13,
-				"cutoutAlpha",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						"transition",
-						[
-							1,
-							"cutout",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"composited",
-						"x"
-					],
-					[
-						7,
-						"composited",
-						"y"
-					],
-					[
-						7,
-						"composited",
-						"z"
-					],
-					[
-						1,
-						[
-							7,
-							"composited",
-							"w"
-						],
-						"*",
-						"cutoutAlpha"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"glassRefrStrength": () => glassRefrStrength,
-		"glassBorderHighlight": () => glassBorderHighlight,
-		"d.vec3f": () => vec3f,
-		"glassTint": () => glassTint,
-		"glassSpecular": () => glassSpecular,
-		"glassFresnelRim": () => glassFresnelRim,
-		"d.vec4f": () => vec4f,
-		"std.smoothstep": () => smoothstep,
-		"std.mix": () => mix,
-		"std.select": () => select,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-function applyGlassEffect(params, sdfSampler, childTexture, blurredTexture, options) {
-	const { uniforms, propValues, ctx } = params;
-	const volumetric = options?.volumetric ?? false;
-	const bakedGradients = options?.bakedGradients ?? false;
-	const volFlag = floatE(volumetric ? 1 : 0);
-	const sdfUV = asLocal(call(sdfSpaceUV, "sdfSpaceUV", [
-		uniforms.center,
-		uniforms.scale,
-		uniforms.rotation,
-		ctx.uv,
-		ctx.aspect
-	]), "glassSdfUV");
-	const surf0 = asLocal(sdfSampler(sdfUV), "glassSurf");
-	const sdfRaw = surf0.member("r");
-	let gradX;
-	let gradY;
-	if (bakedGradients) {
-		gradX = surf0.member("g");
-		gradY = surf0.member("b");
-	} else {
-		const surfX = sdfSampler(call(offsetUV, "offsetUV", [
-			sdfUV,
-			floatE(.01),
-			floatE(0)
-		]));
-		const surfY = sdfSampler(call(offsetUV, "offsetUV", [
-			sdfUV,
-			floatE(0),
-			floatE(.01)
-		]));
-		const grad = asLocal(call(glassGradient, "glassGradient", [
-			sdfRaw,
-			surfX.member("r"),
-			surfY.member("r")
-		]), "glassGrad");
-		gradX = grad.member("x");
-		gradY = grad.member("y");
-	}
-	const lens = asLocal(call(glassLensUVs, "glassLensUVs", [
-		ctx.uv,
-		uniforms.center,
-		sdfRaw,
-		uniforms.scale,
-		gradX,
-		gradY,
-		uniforms.refraction,
-		uniforms.innerZoom,
-		uniforms.thickness,
-		uniforms.aberration,
-		ctx.aspect,
-		volFlag
-	]), "glassLens");
-	const lensUV = lens.member("lensUV");
-	const rUV = lens.member("rUV");
-	const bUV = lens.member("bUV");
-	const blurVal = propValues.blur;
-	const blurEnabled = typeof blurVal === "number" ? blurVal > 0 : true;
-	const abVal = propValues.aberration;
-	const aberrationEnabled = typeof abVal === "number" ? abVal > 0 : true;
-	const blurTap = (tex, uv, offOx, offOy) => tex.sample(uv.add(call(glassBlurOffset, "glassBlurOffset", [
-		ctx.viewportSize,
-		uniforms.blur,
-		floatE(offOx),
-		floatE(offOy)
-	])));
-	const vogelAccum = (tex, uv) => {
-		let acc = blurTap(tex, uv, BLUR_DISK[0][0], BLUR_DISK[0][1]);
-		for (let i = 1; i < BLUR_DISK.length; i++) acc = acc.add(blurTap(tex, uv, BLUR_DISK[i][0], BLUR_DISK[i][1]));
-		return acc.mul(1 / BLUR_SAMPLE_COUNT);
-	};
-	let blurred;
-	if (blurredTexture && blurEnabled) blurred = aberrationEnabled ? vec4(blurredTexture.sample(rUV).member("r"), blurredTexture.sample(lensUV).member("g"), blurredTexture.sample(bUV).member("b"), blurredTexture.sample(lensUV).member("a")) : blurredTexture.sample(lensUV);
-	else if (!blurEnabled && !aberrationEnabled) blurred = childTexture.sample(lensUV);
-	else if (!blurEnabled && aberrationEnabled) blurred = vec4(childTexture.sample(rUV).member("r"), childTexture.sample(lensUV).member("g"), childTexture.sample(bUV).member("b"), childTexture.sample(lensUV).member("a"));
-	else if (blurEnabled && !aberrationEnabled) blurred = vogelAccum(childTexture, lensUV);
-	else {
-		const accR = vogelAccum(childTexture, rUV);
-		const accG = vogelAccum(childTexture, lensUV);
-		const accB = vogelAccum(childTexture, bUV);
-		blurred = vec4(accR.member("r"), accG.member("g"), accB.member("b"), accG.member("a"));
-	}
-	const blurredStraight = call(unpremultiplyAlpha, "unpremultiplyAlpha", [blurred]);
-	return call(glassComposite, "glassComposite", [
-		call(unpremultiplyAlpha, "unpremultiplyAlpha", [childTexture.sample(ctx.uv)]),
-		blurredStraight,
-		sdfRaw,
-		uniforms.scale,
-		gradX,
-		gradY,
-		ctx.viewportSize,
-		uniforms.edgeSoftness,
-		uniforms.lightAngle,
-		uniforms.highlight,
-		uniforms.highlightColor.member("rgb"),
-		uniforms.highlightSoftness,
-		uniforms.fresnel,
-		uniforms.fresnelColor.member("rgb"),
-		uniforms.fresnelSoftness,
-		uniforms.thickness,
-		uniforms.tintColor.member("rgb"),
-		uniforms.tintIntensity,
-		uniforms.tintPreserveLuminosity,
-		uniforms.cutout,
-		volFlag
-	]);
-}
-export { sdfSpaceUV as i, glass_exports as n, offsetUV as r, glassGradient as t };