shaders 2.5.135 → 3.0.437

package/dist/core/glass-DdgMBWkF.js

@@ -0,0 +1,2646 @@
+import { At as call, It as vec4, Pt as floatE, R as std, Wt as unpremultiplyAlpha, cn as __export, n as tgpu, on as d } from "./coords-BlwgBpJf.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 = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.vec2f,
+	d.f32
+], d.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 = std.cos(rotRad);
+	const sinR = std.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 d.vec2f(__tsover_add(__tsover_div(rdx, scale), .5), __tsover_add(__tsover_div(rdy, scale), .5));
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"rdx",
+				[
+					1,
+					[
+						1,
+						"dxAc",
+						"*",
+						"cosR"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"rdy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						"cosR"
+					],
+					"-",
+					[
+						1,
+						"dxAc",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						"rdx",
+						"/",
+						"scale"
+					],
+					"+",
+					[5, "0.5"]
+				], [
+					1,
+					[
+						1,
+						"rdy",
+						"/",
+						"scale"
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]],
+		"externalNames": [
+			"DEG_TO_RAD",
+			"std",
+			"d"
+		]
+	},
+	externals: () => ({
+		DEG_TO_RAD,
+		std,
+		d
+	})
+}) && $.f)({}));
+const offsetUV = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
+	"use gpu";
+	return d.vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "ox"
+			},
+			{
+				"type": "i",
+				"name": "oy"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					7,
+					"uv",
+					"x"
+				],
+				"+",
+				"ox"
+			], [
+				1,
+				[
+					7,
+					"uv",
+					"y"
+				],
+				"+",
+				"oy"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const glassGradient = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfRaw, sdfX, sdfY) => {
+	"use gpu";
+	const eps = .01;
+	return d.vec2f(__tsover_div(__tsover_sub(sdfX, sdfRaw), eps), __tsover_div(__tsover_sub(sdfY, sdfRaw), eps));
+}), {
+	v: 1,
+	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,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					1,
+					"sdfX",
+					"-",
+					"sdfRaw"
+				],
+				"/",
+				"eps"
+			], [
+				1,
+				[
+					1,
+					"sdfY",
+					"-",
+					"sdfRaw"
+				],
+				"/",
+				"eps"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const glassRefrStrength = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, thickness, volumetric) => {
+	"use gpu";
+	const thicknessRange = std.max(__tsover_mul(thickness, .3), .005);
+	const depthNorm = std.clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
+	const vol = std.smoothstep(0, 1, depthNorm);
+	const flat = __tsover_mul(__tsover_sub(1, depthNorm), __tsover_sub(1, depthNorm));
+	return std.select(flat, vol, volumetric > .5);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdf"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "volumetric"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"thicknessRange",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"thickness",
+						"*",
+						[5, "0.3"]
+					], [5, "0.005"]]
+				]
+			],
+			[
+				13,
+				"depthNorm",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"/",
+							"thicknessRange"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"vol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						[5, "1"],
+						"depthNorm"
+					]
+				]
+			],
+			[
+				13,
+				"flat",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						"depthNorm"
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						"depthNorm"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"flat",
+					"vol",
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const GlassLensUVs = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	lensUV: d.vec2f,
+	rUV: d.vec2f,
+	bUV: d.vec2f
+}), "GlassLensUVs");
+const glassLensUVs = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.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 offsetX = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(gradX, -1), refrScale), refrStrength), aspect);
+	const offsetY = __tsover_mul(__tsover_mul(__tsover_mul(gradY, -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: d.vec2f(lensX, lensY),
+		rUV: d.vec2f(__tsover_add(lensX, chrOffX), __tsover_add(lensY, chrOffY)),
+		bUV: d.vec2f(__tsover_sub(lensX, chrOffX), __tsover_sub(lensY, chrOffY))
+	});
+}), {
+	v: 1,
+	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,
+				"offsetX",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"gradX",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							"refrScale"
+						],
+						"*",
+						"refrStrength"
+					],
+					"/",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"offsetY",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"gradY",
+							"*",
+							[
+								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,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						["lensX", "lensY"]
+					],
+					"rUV": [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							"lensX",
+							"+",
+							"chrOffX"
+						], [
+							1,
+							"lensY",
+							"+",
+							"chrOffY"
+						]]
+					],
+					"bUV": [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							"lensX",
+							"-",
+							"chrOffX"
+						], [
+							1,
+							"lensY",
+							"-",
+							"chrOffY"
+						]]
+					]
+				}]]
+			]]
+		]],
+		"externalNames": [
+			"glassRefrStrength",
+			"GlassLensUVs",
+			"d"
+		]
+	},
+	externals: () => ({
+		glassRefrStrength,
+		GlassLensUVs,
+		d
+	})
+}) && $.f)({}));
+const glassBlurOffset = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((viewportSize, blur, ox, oy) => {
+	"use gpu";
+	const m = __tsover_mul(blur, 2);
+	return d.vec2f(__tsover_mul(__tsover_div(ox, viewportSize.x), m), __tsover_mul(__tsover_div(oy, viewportSize.y), m));
+}), {
+	v: 1,
+	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,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					1,
+					"ox",
+					"/",
+					[
+						7,
+						"viewportSize",
+						"x"
+					]
+				],
+				"*",
+				"m"
+			], [
+				1,
+				[
+					1,
+					"oy",
+					"/",
+					[
+						7,
+						"viewportSize",
+						"y"
+					]
+				],
+				"*",
+				"m"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const glassTint = tgpu.fn([
+	d.vec3f,
+	d.vec3f,
+	d.f32,
+	d.f32
+], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, tintColor, tintIntensity, preserveLum) => {
+	"use gpu";
+	const lumWeights = d.vec3f(.299, .587, .114);
+	const origLum = std.dot(rgb, lumWeights);
+	const tinted = std.mix(rgb, tintColor, tintIntensity);
+	const tintedLum = std.dot(tinted, lumWeights);
+	const lumPreserved = tinted.mul(__tsover_div(origLum, std.max(tintedLum, 1e-4)));
+	const preserveFactor = std.select(d.f32(0), d.f32(1), preserveLum > .5);
+	return std.mix(tinted, lumPreserved, preserveFactor);
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0.299"],
+						[5, "0.587"],
+						[5, "0.114"]
+					]
+				]
+			],
+			[
+				13,
+				"origLum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["rgb", "lumWeights"]
+				]
+			],
+			[
+				13,
+				"tinted",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"rgb",
+						"tintColor",
+						"tintIntensity"
+					]
+				]
+			],
+			[
+				13,
+				"tintedLum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["tinted", "lumWeights"]
+				]
+			],
+			[
+				13,
+				"lumPreserved",
+				[
+					6,
+					[
+						7,
+						"tinted",
+						"mul"
+					],
+					[[
+						1,
+						"origLum",
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["tintedLum", [5, "0.0001"]]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"preserveFactor",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"preserveLum",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"mix"
+				],
+				[
+					"tinted",
+					"lumPreserved",
+					"preserveFactor"
+				]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const glassBorderHighlight = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, edgeSoftness, pxH, gradX, gradY, lightAngle, highlight) => {
+	"use gpu";
+	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sdfOuter = __tsover_sub(sdf, pxH);
+	const rb2base = __tsover_sub(std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdfOuter, -1), sharp), 16), 0, 1), std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 16), 0, 1));
+	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const normalDotLight = __tsover_add(__tsover_mul(gradX, lx), __tsover_mul(gradY, ly));
+	const lightFacing = __tsover_add(__tsover_mul(normalDotLight, .5), .5);
+	return __tsover_mul(__tsover_mul(rb2base, lightFacing), highlight);
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"edgeSoftness",
+						"*",
+						[5, "0.5"]
+					], [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"sdfOuter",
+				[
+					1,
+					"sdf",
+					"-",
+					"pxH"
+				]
+			],
+			[
+				13,
+				"rb2base",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"sdfOuter",
+										"*",
+										[
+											4,
+											"-",
+											[5, "1"]
+										]
+									],
+									"/",
+									"sharp"
+								],
+								"*",
+								[5, "16"]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"sdf",
+										"*",
+										[
+											4,
+											"-",
+											[5, "1"]
+										]
+									],
+									"/",
+									"sharp"
+								],
+								"*",
+								[5, "16"]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"lx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"normalDotLight",
+				[
+					1,
+					[
+						1,
+						"gradX",
+						"*",
+						"lx"
+					],
+					"+",
+					[
+						1,
+						"gradY",
+						"*",
+						"ly"
+					]
+				]
+			],
+			[
+				13,
+				"lightFacing",
+				[
+					1,
+					[
+						1,
+						"normalDotLight",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"rb2base",
+					"*",
+					"lightFacing"
+				],
+				"*",
+				"highlight"
+			]]
+		]],
+		"externalNames": ["std", "DEG_TO_RAD"]
+	},
+	externals: () => ({
+		std,
+		DEG_TO_RAD
+	})
+}) && $.f)({}));
+const glassSpecular = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gradX, gradY, lightAngle, highlight, highlightSoftness, refrStrength) => {
+	"use gpu";
+	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const nz = d.f32(2);
+	const nLen = std.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 = std.exp2(__tsover_sub(8, __tsover_mul(highlightSoftness, 7)));
+	return __tsover_mul(__tsover_mul(std.pow(std.clamp(nDotH, 0, 1), shininess), highlight), refrStrength);
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"nz",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "2"]]
+				]
+			],
+			[
+				13,
+				"nLen",
+				[
+					6,
+					[
+						7,
+						"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,
+					[
+						7,
+						"std",
+						"exp2"
+					],
+					[[
+						1,
+						[5, "8"],
+						"-",
+						[
+							1,
+							"highlightSoftness",
+							"*",
+							[5, "7"]
+						]
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"nDotH",
+								[5, "0"],
+								[5, "1"]
+							]
+						], "shininess"]
+					],
+					"*",
+					"highlight"
+				],
+				"*",
+				"refrStrength"
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"DEG_TO_RAD",
+			"d",
+			"INV_HLEN_GLASS"
+		]
+	},
+	externals: () => ({
+		std,
+		DEG_TO_RAD,
+		d,
+		INV_HLEN_GLASS
+	})
+}) && $.f)({}));
+const glassFresnelRim = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.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, std.sqrt(__tsover_add(slopeSq, 1)));
+	const exponent = std.mix(6, 1.5, std.clamp(fresnelSoftness, 0, 1));
+	const volRim = __tsover_mul(__tsover_mul(__tsover_mul(std.pow(__tsover_sub(1, cosView), exponent), fresnel), 2), rb1);
+	const fresnelWidth = std.max(__tsover_mul(fresnelSoftness, .06), .001);
+	const fresnelDepth = std.clamp(__tsover_div(__tsover_mul(sdf, -1), fresnelWidth), 0, 1);
+	const flatRim = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(1, fresnelDepth), __tsover_sub(1, fresnelDepth)), fresnel), rb1);
+	return std.select(flatRim, volRim, volumetric > .5);
+}), {
+	v: 1,
+	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,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							"slopeSq",
+							"+",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"exponent",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[5, "6"],
+						[5, "1.5"],
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"fresnelSoftness",
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"volRim",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"pow"
+								],
+								[[
+									1,
+									[5, "1"],
+									"-",
+									"cosView"
+								], "exponent"]
+							],
+							"*",
+							"fresnel"
+						],
+						"*",
+						[5, "2"]
+					],
+					"*",
+					"rb1"
+				]
+			],
+			[
+				13,
+				"fresnelWidth",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"fresnelSoftness",
+						"*",
+						[5, "0.06"]
+					], [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"fresnelDepth",
+				[
+					6,
+					[
+						7,
+						"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,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"flatRim",
+					"volRim",
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const glassComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.vec3f,
+	d.f32,
+	d.f32,
+	d.vec3f,
+	d.f32,
+	d.f32,
+	d.vec3f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.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 = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const pxH = __tsover_div(1, viewportSize.y);
+	const sdf = __tsover_div(sdfRaw, scale);
+	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const refrStrength = glassRefrStrength(sdf, thickness, volumetric);
+	const rb2 = glassBorderHighlight(sdf, edgeSoftness, pxH, gradX, gradY, lightAngle, highlight);
+	const tintedRgb = glassTint(d.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 litR = __tsover_add(__tsover_add(__tsover_add(tintedRgb.x, __tsover_mul(highlightColor.x, rb2)), __tsover_mul(highlightColor.x, specGlint)), __tsover_mul(fresnelColor.x, fresnelRim));
+	const litG = __tsover_add(__tsover_add(__tsover_add(tintedRgb.y, __tsover_mul(highlightColor.y, rb2)), __tsover_mul(highlightColor.y, specGlint)), __tsover_mul(fresnelColor.y, fresnelRim));
+	const litB = __tsover_add(__tsover_add(__tsover_add(tintedRgb.z, __tsover_mul(highlightColor.z, rb2)), __tsover_mul(highlightColor.z, specGlint)), __tsover_mul(fresnelColor.z, fresnelRim));
+	const litA = __tsover_add(blurred.w, rb2);
+	const lighting = d.vec4f(litR, litG, litB, litA);
+	const transition = std.smoothstep(0, 1, rb1);
+	const composited = std.mix(baseColor, lighting, transition);
+	const cutoutAlpha = std.select(d.f32(1), transition, cutout > .5);
+	return d.vec4f(composited.x, composited.y, composited.z, __tsover_mul(composited.w, cutoutAlpha));
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"edgeSoftness",
+						"*",
+						[5, "0.5"]
+					], [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"pxH",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewportSize",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"sdf",
+				[
+					1,
+					"sdfRaw",
+					"/",
+					"scale"
+				]
+			],
+			[
+				13,
+				"rb1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"sdf",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								],
+								"/",
+								"sharp"
+							],
+							"*",
+							[5, "32"]
+						],
+						[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,
+					[
+						7,
+						"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,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"litR",
+						"litG",
+						"litB",
+						"litA"
+					]
+				]
+			],
+			[
+				13,
+				"transition",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						[5, "1"],
+						"rb1"
+					]
+				]
+			],
+			[
+				13,
+				"composited",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"baseColor",
+						"lighting",
+						"transition"
+					]
+				]
+			],
+			[
+				13,
+				"cutoutAlpha",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						"transition",
+						[
+							1,
+							"cutout",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"composited",
+						"x"
+					],
+					[
+						7,
+						"composited",
+						"y"
+					],
+					[
+						7,
+						"composited",
+						"z"
+					],
+					[
+						1,
+						[
+							7,
+							"composited",
+							"w"
+						],
+						"*",
+						"cutoutAlpha"
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"glassRefrStrength",
+			"glassBorderHighlight",
+			"d",
+			"glassTint",
+			"glassSpecular",
+			"glassFresnelRim"
+		]
+	},
+	externals: () => ({
+		std,
+		glassRefrStrength,
+		glassBorderHighlight,
+		d,
+		glassTint,
+		glassSpecular,
+		glassFresnelRim
+	})
+}) && $.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 = call(sdfSpaceUV, "sdfSpaceUV", [
+		uniforms.center,
+		uniforms.scale,
+		uniforms.rotation,
+		ctx.uv,
+		ctx.aspect
+	]);
+	const surf0 = sdfSampler(sdfUV);
+	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 = call(glassGradient, "glassGradient", [
+			sdfRaw,
+			surfX.member("r"),
+			surfY.member("r")
+		]);
+		gradX = grad.member("x");
+		gradY = grad.member("y");
+	}
+	const lens = call(glassLensUVs, "glassLensUVs", [
+		ctx.uv,
+		uniforms.center,
+		sdfRaw,
+		uniforms.scale,
+		gradX,
+		gradY,
+		uniforms.refraction,
+		uniforms.innerZoom,
+		uniforms.thickness,
+		uniforms.aberration,
+		ctx.aspect,
+		volFlag
+	]);
+	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 };