shaders 3.1.462 → 3.2.464

package/dist/core/lighting-CBczjo6Y.js

@@ -1,1133 +0,0 @@
-import { Ft as vec3f, Lt as vec4f, Mt as vec2f, _t as max, bt as normalize, ct as clamp, dt as dot, et as typegpu_default, ft as exp, gt as length, hn as __export, it as abs, kt as sqrt, lt as cos, on as bool, qt as struct, rt as select, sn as f32, vt as min } from "./edges-CV-BHMpI.js";
-import { s as TWO_PI } from "./constants-BKlzQFdJ.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(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), eps), __tsover_mul(gradClamp, -1), gradClamp), clamp(__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,
-		"std.normalize": () => normalize,
-		"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(length(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,
-		"std.length": () => length,
-		"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(__tsover_mul(sharpEdge, .03125), __tsover_mul(pxH, minPixels));
-	return clamp(__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,
-		"std.clamp": () => clamp
-	}
-}) && $.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(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,
-		"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(dir.sub(normal.mul(dot(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,
-		"std.dot": () => dot,
-		"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(p.light.sub(p.view));
-	const hT = dot(H, frame.tangent);
-	const hB = dot(H, frame.bitangent);
-	const hN = clamp(abs(dot(H, p.normal)), 1e-4, 1);
-	const aT = max(p.alphaAlong, 1e-4);
-	const aB = max(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(__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,
-		"std.dot": () => dot,
-		"std.clamp": () => clamp,
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.exp": () => exp
-	}
-}) && $.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)({}));
-export { lighting_exports as n, cosinePalette as t };