luxscura 0.1.0

package/dist/index.js

@@ -0,0 +1,1393 @@
+import { arrayOf as e, bool as t, builtin as n, f32 as r, interpolate as i, mat4x4f as a, struct as o, u32 as s, vec2f as c, vec3b as l, vec3f as u, vec4f as d } from "typegpu/data";
+import { discard as f, length as p, min as m, normalize as h, select as g } from "typegpu/std";
+import { tgpu as _ } from "typegpu";
+//#region src/aabb.ts
+var v = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, n, i) {
+	"use gpu";
+	return t > 0 ? __tsover_div(__tsover_sub(i, e), t) : t < 0 ? __tsover_div(__tsover_sub(n, e), t) : r(1e9);
+}), {
+	v: 2,
+	name: "axisExitDistance",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "position"
+			},
+			{
+				type: "i",
+				name: "direction"
+			},
+			{
+				type: "i",
+				name: "minimum"
+			},
+			{
+				type: "i",
+				name: "maximum"
+			}
+		],
+		body: [0, [
+			[
+				11,
+				[
+					1,
+					"direction",
+					">",
+					[5, "0"]
+				],
+				[10, [
+					1,
+					[
+						1,
+						"maximum",
+						"-",
+						"position"
+					],
+					"/",
+					"direction"
+				]]
+			],
+			[
+				11,
+				[
+					1,
+					"direction",
+					"<",
+					[5, "0"]
+				],
+				[10, [
+					1,
+					[
+						1,
+						"minimum",
+						"-",
+						"position"
+					],
+					"/",
+					"direction"
+				]]
+			],
+			[10, [
+				6,
+				"f32",
+				[[5, "1000000000"]]
+			]]
+		]]
+	},
+	externals: { f32: () => r }
+}) && e.f)({}), y = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t, n) {
+	"use gpu";
+	return m(v(t.x, n.x, e.min.x, e.max.x), m(v(t.y, n.y, e.min.y, e.max.y), v(t.z, n.z, e.min.z, e.max.z)));
+}), {
+	v: 2,
+	name: "aabbExitDistance",
+	ast: {
+		params: [
+			{
+				type: "i",
+				name: "aabb"
+			},
+			{
+				type: "i",
+				name: "point"
+			},
+			{
+				type: "i",
+				name: "direction"
+			}
+		],
+		body: [0, [[10, [
+			6,
+			"min",
+			[[
+				6,
+				"axisExitDistance",
+				[
+					[
+						7,
+						"point",
+						"x"
+					],
+					[
+						7,
+						"direction",
+						"x"
+					],
+					[
+						7,
+						[
+							7,
+							"aabb",
+							"min"
+						],
+						"x"
+					],
+					[
+						7,
+						[
+							7,
+							"aabb",
+							"max"
+						],
+						"x"
+					]
+				]
+			], [
+				6,
+				"min",
+				[[
+					6,
+					"axisExitDistance",
+					[
+						[
+							7,
+							"point",
+							"y"
+						],
+						[
+							7,
+							"direction",
+							"y"
+						],
+						[
+							7,
+							[
+								7,
+								"aabb",
+								"min"
+							],
+							"y"
+						],
+						[
+							7,
+							[
+								7,
+								"aabb",
+								"max"
+							],
+							"y"
+						]
+					]
+				], [
+					6,
+					"axisExitDistance",
+					[
+						[
+							7,
+							"point",
+							"z"
+						],
+						[
+							7,
+							"direction",
+							"z"
+						],
+						[
+							7,
+							[
+								7,
+								"aabb",
+								"min"
+							],
+							"z"
+						],
+						[
+							7,
+							[
+								7,
+								"aabb",
+								"max"
+							],
+							"z"
+						]
+					]
+				]]
+			]]
+		]]]]
+	},
+	externals: {
+		min: () => m,
+		axisExitDistance: () => v
+	}
+}) && e.f)({}), b = /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (function(e, t) {
+	"use gpu";
+	return g(e.min, e.max, l(t.x > 0, t.y > 0, t.z > 0));
+}), {
+	v: 2,
+	name: "aabbPoint",
+	ast: {
+		params: [{
+			type: "i",
+			name: "aabb"
+		}, {
+			type: "i",
+			name: "corner"
+		}],
+		body: [0, [[10, [
+			6,
+			"select",
+			[
+				[
+					7,
+					"aabb",
+					"min"
+				],
+				[
+					7,
+					"aabb",
+					"max"
+				],
+				[
+					6,
+					"vec3b",
+					[
+						[
+							1,
+							[
+								7,
+								"corner",
+								"x"
+							],
+							">",
+							[5, "0"]
+						],
+						[
+							1,
+							[
+								7,
+								"corner",
+								"y"
+							],
+							">",
+							[5, "0"]
+						],
+						[
+							1,
+							[
+								7,
+								"corner",
+								"z"
+							],
+							">",
+							[5, "0"]
+						]
+					]
+				]
+			]
+		]]]]
+	},
+	externals: {
+		select: () => g,
+		vec3b: () => l
+	}
+}) && e.f)({}), x = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(o({
+	min: u,
+	max: u
+}), "AABB"), S = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(o({
+	direction: u,
+	color: u,
+	intensity: r
+}), "RaymarchDirectionalLight"), C = [S({
+	direction: u(0, -1, 0),
+	color: u(0),
+	intensity: 0
+})];
+function w(t) {
+	if (!Number.isInteger(t) || t < 1) throw RangeError("Lighting capacity must be a positive integer.");
+	return o({
+		ambient: u,
+		directionalLights: e(S, t)
+	});
+}
+function T(e) {
+	let t = e.directionalLights.length > 0 ? e.directionalLights : C, n = w(t.length);
+	return /*#__PURE__*/ ((r) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(r.f = (function() {
+		"use gpu";
+		return n({
+			ambient: e.ambient,
+			directionalLights: t
+		});
+	}), {
+		v: 2,
+		name: "raymarchLighting",
+		ast: {
+			params: [],
+			body: [0, [[10, [
+				6,
+				"RaymarchConstantLighting",
+				[[104, {
+					ambient: "lighting.ambient",
+					directionalLights: "directionalLights"
+				}]]
+			]]]]
+		},
+		externals: {
+			RaymarchConstantLighting: () => n,
+			"lighting.ambient": () => e.ambient,
+			directionalLights: () => t
+		}
+	}) && r.f)({});
+}
+//#endregion
+//#region src/program.ts
+var E = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(o({
+	viewProjectionMatrix: a,
+	position: u
+}), "RaymarchCamera"), D = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(o({
+	isHit: t,
+	position: u,
+	normal: u,
+	rayOrigin: u,
+	rayDirection: u,
+	rayDistance: r,
+	stepCount: s,
+	projectedDepth: r,
+	fragmentCoord: c,
+	instanceIndex: s,
+	bounds: x
+}), "RaymarchResult"), O = "raymarchProgramDefinition";
+function k(e, t, n) {
+	let r = n?.data[O] ?? {
+		version: 0,
+		options: e,
+		create: t
+	};
+	return r.version += 1, r.options = e, r.create = t, n && (n.data[O] = r), r;
+}
+//#endregion
+//#region src/cube-vertices.ts
+var A = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(_.const(e(u, 36), [
+	u(0, 0, 1),
+	u(1, 0, 1),
+	u(1, 1, 1),
+	u(1, 1, 1),
+	u(0, 1, 1),
+	u(0, 0, 1),
+	u(1, 0, 0),
+	u(0, 0, 0),
+	u(0, 1, 0),
+	u(0, 1, 0),
+	u(1, 1, 0),
+	u(1, 0, 0),
+	u(0, 1, 1),
+	u(1, 1, 1),
+	u(1, 1, 0),
+	u(1, 1, 0),
+	u(0, 1, 0),
+	u(0, 1, 1),
+	u(0, 0, 0),
+	u(1, 0, 0),
+	u(1, 0, 1),
+	u(1, 0, 1),
+	u(0, 0, 1),
+	u(0, 0, 0),
+	u(1, 0, 1),
+	u(1, 0, 0),
+	u(1, 1, 0),
+	u(1, 1, 0),
+	u(1, 1, 1),
+	u(1, 0, 1),
+	u(0, 0, 0),
+	u(0, 0, 1),
+	u(0, 1, 1),
+	u(0, 1, 1),
+	u(0, 1, 0),
+	u(0, 0, 0)
+]), "cubeVertices"), j = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(o({
+	isHit: t,
+	pos: u,
+	depth: r,
+	rayDirection: u,
+	rayDistance: r,
+	stepCount: s
+}), "RayHit");
+function M({ sdSurface: e, maxSteps: t, maxDistance: n, epsilon: i, marchBeyondBounds: a }) {
+	return /*#__PURE__*/ ((o) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(o.f = (function(o, c, l, u) {
+		"use gpu";
+		let f = __tsover_sub(c.xyz, o.position), g = p(f), _ = h(f), v = r(0), b = __tsover_add(o.position, __tsover_mul(_, g)), x = s(0), S = y(l, b, _);
+		a ? S = r(n ?? 0) : n !== void 0 && (S = m(S, n));
+		for (let n = 0; n < t && !(v > S); n++) {
+			x = __tsover_add(x, 1), b = __tsover_add(o.position, __tsover_mul(_, __tsover_add(g, v)));
+			let t = e(b, u, l);
+			if (t < i) {
+				let e = __tsover_mul(o.viewProjectionMatrix, d(b, 1));
+				return j({
+					isHit: !0,
+					pos: b,
+					depth: __tsover_div(e.z, e.w),
+					rayDirection: _,
+					rayDistance: __tsover_add(g, v),
+					stepCount: x
+				});
+			}
+			v = __tsover_add(v, t);
+		}
+		return j({
+			isHit: !1,
+			pos: b,
+			depth: 1,
+			rayDirection: _,
+			rayDistance: p(__tsover_sub(b, o.position)),
+			stepCount: x
+		});
+	}), {
+		v: 2,
+		name: "raymarch",
+		ast: {
+			params: [
+				{
+					type: "i",
+					name: "camera"
+				},
+				{
+					type: "i",
+					name: "worldPosition"
+				},
+				{
+					type: "i",
+					name: "aabb"
+				},
+				{
+					type: "i",
+					name: "instanceIndex"
+				}
+			],
+			body: [0, [
+				[
+					13,
+					"triangleDifference",
+					[
+						1,
+						[
+							7,
+							"worldPosition",
+							"xyz"
+						],
+						"-",
+						[
+							7,
+							"camera",
+							"position"
+						]
+					]
+				],
+				[
+					13,
+					"triangleDistance",
+					[
+						6,
+						"length",
+						["triangleDifference"]
+					]
+				],
+				[
+					13,
+					"rayDirection",
+					[
+						6,
+						"normalize",
+						["triangleDifference"]
+					]
+				],
+				[
+					12,
+					"marchedDistance",
+					[
+						6,
+						"f32",
+						[[5, "0"]]
+					]
+				],
+				[
+					12,
+					"point",
+					[
+						1,
+						[
+							7,
+							"camera",
+							"position"
+						],
+						"+",
+						[
+							1,
+							"rayDirection",
+							"*",
+							"triangleDistance"
+						]
+					]
+				],
+				[
+					12,
+					"stepCount",
+					[
+						6,
+						"u32",
+						[[5, "0"]]
+					]
+				],
+				[
+					12,
+					"marchLimit",
+					[
+						6,
+						"aabbExitDistance",
+						[
+							"aabb",
+							"point",
+							"rayDirection"
+						]
+					]
+				],
+				[
+					11,
+					"marchBeyondBounds",
+					[0, [[
+						2,
+						"marchLimit",
+						"=",
+						[
+							6,
+							"f32",
+							[[
+								3,
+								"maxDistance",
+								"??",
+								[5, "0"]
+							]]
+						]
+					]]],
+					[
+						11,
+						[
+							1,
+							"maxDistance",
+							"!==",
+							"undefined"
+						],
+						[0, [[
+							2,
+							"marchLimit",
+							"=",
+							[
+								6,
+								"min",
+								["marchLimit", "maxDistance"]
+							]
+						]]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"stepIndex",
+						[5, "0"]
+					],
+					[
+						1,
+						"stepIndex",
+						"<",
+						"maxSteps"
+					],
+					[
+						102,
+						"++",
+						"stepIndex"
+					],
+					[0, [
+						[
+							11,
+							[
+								1,
+								"marchedDistance",
+								">",
+								"marchLimit"
+							],
+							[17]
+						],
+						[
+							2,
+							"stepCount",
+							"+=",
+							[5, "1"]
+						],
+						[
+							2,
+							"point",
+							"=",
+							[
+								1,
+								[
+									7,
+									"camera",
+									"position"
+								],
+								"+",
+								[
+									1,
+									"rayDirection",
+									"*",
+									[
+										1,
+										"triangleDistance",
+										"+",
+										"marchedDistance"
+									]
+								]
+							]
+						],
+						[
+							13,
+							"distance",
+							[
+								6,
+								"sdSurface",
+								[
+									"point",
+									"instanceIndex",
+									"aabb"
+								]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"distance",
+								"<",
+								"epsilon"
+							],
+							[0, [[
+								13,
+								"hitClipPosition",
+								[
+									1,
+									[
+										7,
+										"camera",
+										"viewProjectionMatrix"
+									],
+									"*",
+									[
+										6,
+										"vec4f",
+										["point", [5, "1"]]
+									]
+								]
+							], [10, [
+								6,
+								"RayHit",
+								[[104, {
+									isHit: !0,
+									pos: "point",
+									depth: [
+										1,
+										[
+											7,
+											"hitClipPosition",
+											"z"
+										],
+										"/",
+										[
+											7,
+											"hitClipPosition",
+											"w"
+										]
+									],
+									rayDirection: "rayDirection",
+									rayDistance: [
+										1,
+										"triangleDistance",
+										"+",
+										"marchedDistance"
+									],
+									stepCount: "stepCount"
+								}]]
+							]]]]
+						],
+						[
+							2,
+							"marchedDistance",
+							"+=",
+							"distance"
+						]
+					]]
+				],
+				[10, [
+					6,
+					"RayHit",
+					[[104, {
+						isHit: !1,
+						pos: "point",
+						depth: [5, "1"],
+						rayDirection: "rayDirection",
+						rayDistance: [
+							6,
+							"length",
+							[[
+								1,
+								"point",
+								"-",
+								[
+									7,
+									"camera",
+									"position"
+								]
+							]]
+						],
+						stepCount: "stepCount"
+					}]]
+				]]
+			]]
+		},
+		externals: {
+			length: () => p,
+			normalize: () => h,
+			f32: () => r,
+			u32: () => s,
+			aabbExitDistance: () => y,
+			marchBeyondBounds: () => a,
+			maxDistance: () => n,
+			undefined: () => void 0,
+			min: () => m,
+			maxSteps: () => t,
+			sdSurface: () => e,
+			epsilon: () => i,
+			vec4f: () => d,
+			RayHit: () => j
+		}
+	}) && o.f)({});
+}
+function N({ sdSurface: e, epsilonNormal: t }) {
+	return /*#__PURE__*/ ((n) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(n.f = (function(n, r, i) {
+		"use gpu";
+		let a = c(1, -1);
+		return h(__tsover_add(__tsover_mul(a.xyy, e(__tsover_add(n, __tsover_mul(a.xyy, t)), i, r)), __tsover_add(__tsover_mul(a.yyx, e(__tsover_add(n, __tsover_mul(a.yyx, t)), i, r)), __tsover_add(__tsover_mul(a.yxy, e(__tsover_add(n, __tsover_mul(a.yxy, t)), i, r)), __tsover_mul(a.xxx, e(__tsover_add(n, __tsover_mul(a.xxx, t)), i, r))))));
+	}), {
+		v: 2,
+		name: "calculateNormal",
+		ast: {
+			params: [
+				{
+					type: "i",
+					name: "point"
+				},
+				{
+					type: "i",
+					name: "aabb"
+				},
+				{
+					type: "i",
+					name: "instanceIndex"
+				}
+			],
+			body: [0, [[
+				13,
+				"k",
+				[
+					6,
+					"vec2f",
+					[[5, "1"], [
+						4,
+						"-",
+						[5, "1"]
+					]]
+				]
+			], [10, [
+				6,
+				"normalize",
+				[[
+					1,
+					[
+						1,
+						[
+							7,
+							"k",
+							"xyy"
+						],
+						"*",
+						[
+							6,
+							"sdSurface",
+							[
+								[
+									1,
+									"point",
+									"+",
+									[
+										1,
+										[
+											7,
+											"k",
+											"xyy"
+										],
+										"*",
+										"epsilonNormal"
+									]
+								],
+								"instanceIndex",
+								"aabb"
+							]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"k",
+								"yyx"
+							],
+							"*",
+							[
+								6,
+								"sdSurface",
+								[
+									[
+										1,
+										"point",
+										"+",
+										[
+											1,
+											[
+												7,
+												"k",
+												"yyx"
+											],
+											"*",
+											"epsilonNormal"
+										]
+									],
+									"instanceIndex",
+									"aabb"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"k",
+									"yxy"
+								],
+								"*",
+								[
+									6,
+									"sdSurface",
+									[
+										[
+											1,
+											"point",
+											"+",
+											[
+												1,
+												[
+													7,
+													"k",
+													"yxy"
+												],
+												"*",
+												"epsilonNormal"
+											]
+										],
+										"instanceIndex",
+										"aabb"
+									]
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"k",
+									"xxx"
+								],
+								"*",
+								[
+									6,
+									"sdSurface",
+									[
+										[
+											1,
+											"point",
+											"+",
+											[
+												1,
+												[
+													7,
+													"k",
+													"xxx"
+												],
+												"*",
+												"epsilonNormal"
+											]
+										],
+										"instanceIndex",
+										"aabb"
+									]
+								]
+							]
+						]
+					]
+				]]
+			]]]]
+		},
+		externals: {
+			vec2f: () => c,
+			normalize: () => h,
+			sdSurface: () => e,
+			epsilonNormal: () => t
+		}
+	}) && n.f)({});
+}
+function P({ root: e, options: t, camera: r, appearance: a, surface: o, preparePipeline: c = (e) => e, renderTarget: l }) {
+	let p = o.isRayVisible ?? /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (() => {
+		"use gpu";
+		return !0;
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			params: [],
+			body: [0, [[10, !0]]]
+		},
+		externals: {}
+	}) && e.f)({}), m = N({
+		sdSurface: o.sd,
+		epsilonNormal: t.epsilonNormal ?? t.epsilon
+	}), h = M({
+		sdSurface: o.sd,
+		epsilon: t.epsilon,
+		maxSteps: t.maxSteps ?? 100,
+		maxDistance: t.maxDistance,
+		marchBeyondBounds: t.marchBeyondBounds ?? !1
+	}), g = c(e.createRenderPipeline({
+		multisample: { count: l?.sampleCount },
+		depthStencil: {
+			format: l?.depthStencilFormat ?? "depth24plus",
+			depthWriteEnabled: t.depthWriteEnabled ?? !0,
+			depthCompare: t.depthCompare ?? "less"
+		},
+		primitive: {
+			topology: "triangle-list",
+			cullMode: "back"
+		},
+		targets: { color: {
+			format: l?.colorFormat,
+			blend: {
+				color: {
+					srcFactor: "src-alpha",
+					dstFactor: "one-minus-src-alpha",
+					operation: "add"
+				},
+				alpha: {
+					srcFactor: "one",
+					dstFactor: "one-minus-src-alpha",
+					operation: "add"
+				}
+			}
+		} },
+		vertex: /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(_.vertexFn({
+			in: {
+				vertexIdx: n.vertexIndex,
+				instanceIdx: n.instanceIndex
+			},
+			out: {
+				position: n.position,
+				worldPos: u,
+				instanceIdx: i("flat, either", s)
+			}
+		})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ vertexIdx: e, instanceIdx: t }) => {
+			"use gpu";
+			let n = o.bounds(t), i = A.$[e], a = b(n, i);
+			return {
+				position: __tsover_mul(r().viewProjectionMatrix, d(a, 1)),
+				worldPos: a,
+				instanceIdx: t
+			};
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				params: [{
+					type: "d",
+					props: [{
+						name: "vertexIdx",
+						alias: "vertexIdx"
+					}, {
+						name: "instanceIdx",
+						alias: "instanceIdx"
+					}]
+				}],
+				body: [0, [
+					[
+						13,
+						"aabb",
+						[
+							6,
+							"surface.bounds",
+							["instanceIdx"]
+						]
+					],
+					[
+						13,
+						"localPos",
+						[
+							8,
+							[
+								7,
+								"cubeVertices",
+								"$"
+							],
+							"vertexIdx"
+						]
+					],
+					[
+						13,
+						"worldPos",
+						[
+							6,
+							"aabbPoint",
+							["aabb", "localPos"]
+						]
+					],
+					[
+						13,
+						"position",
+						[
+							1,
+							[
+								7,
+								[
+									6,
+									"camera",
+									[]
+								],
+								"viewProjectionMatrix"
+							],
+							"*",
+							[
+								6,
+								"vec4f",
+								["worldPos", [5, "1"]]
+							]
+						]
+					],
+					[10, [104, {
+						position: "position",
+						worldPos: "worldPos",
+						instanceIdx: "instanceIdx"
+					}]]
+				]]
+			},
+			externals: {
+				"surface.bounds": () => o.bounds,
+				cubeVertices: () => A,
+				aabbPoint: () => b,
+				camera: () => r,
+				vec4f: () => d
+			}
+		}) && e.f)({})), "vertex"),
+		fragment: /*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ $position: e, worldPos: t, instanceIdx: n }) => {
+			"use gpu";
+			let i = o.bounds(n);
+			o.init !== void 0 && o.init(n), p(t.xyz, n, i) || f();
+			let s = r(), c = h(s, t.xyz, i, n), l = __tsover_mul(-1, c.rayDirection);
+			c.isHit && (l = m(c.pos, i, n));
+			let u = a(D({
+				isHit: c.isHit,
+				position: c.pos,
+				normal: l,
+				rayOrigin: s.position,
+				rayDirection: c.rayDirection,
+				rayDistance: c.rayDistance,
+				stepCount: c.stepCount,
+				projectedDepth: c.depth,
+				fragmentCoord: e.xy,
+				instanceIndex: n,
+				bounds: i
+			}));
+			return c.isHit ? {
+				color: d(u, 1),
+				$fragDepth: c.depth
+			} : {
+				color: d(),
+				$fragDepth: 1
+			};
+		}), {
+			v: 2,
+			name: "fragment",
+			ast: {
+				params: [{
+					type: "d",
+					props: [
+						{
+							name: "$position",
+							alias: "$position"
+						},
+						{
+							name: "worldPos",
+							alias: "worldPos"
+						},
+						{
+							name: "instanceIdx",
+							alias: "instanceIdx"
+						}
+					]
+				}],
+				body: [0, [
+					[
+						13,
+						"aabb",
+						[
+							6,
+							"surface.bounds",
+							["instanceIdx"]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"surface.init",
+							"!==",
+							"undefined"
+						],
+						[
+							6,
+							"surface.init",
+							["instanceIdx"]
+						]
+					],
+					[
+						11,
+						[
+							4,
+							"!",
+							[
+								6,
+								"isRayVisible",
+								[
+									[
+										7,
+										"worldPos",
+										"xyz"
+									],
+									"instanceIdx",
+									"aabb"
+								]
+							]
+						],
+						[
+							6,
+							"discard",
+							[]
+						]
+					],
+					[
+						13,
+						"activeCamera",
+						[
+							6,
+							"camera",
+							[]
+						]
+					],
+					[
+						13,
+						"hit",
+						[
+							6,
+							"raymarch",
+							[
+								"activeCamera",
+								[
+									7,
+									"worldPos",
+									"xyz"
+								],
+								"aabb",
+								"instanceIdx"
+							]
+						]
+					],
+					[
+						12,
+						"normal",
+						[
+							1,
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							"*",
+							[
+								7,
+								"hit",
+								"rayDirection"
+							]
+						]
+					],
+					[
+						11,
+						[
+							7,
+							"hit",
+							"isHit"
+						],
+						[0, [[
+							2,
+							"normal",
+							"=",
+							[
+								6,
+								"calculateNormal",
+								[
+									[
+										7,
+										"hit",
+										"pos"
+									],
+									"aabb",
+									"instanceIdx"
+								]
+							]
+						]]]
+					],
+					[
+						13,
+						"color",
+						[
+							6,
+							"appearance",
+							[[
+								6,
+								"RaymarchResult",
+								[[104, {
+									isHit: [
+										7,
+										"hit",
+										"isHit"
+									],
+									position: [
+										7,
+										"hit",
+										"pos"
+									],
+									normal: "normal",
+									rayOrigin: [
+										7,
+										"activeCamera",
+										"position"
+									],
+									rayDirection: [
+										7,
+										"hit",
+										"rayDirection"
+									],
+									rayDistance: [
+										7,
+										"hit",
+										"rayDistance"
+									],
+									stepCount: [
+										7,
+										"hit",
+										"stepCount"
+									],
+									projectedDepth: [
+										7,
+										"hit",
+										"depth"
+									],
+									fragmentCoord: [
+										7,
+										"$position",
+										"xy"
+									],
+									instanceIndex: "instanceIdx",
+									bounds: "aabb"
+								}]]
+							]]
+						]
+					],
+					[
+						11,
+						[
+							7,
+							"hit",
+							"isHit"
+						],
+						[0, [[10, [104, {
+							color: [
+								6,
+								"vec4f",
+								["color", [5, "1"]]
+							],
+							$fragDepth: [
+								7,
+								"hit",
+								"depth"
+							]
+						}]]]]
+					],
+					[10, [104, {
+						color: [
+							6,
+							"vec4f",
+							[]
+						],
+						$fragDepth: [5, "1"]
+					}]]
+				]]
+			},
+			externals: {
+				"surface.bounds": () => o.bounds,
+				"surface.init": () => o.init,
+				undefined: () => void 0,
+				isRayVisible: () => p,
+				discard: () => f,
+				camera: () => r,
+				raymarch: () => h,
+				calculateNormal: () => m,
+				appearance: () => a,
+				RaymarchResult: () => D,
+				vec4f: () => d
+			}
+		}) && e.f)({})
+	}));
+	return function({ colorAttachment: e, depthStencilAttachment: t, instances: n = 1 }) {
+		g.withColorAttachment({ color: e }).withDepthStencilAttachment(t).draw(A.$.length, n);
+	};
+}
+function F({ root: e, program: t, context: n = void 0, renderTarget: r, prepare: i = (e) => e, preparePipeline: a }) {
+	function o() {
+		let { camera: o, surface: s, appearance: c } = i(t.create(n));
+		return P({
+			root: e,
+			options: t.options,
+			surface: s,
+			camera: o,
+			appearance: c,
+			preparePipeline: a,
+			renderTarget: r
+		});
+	}
+	let s = t.version, c = o();
+	return function(e) {
+		s !== t.version && (c = o(), s = t.version), c(e);
+	};
+}
+//#endregion
+export { x as AABB, E as RaymarchCamera, S as RaymarchDirectionalLight, D as RaymarchResult, T as createRaymarchConstantLighting, k as createRaymarchProgram, F as createRaymarchRenderer };
+
+//# sourceMappingURL=index.js.map