shaders 3.1.463 → 3.2.465

package/dist/core/materials-Dhq8lDKb.js

@@ -0,0 +1,2943 @@
+import { $n as clamp$1, Br as f32, En as value12, Fn as TWO_PI, Jn as select, Jr as __export, Nr as struct, P as sdf_exports, Sn as perlin12d, St as neutral, Tr as vec4f, Yn as abs, _r as smoothstep$1, bn as mxWorleyNoiseFloat2Pub, cr as max$1, dr as normalize$1, er as cos, fr as pow$1, gr as sin$1, lr as min, mn as hash12, nr as dot$1, ot as call, pt as Expr, rr as exp$1, rt as ZERO, sr as length$1, ur as mix$1, ut as floatE, vn as mxNoiseFloat2, vr as sqrt, wr as vec3f, xr as vec2f, yn as mxNoiseFloat3, zn as typegpu_default, zr as bool } from "./lower-DSk_KxOY.js";
+import { m as sdf3d_exports } from "./sdf3d-DQ55w9nI.js";
+import { n as glass_exports } from "./glass-CtWl8jzT.js";
+import { C as mul, E as pow, L as sub, M as smoothstep, P as splat3, R as vec2, S as mix, T as normalize, b as max, c as exp, i as clamp, j as sin, l as exp2, n as add, o as div, s as dot, u as float, v as length, w as neg, y as local, z as vec3 } from "./math-DCQU6EQz.js";
+var lighting_exports = /* @__PURE__ */ __export({
+	TangentFrame: () => TangentFrame,
+	WardSpecularInput: () => WardSpecularInput,
+	bevelledFlatNormal: () => bevelledFlatNormal,
+	cosinePalette: () => cosinePalette,
+	fieldGradient: () => fieldGradient,
+	insideMask: () => insideMask,
+	orthonormalTangentFrame: () => orthonormalTangentFrame,
+	outsideShape: () => outsideShape,
+	patternCoords: () => patternCoords,
+	perspectiveViewRay: () => perspectiveViewRay,
+	volumetricNormal: () => volumetricNormal,
+	wardAnisotropicSpecular: () => wardAnisotropicSpecular
+});
+const fieldGradient = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, eps) => {
+	"use gpu";
+	return vec2f(__tsover_div(__tsover_sub(surfX.x, surf0.x), eps), __tsover_div(__tsover_sub(surfY.x, surf0.x), eps));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "surfX"
+			},
+			{
+				"type": "i",
+				"name": "surfY"
+			},
+			{
+				"type": "i",
+				"name": "eps"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"d.vec2f",
+			[[
+				1,
+				[
+					1,
+					[
+						7,
+						"surfX",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"surf0",
+						"x"
+					]
+				],
+				"/",
+				"eps"
+			], [
+				1,
+				[
+					1,
+					[
+						7,
+						"surfY",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"surf0",
+						"x"
+					]
+				],
+				"/",
+				"eps"
+			]]
+		]]]]
+	},
+	externals: { "d.vec2f": () => vec2f }
+}) && $.f)({}));
+const volumetricNormal = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, eps, gradClamp) => {
+	"use gpu";
+	return normalize$1(vec3f(clamp$1(__tsover_div(__tsover_sub(surfX.w, surf0.w), eps), __tsover_mul(gradClamp, -1), gradClamp), clamp$1(__tsover_div(__tsover_sub(surfY.w, surf0.w), eps), __tsover_mul(gradClamp, -1), gradClamp), -1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "surfX"
+			},
+			{
+				"type": "i",
+				"name": "surfY"
+			},
+			{
+				"type": "i",
+				"name": "eps"
+			},
+			{
+				"type": "i",
+				"name": "gradClamp"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ddx",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfX",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"eps"
+						],
+						[
+							1,
+							"gradClamp",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gradClamp"
+					]
+				]
+			],
+			[
+				13,
+				"ddy",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfY",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"eps"
+						],
+						[
+							1,
+							"gradClamp",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gradClamp"
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.normalize",
+				[[
+					6,
+					"d.vec3f",
+					[
+						"ddx",
+						"ddy",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.clamp": () => clamp$1,
+		"std.normalize": () => normalize$1,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const bevelledFlatNormal = typegpu_default.fn([vec2f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((grad, sinTilt) => {
+	"use gpu";
+	const glen = max$1(length$1(grad), 1e-4);
+	const sB = min(sinTilt, .9995);
+	return vec3f(__tsover_mul(__tsover_div(grad.x, glen), sB), __tsover_mul(__tsover_div(grad.y, glen), sB), __tsover_mul(sqrt(__tsover_sub(1, __tsover_mul(sB, sB))), -1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "grad"
+		}, {
+			"type": "i",
+			"name": "sinTilt"
+		}],
+		"body": [0, [
+			[
+				13,
+				"glen",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.length",
+						["grad"]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"sB",
+				[
+					6,
+					"std.min",
+					["sinTilt", [5, "0.9995"]]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"grad",
+								"x"
+							],
+							"/",
+							"glen"
+						],
+						"*",
+						"sB"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"grad",
+								"y"
+							],
+							"/",
+							"glen"
+						],
+						"*",
+						"sB"
+					],
+					[
+						1,
+						[
+							6,
+							"std.sqrt",
+							[[
+								1,
+								[5, "1"],
+								"-",
+								[
+									1,
+									"sB",
+									"*",
+									"sB"
+								]
+							]]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max$1,
+		"std.length": () => length$1,
+		"std.min": () => min,
+		"d.vec3f": () => vec3f,
+		"std.sqrt": () => sqrt
+	}
+}) && $.f)({}));
+const patternCoords = typegpu_default.fn([
+	vec2f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, surf0, volumetric) => {
+	"use gpu";
+	return vec2f(select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5), select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "volumetric"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"d.vec2f",
+			[[
+				6,
+				"std.select",
+				[
+					[
+						1,
+						[
+							7,
+							"sdfUV",
+							"x"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					[
+						7,
+						"surf0",
+						"y"
+					],
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			], [
+				6,
+				"std.select",
+				[
+					[
+						1,
+						[
+							7,
+							"sdfUV",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					[
+						7,
+						"surf0",
+						"z"
+					],
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.select": () => select
+	}
+}) && $.f)({}));
+const outsideShape = typegpu_default.fn([f32, f32], bool)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, pxH) => {
+	"use gpu";
+	return sdf > __tsover_mul(pxH, 2);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sdf"
+		}, {
+			"type": "i",
+			"name": "pxH"
+		}],
+		"body": [0, [[10, [
+			1,
+			"sdf",
+			">",
+			[
+				1,
+				"pxH",
+				"*",
+				[5, "2"]
+			]
+		]]]]
+	},
+	externals: {}
+}) && $.f)({}));
+const insideMask = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, sharpEdge, pxH, minPixels) => {
+	"use gpu";
+	const w = max$1(__tsover_mul(sharpEdge, .03125), __tsover_mul(pxH, minPixels));
+	return clamp$1(__tsover_div(__tsover_mul(sdf, -1), w), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdf"
+			},
+			{
+				"type": "i",
+				"name": "sharpEdge"
+			},
+			{
+				"type": "i",
+				"name": "pxH"
+			},
+			{
+				"type": "i",
+				"name": "minPixels"
+			}
+		],
+		"body": [0, [[
+			13,
+			"w",
+			[
+				6,
+				"std.max",
+				[[
+					1,
+					"sharpEdge",
+					"*",
+					[5, "0.03125"]
+				], [
+					1,
+					"pxH",
+					"*",
+					"minPixels"
+				]]
+			]
+		], [10, [
+			6,
+			"std.clamp",
+			[
+				[
+					1,
+					[
+						1,
+						"sdf",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"/",
+					"w"
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]]
+	},
+	externals: {
+		"std.max": () => max$1,
+		"std.clamp": () => clamp$1
+	}
+}) && $.f)({}));
+const perspectiveViewRay = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, fov) => {
+	"use gpu";
+	return normalize$1(vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "fov"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"std.normalize",
+			[[
+				6,
+				"d.vec3f",
+				[
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							"aspect"
+						],
+						"*",
+						"fov"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						"fov"
+					],
+					[5, "1"]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.normalize": () => normalize$1,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const TangentFrame = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	tangent: vec3f,
+	bitangent: vec3f
+}), "TangentFrame");
+const orthonormalTangentFrame = typegpu_default.fn([vec3f, vec3f], TangentFrame)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normal, dir) => {
+	"use gpu";
+	const T3 = normalize$1(dir.sub(normal.mul(dot$1(normal, dir))));
+	return TangentFrame({
+		tangent: T3,
+		bitangent: vec3f(__tsover_sub(__tsover_mul(normal.y, T3.z), __tsover_mul(normal.z, T3.y)), __tsover_sub(__tsover_mul(normal.z, T3.x), __tsover_mul(normal.x, T3.z)), __tsover_sub(__tsover_mul(normal.x, T3.y), __tsover_mul(normal.y, T3.x)))
+	});
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "normal"
+		}, {
+			"type": "i",
+			"name": "dir"
+		}],
+		"body": [0, [
+			[
+				13,
+				"T3",
+				[
+					6,
+					"std.normalize",
+					[[
+						6,
+						[
+							7,
+							"dir",
+							"sub"
+						],
+						[[
+							6,
+							[
+								7,
+								"normal",
+								"mul"
+							],
+							[[
+								6,
+								"std.dot",
+								["normal", "dir"]
+							]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"B3",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"TangentFrame",
+				[[104, {
+					"tangent": "T3",
+					"bitangent": "B3"
+				}]]
+			]]
+		]]
+	},
+	externals: {
+		"std.normalize": () => normalize$1,
+		"std.dot": () => dot$1,
+		"d.vec3f": () => vec3f,
+		"TangentFrame": () => TangentFrame
+	}
+}) && $.f)({}));
+const WardSpecularInput = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	normal: vec3f,
+	tangent: vec3f,
+	light: vec3f,
+	view: vec3f,
+	alphaAlong: f32,
+	alphaAcross: f32
+}), "WardSpecularInput");
+const wardAnisotropicSpecular = typegpu_default.fn([WardSpecularInput], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	const frame = orthonormalTangentFrame(p.normal, p.tangent);
+	const H = normalize$1(p.light.sub(p.view));
+	const hT = dot$1(H, frame.tangent);
+	const hB = dot$1(H, frame.bitangent);
+	const hN = clamp$1(abs(dot$1(H, p.normal)), 1e-4, 1);
+	const aT = max$1(p.alphaAlong, 1e-4);
+	const aB = max$1(p.alphaAcross, 1e-4);
+	const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aT), __tsover_div(hT, aT)), __tsover_mul(__tsover_div(hB, aB), __tsover_div(hB, aB))), __tsover_mul(__tsover_add(hN, 1), .5));
+	return exp$1(__tsover_mul(expo, -1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [
+			[
+				13,
+				"frame",
+				[
+					6,
+					"orthonormalTangentFrame",
+					[[
+						7,
+						"p",
+						"normal"
+					], [
+						7,
+						"p",
+						"tangent"
+					]]
+				]
+			],
+			[
+				13,
+				"H",
+				[
+					6,
+					"std.normalize",
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"p",
+								"light"
+							],
+							"sub"
+						],
+						[[
+							7,
+							"p",
+							"view"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"hT",
+				[
+					6,
+					"std.dot",
+					["H", [
+						7,
+						"frame",
+						"tangent"
+					]]
+				]
+			],
+			[
+				13,
+				"hB",
+				[
+					6,
+					"std.dot",
+					["H", [
+						7,
+						"frame",
+						"bitangent"
+					]]
+				]
+			],
+			[
+				13,
+				"hN",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							"std.abs",
+							[[
+								6,
+								"std.dot",
+								["H", [
+									7,
+									"p",
+									"normal"
+								]]
+							]]
+						],
+						[5, "0.0001"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"aT",
+				[
+					6,
+					"std.max",
+					[[
+						7,
+						"p",
+						"alphaAlong"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"aB",
+				[
+					6,
+					"std.max",
+					[[
+						7,
+						"p",
+						"alphaAcross"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"expo",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"hT",
+								"/",
+								"aT"
+							],
+							"*",
+							[
+								1,
+								"hT",
+								"/",
+								"aT"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								"hB",
+								"/",
+								"aB"
+							],
+							"*",
+							[
+								1,
+								"hB",
+								"/",
+								"aB"
+							]
+						]
+					],
+					"/",
+					[
+						1,
+						[
+							1,
+							"hN",
+							"+",
+							[5, "1"]
+						],
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.exp",
+				[[
+					1,
+					"expo",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"orthonormalTangentFrame": () => orthonormalTangentFrame,
+		"std.normalize": () => normalize$1,
+		"std.dot": () => dot$1,
+		"std.clamp": () => clamp$1,
+		"std.abs": () => abs,
+		"std.max": () => max$1,
+		"std.exp": () => exp$1
+	}
+}) && $.f)({}));
+const cosinePalette = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phaseR, phaseG, phaseB) => {
+	"use gpu";
+	return vec3f(__tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseR), TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseG), TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseB), TWO_PI)), .5), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "phaseR"
+			},
+			{
+				"type": "i",
+				"name": "phaseG"
+			},
+			{
+				"type": "i",
+				"name": "phaseB"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"d.vec3f",
+			[
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseR"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseG"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseB"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			]
+		]]]]
+	},
+	externals: {
+		"d.vec3f": () => vec3f,
+		"std.cos": () => cos,
+		"TWO_PI": () => TWO_PI
+	}
+}) && $.f)({}));
+const silhouetteAlpha = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, edgeSoftness, pxH) => {
+	"use gpu";
+	return smoothstep$1(0, 1, insideMask(sdf, max$1(__tsover_mul(edgeSoftness, .5), .001), pxH, 1.5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdf"
+			},
+			{
+				"type": "i",
+				"name": "edgeSoftness"
+			},
+			{
+				"type": "i",
+				"name": "pxH"
+			}
+		],
+		"body": [0, [[
+			13,
+			"sharpEdge",
+			[
+				6,
+				"std.max",
+				[[
+					1,
+					"edgeSoftness",
+					"*",
+					[5, "0.5"]
+				], [5, "0.001"]]
+			]
+		], [10, [
+			6,
+			"std.smoothstep",
+			[
+				[5, "0"],
+				[5, "1"],
+				[
+					6,
+					"insideMask",
+					[
+						"sdf",
+						"sharpEdge",
+						"pxH",
+						[5, "1.5"]
+					]
+				]
+			]
+		]]]]
+	},
+	externals: {
+		"std.max": () => max$1,
+		"std.smoothstep": () => smoothstep$1,
+		"insideMask": () => insideMask
+	}
+}) && $.f)({}));
+const KeyLight = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	L: vec3f,
+	H: vec3f
+}), "KeyLight");
+const keyLight = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], KeyLight)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lx, ly, lz) => {
+	"use gpu";
+	const L = normalize$1(vec3f(lx, ly, lz));
+	return KeyLight({
+		L,
+		H: normalize$1(L.add(vec3f(0, 0, -1)))
+	});
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "lx"
+			},
+			{
+				"type": "i",
+				"name": "ly"
+			},
+			{
+				"type": "i",
+				"name": "lz"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"L",
+				[
+					6,
+					"std.normalize",
+					[[
+						6,
+						"d.vec3f",
+						[
+							"lx",
+							"ly",
+							"lz"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"H",
+				[
+					6,
+					"std.normalize",
+					[[
+						6,
+						[
+							7,
+							"L",
+							"add"
+						],
+						[[
+							6,
+							"d.vec3f",
+							[
+								[5, "0"],
+								[5, "0"],
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[10, [
+				6,
+				"KeyLight",
+				[[104, {
+					"L": "L",
+					"H": "H"
+				}]]
+			]]
+		]]
+	},
+	externals: {
+		"std.normalize": () => normalize$1,
+		"d.vec3f": () => vec3f,
+		"KeyLight": () => KeyLight
+	}
+}) && $.f)({}));
+const grazingView = typegpu_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((n) => {
+	"use gpu";
+	return __tsover_sub(1, clamp$1(__tsover_mul(n.z, -1), 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "n"
+		}],
+		"body": [0, [[10, [
+			1,
+			[5, "1"],
+			"-",
+			[
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[
+							7,
+							"n",
+							"z"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]
+		]]]]
+	},
+	externals: { "std.clamp": () => clamp$1 }
+}) && $.f)({}));
+const sharpGlint$1 = typegpu_default.fn([
+	f32,
+	f32,
+	vec4f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ndh, sharp, cfg) => {
+	"use gpu";
+	return __tsover_mul(pow$1(ndh, mix$1(cfg.x, cfg.y, sharp)), mix$1(cfg.z, cfg.w, sharp));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "ndh"
+			},
+			{
+				"type": "i",
+				"name": "sharp"
+			},
+			{
+				"type": "i",
+				"name": "cfg"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				"std.pow",
+				["ndh", [
+					6,
+					"std.mix",
+					[
+						[
+							7,
+							"cfg",
+							"x"
+						],
+						[
+							7,
+							"cfg",
+							"y"
+						],
+						"sharp"
+					]
+				]]
+			],
+			"*",
+			[
+				6,
+				"std.mix",
+				[
+					[
+						7,
+						"cfg",
+						"z"
+					],
+					[
+						7,
+						"cfg",
+						"w"
+					],
+					"sharp"
+				]
+			]
+		]]]]
+	},
+	externals: {
+		"std.pow": () => pow$1,
+		"std.mix": () => mix$1
+	}
+}) && $.f)({}));
+const clampedPerlinGrad = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((q, gain) => {
+	"use gpu";
+	const gMax = f32(4);
+	const nd = perlin12d(q);
+	return vec2f(clamp$1(__tsover_mul(nd.y, gain), __tsover_mul(gMax, -1), gMax), clamp$1(__tsover_mul(nd.z, gain), __tsover_mul(gMax, -1), gMax));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "q"
+		}, {
+			"type": "i",
+			"name": "gain"
+		}],
+		"body": [0, [
+			[
+				13,
+				"gMax",
+				[
+					6,
+					"d.f32",
+					[[5, "4"]]
+				]
+			],
+			[
+				13,
+				"nd",
+				[
+					6,
+					"perlin12d",
+					["q"]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								7,
+								"nd",
+								"y"
+							],
+							"*",
+							"gain"
+						],
+						[
+							1,
+							"gMax",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gMax"
+					]
+				], [
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								7,
+								"nd",
+								"z"
+							],
+							"*",
+							"gain"
+						],
+						[
+							1,
+							"gMax",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gMax"
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"d.f32": () => f32,
+		"perlin12d": () => perlin12d,
+		"d.vec2f": () => vec2f,
+		"std.clamp": () => clamp$1
+	}
+}) && $.f)({}));
+const nudgeNormal$1 = typegpu_default.fn([
+	vec3f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((n, dx, dy) => {
+	"use gpu";
+	return normalize$1(vec3f(__tsover_add(n.x, dx), __tsover_add(n.y, dy), n.z));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "n"
+			},
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"std.normalize",
+			[[
+				6,
+				"d.vec3f",
+				[
+					[
+						1,
+						[
+							7,
+							"n",
+							"x"
+						],
+						"+",
+						"dx"
+					],
+					[
+						1,
+						[
+							7,
+							"n",
+							"y"
+						],
+						"+",
+						"dy"
+					],
+					[
+						7,
+						"n",
+						"z"
+					]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.normalize": () => normalize$1,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const opticalThickness$1 = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, volumetric) => {
+	"use gpu";
+	const thickVol = clamp$1(__tsover_mul(__tsover_mul(sdf, -1), 2), 0, 1.2);
+	return select(__tsover_mul(clamp$1(__tsover_mul(sdf, -1), 0, .5), 2), thickVol, volumetric > .5);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sdf"
+		}, {
+			"type": "i",
+			"name": "volumetric"
+		}],
+		"body": [0, [
+			[
+				13,
+				"thickVol",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							[5, "2"]
+						],
+						[5, "0"],
+						[5, "1.2"]
+					]
+				]
+			],
+			[
+				13,
+				"thickFlat",
+				[
+					1,
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							[5, "0"],
+							[5, "0.5"]
+						]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[10, [
+				6,
+				"std.select",
+				[
+					"thickFlat",
+					"thickVol",
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.clamp": () => clamp$1,
+		"std.select": () => select
+	}
+}) && $.f)({}));
+const beerLambert$1 = typegpu_default.fn([f32, vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((thickness, absorb) => {
+	"use gpu";
+	return vec3f(exp$1(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), exp$1(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), exp$1(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "thickness"
+		}, {
+			"type": "i",
+			"name": "absorb"
+		}],
+		"body": [0, [[10, [
+			6,
+			"d.vec3f",
+			[
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							"thickness",
+							"*",
+							[
+								7,
+								"absorb",
+								"x"
+							]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				],
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							"thickness",
+							"*",
+							[
+								7,
+								"absorb",
+								"y"
+							]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				],
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							"thickness",
+							"*",
+							[
+								7,
+								"absorb",
+								"z"
+							]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				]
+			]
+		]]]]
+	},
+	externals: {
+		"d.vec3f": () => vec3f,
+		"std.exp": () => exp$1
+	}
+}) && $.f)({}));
+const flowWarpOffset = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((warpInput, flowT) => {
+	"use gpu";
+	return vec2f(__tsover_mul(sin$1(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3))), __tsover_mul(cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), sin$1(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1))));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "warpInput"
+		}, {
+			"type": "i",
+			"name": "flowT"
+		}],
+		"body": [0, [
+			[
+				13,
+				"wx",
+				[
+					1,
+					[
+						6,
+						"std.sin",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"x"
+									],
+									"*",
+									[5, "1.7"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.7"]
+								]
+							],
+							"+",
+							[5, "1.7"]
+						]]
+					],
+					"*",
+					[
+						6,
+						"std.cos",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"y"
+									],
+									"*",
+									[5, "1.3"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.5"]
+								]
+							],
+							"+",
+							[5, "2.3"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"wy",
+				[
+					1,
+					[
+						6,
+						"std.cos",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"x"
+									],
+									"*",
+									[5, "1.4"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.9"]
+								]
+							],
+							"+",
+							[5, "8.7"]
+						]]
+					],
+					"*",
+					[
+						6,
+						"std.sin",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"y"
+									],
+									"*",
+									[5, "1.6"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.6"]
+								]
+							],
+							"+",
+							[5, "5.1"]
+						]]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["wx", "wy"]
+			]]
+		]]
+	},
+	externals: {
+		"std.sin": () => sin$1,
+		"std.cos": () => cos,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const studio5Softbox = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr, skyGain) => {
+	"use gpu";
+	const ex = __tsover_sub(__tsover_mul(rx, envC), __tsover_mul(ry, envS));
+	const ey = __tsover_add(__tsover_mul(rx, envS), __tsover_mul(ry, envC));
+	const p = vec2f(ex, ey);
+	const sky = smoothstep$1(-.7, .85, ey);
+	let lum = __tsover_mul(__tsover_mul(sky, sky), skyGain);
+	const r0 = __tsover_mul(keyRad, 1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r0, __tsover_mul(r0, .2), length$1(p.sub(vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
+	const r1 = __tsover_mul(keyRad, 1.15);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r1, __tsover_mul(r1, .2), length$1(p.sub(vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
+	const r2 = __tsover_mul(keyRad, 1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r2, __tsover_mul(r2, .2), length$1(p.sub(vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
+	const r3 = __tsover_mul(keyRad, 1.3);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r3, __tsover_mul(r3, .2), length$1(p.sub(vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
+	const r4 = __tsover_mul(keyRad, 1.1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r4, __tsover_mul(r4, .2), length$1(p.sub(vec2f(__tsover_add(-.35, drift), -.25)))), .85), envStr));
+	return lum;
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "rx"
+			},
+			{
+				"type": "i",
+				"name": "ry"
+			},
+			{
+				"type": "i",
+				"name": "envC"
+			},
+			{
+				"type": "i",
+				"name": "envS"
+			},
+			{
+				"type": "i",
+				"name": "keyRad"
+			},
+			{
+				"type": "i",
+				"name": "drift"
+			},
+			{
+				"type": "i",
+				"name": "envStr"
+			},
+			{
+				"type": "i",
+				"name": "skyGain"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ex",
+				[
+					1,
+					[
+						1,
+						"rx",
+						"*",
+						"envC"
+					],
+					"-",
+					[
+						1,
+						"ry",
+						"*",
+						"envS"
+					]
+				]
+			],
+			[
+				13,
+				"ey",
+				[
+					1,
+					[
+						1,
+						"rx",
+						"*",
+						"envS"
+					],
+					"+",
+					[
+						1,
+						"ry",
+						"*",
+						"envC"
+					]
+				]
+			],
+			[
+				13,
+				"p",
+				[
+					6,
+					"d.vec2f",
+					["ex", "ey"]
+				]
+			],
+			[
+				13,
+				"sky",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[
+							4,
+							"-",
+							[5, "0.7"]
+						],
+						[5, "0.85"],
+						"ey"
+					]
+				]
+			],
+			[
+				12,
+				"lum",
+				[
+					1,
+					[
+						1,
+						"sky",
+						"*",
+						"sky"
+					],
+					"*",
+					"skyGain"
+				]
+			],
+			[
+				13,
+				"r0",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.smoothstep",
+								[
+									"r0",
+									[
+										1,
+										"r0",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										"std.length",
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[
+													1,
+													[5, "0"],
+													"+",
+													"drift"
+												], [5, "0.55"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1.7"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r1",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.15"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.smoothstep",
+								[
+									"r1",
+									[
+										1,
+										"r1",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										"std.length",
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[
+													1,
+													[
+														4,
+														"-",
+														[5, "0.55"]
+													],
+													"+",
+													"drift"
+												], [5, "0.18"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1.05"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r2",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.smoothstep",
+								[
+									"r2",
+									[
+										1,
+										"r2",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										"std.length",
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[
+													1,
+													[5, "0.55"],
+													"+",
+													"drift"
+												], [5, "0.1"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r3",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.3"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.smoothstep",
+								[
+									"r3",
+									[
+										1,
+										"r3",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										"std.length",
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[
+													1,
+													[5, "0.2"],
+													"+",
+													"drift"
+												], [
+													4,
+													"-",
+													[5, "0.5"]
+												]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "0.7"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r4",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.smoothstep",
+								[
+									"r4",
+									[
+										1,
+										"r4",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										"std.length",
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[
+													1,
+													[
+														4,
+														"-",
+														[5, "0.35"]
+													],
+													"+",
+													"drift"
+												], [
+													4,
+													"-",
+													[5, "0.25"]
+												]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "0.85"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[10, "lum"]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.smoothstep": () => smoothstep$1,
+		"std.length": () => length$1
+	}
+}) && $.f)({}));
+var bevel_exports = /* @__PURE__ */ __export({ bevelSin: () => bevelSin });
+const bevelSin = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, shape) => {
+	"use gpu";
+	const sRound = __tsover_sub(1, t);
+	const k1 = smoothstep$1(0, .14, t);
+	const k2 = smoothstep$1(.68, .92, t);
+	return mix$1(sRound, mix$1(f32(1), __tsover_mul(.72, __tsover_sub(1, k2)), k1), shape);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "shape"
+		}],
+		"body": [0, [
+			[
+				13,
+				"sRound",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"t"
+				]
+			],
+			[
+				13,
+				"k1",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0"],
+						[5, "0.14"],
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"k2",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0.68"],
+						[5, "0.92"],
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"sMach",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[
+							1,
+							[5, "0.72"],
+							"*",
+							[
+								1,
+								[5, "1"],
+								"-",
+								"k2"
+							]
+						],
+						"k1"
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.mix",
+				[
+					"sRound",
+					"sMach",
+					"shape"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.smoothstep": () => smoothstep$1,
+		"std.mix": () => mix$1,
+		"d.f32": () => f32
+	}
+}) && $.f)({}));
+var { sdfSpaceUV, offsetUV } = glass_exports;
+var { ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
+var { createVolumetricFieldComputeNode, resolveShapeFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
+var guardCounter = 0;
+function guarded(cond, inner, fallback, hint = "guarded", deps = []) {
+	const id = guardCounter++;
+	return new Expr((ctx) => ctx.memo(`guard:${id}`, () => {
+		const name = ctx.freshLocal(hint);
+		const condText = cond._emit(ctx);
+		const fallbackText = fallback._emit(ctx);
+		for (const dep of deps) dep._emit(ctx);
+		const stmts = [];
+		const innerText = inner._emit({
+			external: (v, h) => ctx.external(v, h),
+			statement: (w) => stmts.push(w),
+			freshLocal: (h) => ctx.freshLocal(h),
+			memo: (k, f) => ctx.memo(k, f)
+		});
+		ctx.statement(`var ${name} = ${fallbackText};`);
+		ctx.statement(`if (${condText}) {\n  ${stmts.join("\n  ")}\n  ${name} = ${innerText};\n}`);
+		return name;
+	}));
+}
+function insideShape(sdf, pxH) {
+	const outside = call(outsideShape, "outsideShape", [sdf, pxH]);
+	return new Expr((ctx) => `(!(${outside._emit(ctx)}))`);
+}
+function shapedSurface(spec) {
+	const pattern = spec.pattern ?? "none";
+	const chord = spec.chord ?? "span";
+	const stencil = spec.stencil ?? {
+		kind: "forward",
+		eps: .01
+	};
+	const compute = (params) => createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), pattern, chord);
+	const fragment = (params) => {
+		const { childNode, computeOutputs, convertToTexture, uniforms, ctx } = params;
+		let childTexture;
+		if (spec.child === "required") {
+			if (!childNode) return ZERO;
+			childTexture = computeOutputs?.childTexture ?? convertToTexture(childNode);
+		}
+		const { sampler, gradSampler, volumetric, bakedGradients } = resolveShapeFieldSampler(params, {
+			patternMode: pattern,
+			gradSampler: spec.gradSampler ?? "fast",
+			bakedGradients: spec.bakedGradients ?? "none"
+		});
+		const frame = {
+			sampler,
+			gradSampler,
+			volumetric,
+			bakedGradients,
+			volFlag: floatE(volumetric ? 1 : 0),
+			childTexture
+		};
+		if (stencil !== "none") {
+			const screenUV = spec.placeUV ? spec.placeUV(params) : ctx.uv;
+			frame.sdfUV = local(call(sdfSpaceUV, "sdfSpaceUV", [
+				uniforms.center,
+				uniforms.scale,
+				uniforms.rotation,
+				screenUV,
+				ctx.aspect
+			]), "sdfUV");
+			frame.surf0 = (spec.centreTap === "fast" ? gradSampler : sampler)(frame.sdfUV);
+			if (stencil !== "centre") {
+				const { kind, eps } = stencil;
+				frame.surfX = gradSampler(call(offsetUV, "offsetUV", [
+					frame.sdfUV,
+					floatE(eps),
+					floatE(0)
+				]));
+				if (kind === "central") frame.surfL = gradSampler(call(offsetUV, "offsetUV", [
+					frame.sdfUV,
+					floatE(-eps),
+					floatE(0)
+				]));
+				frame.surfY = gradSampler(call(offsetUV, "offsetUV", [
+					frame.sdfUV,
+					floatE(0),
+					floatE(eps)
+				]));
+				if (kind === "central") frame.surfD = gradSampler(call(offsetUV, "offsetUV", [
+					frame.sdfUV,
+					floatE(0),
+					floatE(-eps)
+				]));
+			}
+		}
+		return spec.surface(frame, params);
+	};
+	return {
+		extraFields: {
+			...VOLUMETRIC_FIELD_EXTRA_FIELDS,
+			...ANALYTIC_SDF_EXTRA_FIELDS
+		},
+		compute,
+		gpu: { fragment }
+	};
+}
+function surfaceField(frame, params, opts = {}) {
+	const { ctx } = params;
+	const s0 = local(frame.surf0, "s0");
+	const pxH = local(div(1, ctx.viewportSize.member("y")), "pxH");
+	const sdf = local(opts.scale ? div(s0.member("x"), opts.scale) : s0.member("x"), "sdf");
+	const aspect = div(ctx.viewportSize.member("x"), ctx.viewportSize.member("y"));
+	return {
+		s0,
+		sX: frame.surfX ? local(frame.surfX, "sX") : void 0,
+		sY: frame.surfY ? local(frame.surfY, "sY") : void 0,
+		sdf,
+		pxH,
+		aspect
+	};
+}
+function geometricNormal(frame, field, opts) {
+	const eps = float(opts.eps ?? .01);
+	const hint = opts.hint ?? "nGeo";
+	if (frame.volumetric) return local(call(volumetricNormal, "volumetricNormal", [
+		field.s0,
+		field.sX,
+		field.sY,
+		eps,
+		float(opts.sharpness ?? 5)
+	]), hint);
+	const rimT = clamp(div(neg(field.sdf), max(opts.bevelWidth, .003)), 0, 1);
+	return local(call(bevelledFlatNormal, "bevelledFlatNormal", [call(fieldGradient, "fieldGradient", [
+		field.s0,
+		field.sX,
+		field.sY,
+		eps
+	]), call(bevelSin, "bevelSin", [rimT, opts.bevelShape])]), hint);
+}
+function surfacePattern(frame, field, opts = {}) {
+	return local(call(patternCoords, "patternCoords", [
+		opts.uv ?? frame.sdfUV,
+		field.s0,
+		frame.volFlag
+	]), "pat");
+}
+function fieldSlope(field, eps = .01) {
+	return local(call(fieldGradient, "fieldGradient", [
+		field.s0,
+		field.sX,
+		field.sY,
+		float(eps)
+	]), "grad");
+}
+function viewRay(params, field, fov = .6) {
+	return local(call(perspectiveViewRay, "perspectiveViewRay", [
+		params.ctx.uv,
+		field.aspect,
+		float(fov)
+	]), "viewI");
+}
+function grazingOf(n, view) {
+	return local(sub(1, clamp(neg(dot(n, view)), 0, 1)), "grazing");
+}
+function tiltNormal(n, frame, slopes, hint = "n") {
+	const terms = (axis) => {
+		const out = [];
+		if (slopes.across) out.push(mul(frame.perp.member(axis), slopes.across));
+		if (slopes.along) out.push(mul(frame.tangent.member(axis), slopes.along));
+		return out;
+	};
+	const sum = (base, extra) => extra.reduce((acc, e) => add(acc, e), base);
+	return local(normalize(vec3(sum(n.member("x"), terms("x")), sum(n.member("y"), terms("y")), n.member("z"))), hint);
+}
+function studioSoftboxes(x, y, opts) {
+	const toE = (v) => typeof v === "number" ? float(v) : v;
+	return call(studio5Softbox, "studio5Softbox", [
+		x,
+		y,
+		opts.rotation.member("x"),
+		opts.rotation.member("y"),
+		toE(opts.keyRadius),
+		toE(opts.drift),
+		toE(opts.strength),
+		float(opts.skyGain)
+	]);
+}
+function grainNoise(coords, opts) {
+	let x = mul(coords.along, opts.freq[0]);
+	let y = mul(coords.across, opts.freq[1]);
+	if (opts.offset?.[0]) x = add(x, opts.offset[0]);
+	if (opts.offset?.[1]) y = add(y, opts.offset[1]);
+	if (opts.drift) x = add(x, opts.drift);
+	return call(mxNoiseFloat2, "mxNoiseFloat2", [vec2(x, y)]);
+}
+function smearAlong(opts, sample) {
+	const taps = opts.taps ?? 9;
+	const sigma = opts.sigma ?? 2.1;
+	const half = (taps - 1) / 2;
+	const raw = Array.from({ length: taps }, (_, i) => Math.exp(-((i - half) ** 2) / (2 * sigma * sigma)));
+	const sum = raw.reduce((a, b) => a + b, 0);
+	const weights = raw.map((w) => w / sum);
+	const step = local(div(opts.spread, half), "step");
+	let acc = float(0);
+	for (let i = 0; i < taps; i++) {
+		const off = local(mul(step, float(i - half)), "off");
+		acc = add(acc, mul(sample(add(opts.center.member("x"), mul(opts.axis.member("x"), off)), add(opts.center.member("y"), mul(opts.axis.member("y"), off))), float(weights[i])));
+	}
+	return local(acc, opts.hint ?? "smear");
+}
+function lightVec3(dir, z, hint = "L") {
+	return local(normalize(vec3(dir.member("x"), dir.member("y"), float(z))), hint);
+}
+function wardAlphas(roughness, anisotropy) {
+	const baseA = local(mix(.05, .45, roughness), "baseA");
+	return {
+		along: mul(baseA, add(1, mul(anisotropy, 7))),
+		across: max(mul(baseA, sub(1, mul(anisotropy, .55))), .02)
+	};
+}
+function anisoSpecular(opts) {
+	const spec = call(wardAnisotropicSpecular, "wardAnisotropicSpecular", [call(WardSpecularInput, "WardSpecularInput", [
+		opts.normal,
+		vec3(opts.tangent.member("x"), opts.tangent.member("y"), 0),
+		opts.light,
+		opts.view,
+		opts.alphas.along,
+		opts.alphas.across
+	])]);
+	return opts.gain === void 0 ? spec : mul(spec, opts.gain);
+}
+function tiltAlong(n, axis, amount, hint = "n") {
+	return local(normalize(vec3(add(n.member("x"), mul(axis.member("x"), amount)), add(n.member("y"), mul(axis.member("y"), amount)), n.member("z"))), hint);
+}
+function fresnelBoost(grazing, opts) {
+	return add(1, mul(pow(grazing, float(opts.power ?? 3)), opts.amount));
+}
+function tintRamp(t, dark, light) {
+	return mix(dark.member("rgb"), light.member("rgb"), splat3(t));
+}
+function silhouette(field, edgeSoftness) {
+	return call(silhouetteAlpha, "silhouetteAlpha", [
+		field.sdf,
+		edgeSoftness,
+		field.pxH
+	]);
+}
+function neutralTone(rgb) {
+	return call(neutral, "tonemapNeutral", [rgb]);
+}
+function nudgeNormal(n, dx, dy, hint = "n") {
+	return local(call(nudgeNormal$1, "nudgeNormal", [
+		n,
+		dx,
+		dy
+	]), hint);
+}
+function marchedNormal(field, sharpness = 5, hint = "nGeo") {
+	return local(call(volumetricNormal, "volumetricNormal", [
+		field.s0,
+		field.sX,
+		field.sY,
+		float(.01),
+		float(sharpness)
+	]), hint);
+}
+function keyLightAt(dir, elevation, hint = "kl") {
+	return keyLightXY(dir.member("x"), dir.member("y"), elevation, hint);
+}
+function keyLightXY(x, y, elevation, hint = "kl") {
+	return local(call(keyLight, "keyLight", [
+		x,
+		y,
+		float(elevation)
+	]), hint);
+}
+function grazingFlat(n) {
+	return local(call(grazingView, "grazingView", [n]), "grazing");
+}
+function sharpGlint(ndh, sharpness, cfg) {
+	return call(sharpGlint$1, "sharpGlint", [
+		ndh,
+		sharpness,
+		cfg
+	]);
+}
+function perlinSlope(q, gain) {
+	return call(clampedPerlinGrad, "clampedPerlinGrad", [q, typeof gain === "number" ? float(gain) : gain]);
+}
+function opticalThickness(field, frame) {
+	return call(opticalThickness$1, "opticalThickness", [field.sdf, frame.volFlag]);
+}
+function beerLambert(thickness, absorb) {
+	return call(beerLambert$1, "beerLambert", [thickness, absorb]);
+}
+function flowWarp(warpInput, flowT) {
+	return call(flowWarpOffset, "flowWarpOffset", [warpInput, flowT]);
+}
+function surfaceNoise(x, y) {
+	return call(mxNoiseFloat2, "mxNoiseFloat2", [vec2(x, y)]);
+}
+function surfaceNoiseAt(p) {
+	return call(mxNoiseFloat2, "mxNoiseFloat2", [p]);
+}
+function volumeNoiseAt(p) {
+	return call(mxNoiseFloat3, "mxNoiseFloat3", [p]);
+}
+function cosineRainbow(t, phases) {
+	return call(cosinePalette, "cosinePalette", [
+		t,
+		float(phases[0]),
+		float(phases[1]),
+		float(phases[2])
+	]);
+}
+function cellNoiseAt(p) {
+	return call(mxWorleyNoiseFloat2Pub, "mxWorleyNoiseFloat2Pub", [p, float(1)]);
+}
+function fdSlope(sampleAt, p, eps, hint = "fd") {
+	const value = local(sampleAt(p), `${hint}0`);
+	return {
+		value,
+		dx: local(div(sub(sampleAt(add(p, vec2(eps, 0))), value), eps), `${hint}X`),
+		dy: local(div(sub(sampleAt(add(p, vec2(0, eps))), value), eps), `${hint}Y`)
+	};
+}
+function hashNoise(x, y) {
+	return call(hash12, "hash12", [vec2(x, y)]);
+}
+function valueNoise(x, y) {
+	return call(value12, "value12", [vec2(x, y)]);
+}
+function rotationSensor(frame) {
+	const s0C = local(frame.gradSampler(vec2(.5, .5)), "s0C");
+	return {
+		x: local(mul(neg(s0C.member("y")), frame.volFlag), "rotSenseX"),
+		y: local(mul(neg(s0C.member("z")), frame.volFlag), "rotSenseY")
+	};
+}
+function shellRefract(frame, n, amount) {
+	const cx = local(sub(frame.sdfUV.member("x"), .5), "cx");
+	const cy = local(sub(frame.sdfUV.member("y"), .5), "cy");
+	return {
+		x: local(add(cx, mul(n.member("x"), amount)), "bentX"),
+		y: local(add(cy, mul(n.member("y"), amount)), "bentY"),
+		centered: {
+			x: cx,
+			y: cy
+		}
+	};
+}
+function schlickFresnel(grazing, opts) {
+	return add(opts.r0 ?? .04, mul(pow(grazing, float(opts.power ?? 5)), opts.gain));
+}
+function twinkle(t, phase, opts) {
+	return add(sub(1, opts.amount), mul(sin(add(mul(t, opts.rate), mul(phase, opts.spread))), opts.amount));
+}
+function pointStars(p, opts) {
+	const hint = opts.hint ?? "stars";
+	const variation = local(add(mul(surfaceNoiseAt(mul(p, opts.variationFreq)), .5), .5), `${hint}V`);
+	const shimmer = opts.shimmer ? opts.shimmer(variation) : float(1);
+	const glint = local(mul(mul(mul(smoothstep(add(opts.radius[0], mul(variation, opts.radius[1])), 5e-4, cellNoiseAt(p)), smoothstep(opts.keep[0], opts.keep[1], variation)), mul(add(opts.brightness[0], mul(mul(variation, variation), opts.brightness[1])), shimmer)), opts.gain), hint);
+	return {
+		glint,
+		variation,
+		rgb: opts.tint ? mul(mix(vec3(...opts.tint.from), vec3(...opts.tint.to), splat3(variation)), splat3(mul(glint, opts.tint.gain))) : void 0
+	};
+}
+function placementPoint(params, position, hint = "placed") {
+	const { uniforms, ctx } = params;
+	const screenUV = vec2(position.member("x"), sub(1, position.member("y")));
+	return local(call(sdfSpaceUV, "sdfSpaceUV", [
+		uniforms.center,
+		uniforms.scale,
+		uniforms.rotation,
+		screenUV,
+		ctx.aspect
+	]), hint);
+}
+function continuedField(frame, field, params) {
+	if (!(!frame.volumetric && Boolean(params.propValues.shapeSdfUrl))) return {
+		sdf: field.sdf,
+		outward: vec2(0, 0),
+		at: (uv$1) => frame.gradSampler(uv$1).member("x")
+	};
+	const uv = frame.sdfUV;
+	const beyond = (p) => sub(p, clamp(p, vec2(0, 0), vec2(1, 1)));
+	const outward = local(beyond(uv), "outward");
+	const continued = (border, dist) => max(border, max(dist, sub(border, dist)));
+	return {
+		sdf: local(continued(field.sdf, length(outward)), "sdfFar"),
+		outward,
+		at: (p) => {
+			const dist = length(beyond(p));
+			return continued(frame.gradSampler(p).member("x"), dist);
+		}
+	};
+}
+function nearestEdge(sdfUV, sdf, slope, hint = "edge") {
+	const normal = local(div(slope, max(length(slope), 1e-4)), `${hint}N`);
+	return {
+		point: local(sub(sdfUV, mul(normal, max(sdf, 0))), `${hint}P`),
+		normal
+	};
+}
+function pointLightFrom(light, at, hint = "pl") {
+	const delta = local(sub(light.position, at), `${hint}D`);
+	const distance = local(length(delta), `${hint}Dist`);
+	const toLight = local(div(delta, max(distance, 1e-4)), `${hint}Dir`);
+	return {
+		L: local(normalize(vec3(delta.member("x"), delta.member("y"), neg(light.height))), `${hint}L`),
+		toLight,
+		distance
+	};
+}
+function lambert(normal, light, opts = {}) {
+	const ndl = dot(normal, light);
+	if (opts.wrap === void 0) return max(ndl, 0);
+	return clamp(div(add(ndl, opts.wrap), add(1, opts.wrap)), 0, 1);
+}
+function inverseSquare(distance, range) {
+	const r = div(distance, range);
+	return div(1, add(1, mul(r, r)));
+}
+function exposureTone(rgb) {
+	return sub(1, exp(neg(rgb)));
+}
+function dualLobeGlint(ndh, opts) {
+	const widen = opts.softness ? local(exp2(mix(2, -2, opts.softness)), "lobeWiden") : void 0;
+	const exponent = (e) => widen ? mul(e, widen) : float(e);
+	return mul(add(mul(pow(ndh, exponent(opts.core[0])), opts.core[1]), mul(pow(ndh, exponent(opts.halo[0])), opts.halo[1])), opts.gain);
+}
+export { bevel_exports as $, placementPoint as A, studioSoftboxes as B, lightVec3 as C, nudgeNormal as D, neutralTone as E, shapedSurface as F, tiltAlong as G, surfaceNoise as H, sharpGlint as I, twinkle as J, tiltNormal as K, shellRefract as L, pointStars as M, rotationSensor as N, opticalThickness as O, schlickFresnel as P, wardAlphas as Q, silhouette as R, lambert as S, nearestEdge as T, surfaceNoiseAt as U, surfaceField as V, surfacePattern as W, viewRay as X, valueNoise as Y, volumeNoiseAt as Z, hashNoise as _, cosineRainbow as a, keyLightAt as b, fdSlope as c, fresnelBoost as d, cosinePalette as et, geometricNormal as f, guarded as g, grazingOf as h, continuedField as i, pointLightFrom as j, perlinSlope as k, fieldSlope as l, grazingFlat as m, beerLambert as n, dualLobeGlint as o, grainNoise as p, tintRamp as q, cellNoiseAt as r, exposureTone as s, anisoSpecular as t, lighting_exports as tt, flowWarp as u, insideShape as v, marchedNormal as w, keyLightXY as x, inverseSquare as y, smearAlong as z };