shaders 3.2.475 → 4.0.0

package/dist/core/materials-BjsiWqS0.js

@@ -1,2944 +0,0 @@
-import { An as value12, Bn as TWO_PI, Br as struct, Cn as mxNoiseFloat3, Cr as sin$1, En as perlin12d, Gn as typegpu_default, I as sdf_exports, Kr as bool, Mr as vec4f, Or as vec2f, Sn as mxNoiseFloat2, Tr as sqrt, _r as mix$1, ar as clamp$1, at as ZERO, cr as dot$1, ct as call, er as select, ft as floatE, gr as min, hr as max$1, ht as Expr, jr as vec3f, lr as exp$1, mr as length$1, or as cos, qr as f32, ti as __export, tr as abs, vn as hash12, vr as normalize$1, wn as mxWorleyNoiseFloat2Pub, wr as smoothstep$1, wt as neutral, yr as pow$1 } from "./lower-DtoDQ7hV.js";
-import { w as sdf3d_exports } from "./sdf3d-BMqCSSPB.js";
-import { n as glass_exports } from "./glass-DIEus1UY.js";
-import { B as vec2, C as mix, D as pow, E as normalize, I as splat3, N as sin, P as smoothstep, T as neg, V as vec3, c as exp, i as clamp, l as exp2, n as add, o as div, s as dot, u as float, v as length, w as mul, x as max, y as local, z as sub } from "./math-7PlusTFx.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, texelSampler, volumetric, bakedGradients } = resolveShapeFieldSampler(params, {
-			patternMode: pattern,
-			gradSampler: spec.gradSampler ?? "fast",
-			bakedGradients: spec.bakedGradients ?? "none"
-		});
-		const frame = {
-			sampler,
-			gradSampler,
-			texelSampler,
-			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 };