luxscura 0.1.0

package/dist/pbr.js

@@ -0,0 +1,1179 @@
+import { f32 as e, struct as t, vec3f as n } from "typegpu/data";
+import { clamp as r, dot as i, max as a, mix as o, normalize as s, pow as c, reflect as l, sqrt as u } from "typegpu/std";
+//#region src/appearances/pbr/material.ts
+var d = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, n) {
+	"use gpu";
+	return f({
+		baseColor: o(e.baseColor, t.baseColor, n),
+		metallic: o(e.metallic, t.metallic, n),
+		roughness: o(e.roughness, t.roughness, n),
+		emission: o(e.emission, t.emission, n)
+	});
+}), {
+	v: 2,
+	name: "mixPbrMaterials",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "a"
+			},
+			{
+				type: "i",
+				name: "b"
+			},
+			{
+				type: "i",
+				name: "amount"
+			}
+		],
+		body: [0, [[10, [
+			6,
+			"PbrMaterial",
+			[[104, {
+				baseColor: [
+					6,
+					"mix",
+					[
+						[
+							7,
+							"a",
+							"baseColor"
+						],
+						[
+							7,
+							"b",
+							"baseColor"
+						],
+						"amount"
+					]
+				],
+				metallic: [
+					6,
+					"mix",
+					[
+						[
+							7,
+							"a",
+							"metallic"
+						],
+						[
+							7,
+							"b",
+							"metallic"
+						],
+						"amount"
+					]
+				],
+				roughness: [
+					6,
+					"mix",
+					[
+						[
+							7,
+							"a",
+							"roughness"
+						],
+						[
+							7,
+							"b",
+							"roughness"
+						],
+						"amount"
+					]
+				],
+				emission: [
+					6,
+					"mix",
+					[
+						[
+							7,
+							"a",
+							"emission"
+						],
+						[
+							7,
+							"b",
+							"emission"
+						],
+						"amount"
+					]
+				]
+			}]]
+		]]]]
+	},
+	externals: {
+		PbrMaterial: () => f,
+		mix: () => o
+	}
+}) && e.f)({}), f = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t({
+	baseColor: n,
+	metallic: e,
+	roughness: e,
+	emission: n
+}), "PbrMaterial"), p = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, a, o, c, l, u) {
+	"use gpu";
+	let d = r(i(e, a), 0, 1);
+	if (o === 0 || d === 0) return n(0);
+	let f = s(__tsover_add(t, a)), p = r(i(e, f), 0, 1), h = r(i(t, f), 0, 1), g = m(o, d, p, u, _(h, l)), v = _(h, n(.04)), y = __tsover_div(__tsover_mul(__tsover_sub(1, v), c), Math.PI);
+	return __tsover_mul(d, __tsover_add(y, g));
+}), {
+	v: 2,
+	name: "evaluateDirectLightResponse",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "normal"
+			},
+			{
+				type: "i",
+				name: "viewDirection"
+			},
+			{
+				type: "i",
+				name: "lightDirection"
+			},
+			{
+				type: "i",
+				name: "normalDotView"
+			},
+			{
+				type: "i",
+				name: "diffuseColor"
+			},
+			{
+				type: "i",
+				name: "specularF0"
+			},
+			{
+				type: "i",
+				name: "alpha"
+			}
+		],
+		body: [0, [
+			[
+				13,
+				"normalDotLight",
+				[
+					6,
+					"clamp",
+					[
+						[
+							6,
+							"dot",
+							["normal", "lightDirection"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				11,
+				[
+					3,
+					[
+						1,
+						"normalDotView",
+						"===",
+						[5, "0"]
+					],
+					"||",
+					[
+						1,
+						"normalDotLight",
+						"===",
+						[5, "0"]
+					]
+				],
+				[10, [
+					6,
+					"vec3f",
+					[[5, "0"]]
+				]]
+			],
+			[
+				13,
+				"halfwayDirection",
+				[
+					6,
+					"normalize",
+					[[
+						1,
+						"viewDirection",
+						"+",
+						"lightDirection"
+					]]
+				]
+			],
+			[
+				13,
+				"normalDotHalf",
+				[
+					6,
+					"clamp",
+					[
+						[
+							6,
+							"dot",
+							["normal", "halfwayDirection"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"viewDotHalf",
+				[
+					6,
+					"clamp",
+					[
+						[
+							6,
+							"dot",
+							["viewDirection", "halfwayDirection"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"fresnel",
+				[
+					6,
+					"fresnelSchlick",
+					["viewDotHalf", "specularF0"]
+				]
+			],
+			[
+				13,
+				"specular",
+				[
+					6,
+					"calculateSpecularResponse",
+					[
+						"normalDotView",
+						"normalDotLight",
+						"normalDotHalf",
+						"alpha",
+						"fresnel"
+					]
+				]
+			],
+			[
+				13,
+				"dielectricFresnel",
+				[
+					6,
+					"fresnelSchlick",
+					["viewDotHalf", [
+						6,
+						"vec3f",
+						[[5, "0.04"]]
+					]]
+				]
+			],
+			[
+				13,
+				"diffuse",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[5, "1"],
+							"-",
+							"dielectricFresnel"
+						],
+						"*",
+						"diffuseColor"
+					],
+					"/",
+					"Math.PI"
+				]
+			],
+			[10, [
+				1,
+				"normalDotLight",
+				"*",
+				[
+					1,
+					"diffuse",
+					"+",
+					"specular"
+				]
+			]]
+		]]
+	},
+	externals: {
+		clamp: () => r,
+		dot: () => i,
+		vec3f: () => n,
+		normalize: () => s,
+		fresnelSchlick: () => _,
+		calculateSpecularResponse: () => m,
+		"Math.PI": () => Math.PI
+	}
+}) && e.f)({}), m = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, n, r, i) {
+	"use gpu";
+	let a = g(n, r), o = h(e, t, r);
+	return __tsover_mul(__tsover_mul(a, o), i);
+}), {
+	v: 2,
+	name: "calculateSpecularResponse",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "normalDotView"
+			},
+			{
+				type: "i",
+				name: "normalDotLight"
+			},
+			{
+				type: "i",
+				name: "normalDotHalf"
+			},
+			{
+				type: "i",
+				name: "alpha"
+			},
+			{
+				type: "i",
+				name: "fresnel"
+			}
+		],
+		body: [0, [
+			[
+				13,
+				"distribution",
+				[
+					6,
+					"distributionGGX",
+					["normalDotHalf", "alpha"]
+				]
+			],
+			[
+				13,
+				"visibility",
+				[
+					6,
+					"visibilitySmithGGX",
+					[
+						"normalDotView",
+						"normalDotLight",
+						"alpha"
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"distribution",
+					"*",
+					"visibility"
+				],
+				"*",
+				"fresnel"
+			]]
+		]]
+	},
+	externals: {
+		distributionGGX: () => g,
+		visibilitySmithGGX: () => h
+	}
+}) && e.f)({}), h = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, n) {
+	"use gpu";
+	let r = __tsover_mul(n, n), i = __tsover_mul(t, u(__tsover_add(__tsover_mul(__tsover_mul(e, e), __tsover_sub(1, r)), r))), a = __tsover_mul(e, u(__tsover_add(__tsover_mul(__tsover_mul(t, t), __tsover_sub(1, r)), r)));
+	return __tsover_div(.5, __tsover_add(i, a));
+}), {
+	v: 2,
+	name: "visibilitySmithGGX",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "normalDotView"
+			},
+			{
+				type: "i",
+				name: "normalDotLight"
+			},
+			{
+				type: "i",
+				name: "alpha"
+			}
+		],
+		body: [0, [
+			[
+				13,
+				"alphaSquared",
+				[
+					1,
+					"alpha",
+					"*",
+					"alpha"
+				]
+			],
+			[
+				13,
+				"viewTerm",
+				[
+					1,
+					"normalDotLight",
+					"*",
+					[
+						6,
+						"sqrt",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"normalDotView",
+									"*",
+									"normalDotView"
+								],
+								"*",
+								[
+									1,
+									[5, "1"],
+									"-",
+									"alphaSquared"
+								]
+							],
+							"+",
+							"alphaSquared"
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"lightTerm",
+				[
+					1,
+					"normalDotView",
+					"*",
+					[
+						6,
+						"sqrt",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"normalDotLight",
+									"*",
+									"normalDotLight"
+								],
+								"*",
+								[
+									1,
+									[5, "1"],
+									"-",
+									"alphaSquared"
+								]
+							],
+							"+",
+							"alphaSquared"
+						]]
+					]
+				]
+			],
+			[10, [
+				1,
+				[5, "0.5"],
+				"/",
+				[
+					1,
+					"viewTerm",
+					"+",
+					"lightTerm"
+				]
+			]]
+		]]
+	},
+	externals: { sqrt: () => u }
+}) && e.f)({}), g = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t) {
+	"use gpu";
+	let n = __tsover_mul(t, t), r = __tsover_add(__tsover_mul(__tsover_mul(e, e), __tsover_sub(n, 1)), 1);
+	return __tsover_div(n, __tsover_mul(__tsover_mul(Math.PI, r), r));
+}), {
+	v: 2,
+	name: "distributionGGX",
+	ast: {
+		params: [{
+			type: "i",
+			name: "normalDotHalf"
+		}, {
+			type: "i",
+			name: "alpha"
+		}],
+		body: [0, [
+			[
+				13,
+				"alphaSquared",
+				[
+					1,
+					"alpha",
+					"*",
+					"alpha"
+				]
+			],
+			[
+				13,
+				"denominator",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"normalDotHalf",
+							"*",
+							"normalDotHalf"
+						],
+						"*",
+						[
+							1,
+							"alphaSquared",
+							"-",
+							[5, "1"]
+						]
+					],
+					"+",
+					[5, "1"]
+				]
+			],
+			[10, [
+				1,
+				"alphaSquared",
+				"/",
+				[
+					1,
+					[
+						1,
+						"Math.PI",
+						"*",
+						"denominator"
+					],
+					"*",
+					"denominator"
+				]
+			]]
+		]]
+	},
+	externals: { "Math.PI": () => Math.PI }
+}) && e.f)({}), _ = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t) {
+	"use gpu";
+	return __tsover_add(t, __tsover_mul(__tsover_sub(1, t), c(__tsover_sub(1, e), 5)));
+}), {
+	v: 2,
+	name: "fresnelSchlick",
+	ast: {
+		params: [{
+			type: "i",
+			name: "cosTheta"
+		}, {
+			type: "i",
+			name: "specularF0"
+		}],
+		body: [0, [[10, [
+			1,
+			"specularF0",
+			"+",
+			[
+				1,
+				[
+					1,
+					[5, "1"],
+					"-",
+					"specularF0"
+				],
+				"*",
+				[
+					6,
+					"pow",
+					[[
+						1,
+						[5, "1"],
+						"-",
+						"cosTheta"
+					], [5, "5"]]
+				]
+			]
+		]]]]
+	},
+	externals: { pow: () => c }
+}) && e.f)({}), v = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t({
+	position: n,
+	normal: n,
+	material: f
+}), "PbrSurfaceSample");
+function y({ lighting: e, environment: t }) {
+	let c = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, n, r, o) {
+		"use gpu";
+		let s = t(l(__tsover_mul(-1, e), n), o), c = _(a(i(n, e), 0), r);
+		return __tsover_mul(s, c);
+	}), {
+		v: 2,
+		name: "calculateReflection",
+		ast: {
+			params: [
+				{
+					type: "i",
+					name: "viewDirection"
+				},
+				{
+					type: "i",
+					name: "normal"
+				},
+				{
+					type: "i",
+					name: "specularF0"
+				},
+				{
+					type: "i",
+					name: "roughness"
+				}
+			],
+			body: [0, [
+				[
+					13,
+					"reflectionDirection",
+					[
+						6,
+						"reflect",
+						[[
+							1,
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							"*",
+							"viewDirection"
+						], "normal"]
+					]
+				],
+				[
+					13,
+					"environmentColor",
+					[
+						6,
+						"environment",
+						["reflectionDirection", "roughness"]
+					]
+				],
+				[
+					13,
+					"facing",
+					[
+						6,
+						"max",
+						[[
+							6,
+							"dot",
+							["normal", "viewDirection"]
+						], [5, "0"]]
+					]
+				],
+				[
+					13,
+					"fresnel",
+					[
+						6,
+						"fresnelSchlick",
+						["facing", "specularF0"]
+					]
+				],
+				[10, [
+					1,
+					"environmentColor",
+					"*",
+					"fresnel"
+				]]
+			]]
+		},
+		externals: {
+			reflect: () => l,
+			environment: () => t,
+			max: () => a,
+			dot: () => i,
+			fresnelSchlick: () => _
+		}
+	}) && e.f)({}), u = /*#__PURE__*/ ((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (function(t, n, o, c) {
+		"use gpu";
+		let l = __tsover_mul(o.baseColor, __tsover_sub(1, o.metallic)), u = __tsover_mul(e().ambient, l), d = e().directionalLights, f = r(i(n, t), 0, 1);
+		if (f === 0) return u;
+		let m = a(__tsover_mul(o.roughness, o.roughness), .001);
+		for (let e of d) {
+			if (e.intensity === 0) continue;
+			let r = p(n, t, __tsover_mul(-1, s(e.direction)), f, l, c, m);
+			u = __tsover_add(u, __tsover_mul(__tsover_mul(e.color, e.intensity), r));
+		}
+		return u;
+	}), {
+		v: 2,
+		name: "calculateDirectLighting",
+		ast: {
+			params: [
+				{
+					type: "i",
+					name: "viewDirection"
+				},
+				{
+					type: "i",
+					name: "normal"
+				},
+				{
+					type: "i",
+					name: "material"
+				},
+				{
+					type: "i",
+					name: "specularF0"
+				}
+			],
+			body: [0, [
+				[
+					13,
+					"diffuseColor",
+					[
+						1,
+						[
+							7,
+							"material",
+							"baseColor"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"material",
+								"metallic"
+							]
+						]
+					]
+				],
+				[
+					12,
+					"accumulatedLight",
+					[
+						1,
+						[
+							7,
+							[
+								6,
+								"lighting",
+								[]
+							],
+							"ambient"
+						],
+						"*",
+						"diffuseColor"
+					]
+				],
+				[
+					13,
+					"directionalLights",
+					[
+						7,
+						[
+							6,
+							"lighting",
+							[]
+						],
+						"directionalLights"
+					]
+				],
+				[
+					13,
+					"normalDotView",
+					[
+						6,
+						"clamp",
+						[
+							[
+								6,
+								"dot",
+								["normal", "viewDirection"]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"normalDotView",
+						"===",
+						[5, "0"]
+					],
+					[10, "accumulatedLight"]
+				],
+				[
+					13,
+					"minimumAlpha",
+					[5, "0.001"]
+				],
+				[
+					13,
+					"alpha",
+					[
+						6,
+						"max",
+						[[
+							1,
+							[
+								7,
+								"material",
+								"roughness"
+							],
+							"*",
+							[
+								7,
+								"material",
+								"roughness"
+							]
+						], "minimumAlpha"]
+					]
+				],
+				[
+					18,
+					[13, "light"],
+					"directionalLights",
+					[0, [
+						[
+							11,
+							[
+								1,
+								[
+									7,
+									"light",
+									"intensity"
+								],
+								"===",
+								[5, "0"]
+							],
+							[16]
+						],
+						[
+							13,
+							"lightDirection",
+							[
+								1,
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								"*",
+								[
+									6,
+									"normalize",
+									[[
+										7,
+										"light",
+										"direction"
+									]]
+								]
+							]
+						],
+						[
+							13,
+							"response",
+							[
+								6,
+								"evaluateDirectLightResponse",
+								[
+									"normal",
+									"viewDirection",
+									"lightDirection",
+									"normalDotView",
+									"diffuseColor",
+									"specularF0",
+									"alpha"
+								]
+							]
+						],
+						[
+							2,
+							"accumulatedLight",
+							"+=",
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"light",
+										"color"
+									],
+									"*",
+									[
+										7,
+										"light",
+										"intensity"
+									]
+								],
+								"*",
+								"response"
+							]
+						]
+					]]
+				],
+				[10, "accumulatedLight"]
+			]]
+		},
+		externals: {
+			lighting: () => e,
+			clamp: () => r,
+			dot: () => i,
+			max: () => a,
+			normalize: () => s,
+			evaluateDirectLightResponse: () => p
+		}
+	}) && t.f)({});
+	return /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t) {
+		"use gpu";
+		let r = t.material, i = s(__tsover_sub(e, t.position)), a = n(.04), l = o(a, r.baseColor, r.metallic), d = u(i, t.normal, r, l), f = c(i, t.normal, l, r.roughness);
+		return __tsover_add(__tsover_add(d, r.emission), f);
+	}), {
+		v: 2,
+		name: "shadeSurface",
+		ast: {
+			params: [{
+				type: "i",
+				name: "cameraPosition"
+			}, {
+				type: "i",
+				name: "sample"
+			}],
+			body: [0, [
+				[
+					13,
+					"material",
+					[
+						7,
+						"sample",
+						"material"
+					]
+				],
+				[
+					13,
+					"viewDirection",
+					[
+						6,
+						"normalize",
+						[[
+							1,
+							"cameraPosition",
+							"-",
+							[
+								7,
+								"sample",
+								"position"
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"dielectricF0",
+					[
+						6,
+						"vec3f",
+						[[5, "0.04"]]
+					]
+				],
+				[
+					13,
+					"specularF0",
+					[
+						6,
+						"mix",
+						[
+							"dielectricF0",
+							[
+								7,
+								"material",
+								"baseColor"
+							],
+							[
+								7,
+								"material",
+								"metallic"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"directLighting",
+					[
+						6,
+						"calculateDirectLighting",
+						[
+							"viewDirection",
+							[
+								7,
+								"sample",
+								"normal"
+							],
+							"material",
+							"specularF0"
+						]
+					]
+				],
+				[
+					13,
+					"reflection",
+					[
+						6,
+						"calculateReflection",
+						[
+							"viewDirection",
+							[
+								7,
+								"sample",
+								"normal"
+							],
+							"specularF0",
+							[
+								7,
+								"material",
+								"roughness"
+							]
+						]
+					]
+				],
+				[10, [
+					1,
+					[
+						1,
+						"directLighting",
+						"+",
+						[
+							7,
+							"material",
+							"emission"
+						]
+					],
+					"+",
+					"reflection"
+				]]
+			]]
+		},
+		externals: {
+			normalize: () => s,
+			vec3f: () => n,
+			mix: () => o,
+			calculateDirectLighting: () => u,
+			calculateReflection: () => c
+		}
+	}) && e.f)({});
+}
+function b({ material: e, lighting: t, environment: r }) {
+	let i = y({
+		lighting: t,
+		environment: r
+	});
+	return /*#__PURE__*/ ((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = (function(t) {
+		"use gpu";
+		let r = e(t);
+		return t.isHit ? i(t.rayOrigin, v({
+			position: t.position,
+			normal: t.normal,
+			material: r
+		})) : n(0);
+	}), {
+		v: 2,
+		name: "pbrAppearance",
+		ast: {
+			params: [{
+				type: "i",
+				name: "result"
+			}],
+			body: [0, [
+				[
+					13,
+					"materialSample",
+					[
+						6,
+						"material",
+						["result"]
+					]
+				],
+				[
+					11,
+					[
+						4,
+						"!",
+						[
+							7,
+							"result",
+							"isHit"
+						]
+					],
+					[10, [
+						6,
+						"vec3f",
+						[[5, "0"]]
+					]]
+				],
+				[10, [
+					6,
+					"shadeSurface",
+					[[
+						7,
+						"result",
+						"rayOrigin"
+					], [
+						6,
+						"PbrSurfaceSample",
+						[[104, {
+							position: [
+								7,
+								"result",
+								"position"
+							],
+							normal: [
+								7,
+								"result",
+								"normal"
+							],
+							material: "materialSample"
+						}]]
+					]]
+				]]
+			]]
+		},
+		externals: {
+			material: () => e,
+			vec3f: () => n,
+			shadeSurface: () => i,
+			PbrSurfaceSample: () => v
+		}
+	}) && t.f)({});
+}
+//#endregion
+export { f as PbrMaterial, b as createPbrAppearance, d as mixPbrMaterials };
+
+//# sourceMappingURL=pbr.js.map