luxscura 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Wayne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# Luxscura
+
+## A TypeGPU Raymarching Renderer
+
+Luxscura is currently in early development. Its package structure and public API
+may change.
+
+## TypeGPU setup
+
+Luxscura is build on top of TypeGPU. You will want to set it up in your project as well as the the build plugin so your shaders can get compiled from TypeScript.
+
+- https://docs.swmansion.com/TypeGPU/getting-started/
+- https://docs.swmansion.com/TypeGPU/tooling/unplugin-typegpu/
+
+## Usage
+
+1. Create a raymarching program:
+
+```ts
+import { createRaymarchProgram } from 'luxscura'
+
+// This is a camera position and view projection matrix
+const camera = createCamera() 
+
+const program = createRaymarchProgram({ epsilon: 0.001 }, () => {
+	return {
+		camera: () => {
+			'use gpu'
+			return RaymarchCamera({
+				position: camera.cameraPosition,
+				viewProjectionMatrix: camera.viewProjectionMatrix,
+			})
+		},
+
+		surface: {
+			bounds: () => {
+				'use gpu'
+				return AABB({ min: vec3f(-1), max: vec3f(1) })
+			},
+			sd: (point) => {
+				'use gpu'
+				return sdSphere(point, 1)
+			},
+		},
+
+		appearance: createMatteAppearance({
+			color: () => {
+				'use gpu'
+				return vec3f(0.15, 0.5, 0.85)
+			},
+			lighting: createRaymarchConstantLighting({
+				ambient: vec3f(0.2, 0.05, 0.05),
+				directionalLights: [
+					{
+						direction: vec3f(-1, 1, -1),
+						color: vec3f(1, 0.9, 0.75),
+						intensity: 1,
+					},
+				],
+			}),
+		}),
+	}
+})
+```
+
+2. And then create a renderer
+
+```ts
+import { createRaymarchRenderer } from 'luxscura'
+
+const canvas = document.getElementById('canvas') as HTMLCanvasElement
+const root = await tgpu.init()
+const canvasContext = root.configureContext({ canvas })
+
+// A depth buffer is currently required
+const depthTexture = root
+	.createTexture({
+		size: [canvas.width, canvas.height],
+		format: 'depth24plus',
+	})
+	.$usage('render')
+
+// This function renders the scene
+const render = createRaymarchRenderer({ root, program })
+
+// Render loop
+function renderFrame() {
+	render({
+		colorAttachment: { view: canvasContext },
+		depthStencilAttachment: { view: depthTexture },
+	})
+	requestAnimationFrame(renderFrame)
+}
+requestAnimationFrame(renderFrame)
+```
+
+## More documentation coming soon
+
+See [the examples on the website](https://alexjwayne.github.io/luxscura/).

package/dist/aabb.d.ts

@@ -0,0 +1,9 @@
+import { type Infer, type v3f } from 'typegpu/data';
+export declare const AABB: import("typegpu/data").WgslStruct<{
+    min: import("typegpu/data").Vec3f;
+    max: import("typegpu/data").Vec3f;
+}>;
+export type AABB = Infer<typeof AABB>;
+export declare function aabbPoint(aabb: AABB, corner: v3f): v3f;
+export declare function aabbCenter(aabb: AABB): v3f;
+export declare function aabbExitDistance(aabb: AABB, point: v3f, direction: v3f): number;

package/dist/appearances/glossy/appearance.d.ts

@@ -0,0 +1,16 @@
+import type { RaymarchLighting } from '../../lighting';
+import type { RaymarchAppearance, RaymarchResult } from '../../program';
+import type { GlossyMaterial } from './material';
+/** GPU function sampling a glossy material from the raymarch result. */
+export type GlossyMaterialSampler = (result: RaymarchResult) => GlossyMaterial;
+/**
+ * Creates a glossy appearance using diffuse lighting and Blinn-Phong highlights.
+ * Ambient fill affects the diffuse color; emission is added independently.
+ *
+ * Material sampling runs for hits and misses so derivatives remain available.
+ * Lighting runs only for hits. Colors and lighting values are linear RGB.
+ */
+export declare function createGlossyAppearance({ material, lighting, }: {
+    material: GlossyMaterialSampler;
+    lighting: () => RaymarchLighting;
+}): RaymarchAppearance;

package/dist/appearances/glossy/index.d.ts

@@ -0,0 +1,2 @@
+export { createGlossyAppearance, type GlossyMaterialSampler, } from './appearance';
+export { GlossyMaterial } from './material';

package/dist/appearances/glossy/material.d.ts

@@ -0,0 +1,20 @@
+import { type Infer } from 'typegpu/data';
+/**
+ * GPU material schema for an opaque surface with adjustable shiny highlights.
+ * Colors are linear RGB. Callers must supply finite values within the documented
+ * ranges; constructing this struct does not clamp or validate material values.
+ */
+export declare const GlossyMaterial: import("typegpu/data").WgslStruct<{
+    /** Diffuse surface color. Each channel is in [0, 1]. */
+    baseColor: import("typegpu/data").Vec3f;
+    /** Highlight color and strength. Each channel is in [0, 1]; black disables highlights. */
+    specular: import("typegpu/data").Vec3f;
+    /**
+     * Highlight tightness: lower values produce broad highlights, higher values
+     * small ones. Use values of at least 1; shading applies an internal floor of 1.
+     */
+    shininess: import("typegpu/data").F32;
+    /** Nonnegative outgoing linear RGB added independently of illumination; may exceed 1. */
+    emission: import("typegpu/data").Vec3f;
+}>;
+export type GlossyMaterial = Infer<typeof GlossyMaterial>;

package/dist/appearances/matte.d.ts

@@ -0,0 +1,16 @@
+import { type v3f } from 'typegpu/data';
+import type { RaymarchLighting } from '../lighting';
+import type { RaymarchAppearance, RaymarchResult } from '../program';
+/** GPU function sampling a surface's linear RGB color from the raymarch result. */
+export type MatteColorSampler = (result: RaymarchResult) => v3f;
+/**
+ * Creates a matte appearance using ambient fill and Lambert diffuse lighting.
+ * Surfaces facing a light receive its full contribution, with no shiny highlights.
+ *
+ * Color sampling runs for hits and misses so derivatives remain available.
+ * Lighting runs only for hits. Colors and lighting values are linear RGB.
+ */
+export declare function createMatteAppearance({ color, lighting, }: {
+    color: MatteColorSampler;
+    lighting: () => RaymarchLighting;
+}): RaymarchAppearance;

package/dist/appearances/pbr/appearance.d.ts

@@ -0,0 +1,42 @@
+import { type Infer, type v3f } from 'typegpu/data';
+import type { RaymarchLighting } from '../../lighting';
+import type { RaymarchAppearance, RaymarchResult } from '../../program';
+import { PbrMaterial } from './material';
+/** Position, normal, and PBR material consumed by the lighting calculation. */
+export declare const PbrSurfaceSample: import("typegpu/data").WgslStruct<{
+    position: import("typegpu/data").Vec3f;
+    normal: import("typegpu/data").Vec3f;
+    material: import("typegpu/data").WgslStruct<{
+        baseColor: import("typegpu/data").Vec3f;
+        metallic: import("typegpu/data").F32;
+        roughness: import("typegpu/data").F32;
+        emission: import("typegpu/data").Vec3f;
+    }>;
+}>;
+export type PbrSurfaceSample = Infer<typeof PbrSurfaceSample>;
+/**
+ * Creates a GPU surface shader combining direct lighting, material emission,
+ * and environment reflections.
+ */
+export declare function createPbrShadeSurface({ lighting, environment, }: {
+    lighting: () => RaymarchLighting;
+    environment: (direction: v3f, roughness: number) => v3f;
+}): (cameraPosition: v3f, sample: PbrSurfaceSample) => v3f;
+/** GPU function sampling a PBR material from the raymarch result. */
+export type PbrMaterialSampler = (result: RaymarchResult) => PbrMaterial;
+/**
+ * Creates a metallic/roughness appearance for a raymarch program.
+ *
+ * Material sampling runs for hits and misses so derivatives remain available.
+ * Lighting runs only for hits. The returned color on a miss is ignored by the
+ * renderer.
+ */
+export declare function createPbrAppearance({ material, lighting, environment, }: {
+    material: PbrMaterialSampler;
+    lighting: () => RaymarchLighting;
+    /**
+     * Incoming linear RGB from a normalized reflection direction. Called only on
+     * hits; texture sampling here should use an explicit level of detail.
+     */
+    environment: (direction: v3f, roughness: number) => v3f;
+}): RaymarchAppearance;

package/dist/appearances/pbr/index.d.ts

@@ -0,0 +1,2 @@
+export { createPbrAppearance, type PbrMaterialSampler } from './appearance';
+export { mixPbrMaterials, PbrMaterial } from './material';

package/dist/appearances/pbr/material.d.ts

@@ -0,0 +1,27 @@
+import { type Infer } from 'typegpu/data';
+/**
+ * GPU material schema for an opaque surface using metallic/roughness shading.
+ * Colors are linear RGB. Callers must supply finite values within the documented
+ * ranges; constructing this struct does not clamp or validate material values.
+ */
+export declare const PbrMaterial: import("typegpu/data").WgslStruct<{
+    /** Diffuse color for nonmetals, specular reflection color for metals. Each channel is in [0, 1]. */
+    baseColor: import("typegpu/data").Vec3f;
+    /** Nonmetal at 0, metal at 1; intermediate values blend the responses. Not a shininess control. */
+    metallic: import("typegpu/data").F32;
+    /**
+     * Surface roughness in [0, 1]: 0 produces sharp direct highlights, 1 broad ones.
+     * Direct shading applies a small internal floor at the smooth end for stability.
+     * Passed to the environment callback; the consumer owns reflection filtering.
+     */
+    roughness: import("typegpu/data").F32;
+    /**
+     * Nonnegative outgoing linear RGB added independently of illumination; may exceed 1.
+     * Does not illuminate other surfaces or disable this material's reflections.
+     */
+    emission: import("typegpu/data").Vec3f;
+}>;
+export type PbrMaterial = Infer<typeof PbrMaterial>;
+/** Debug material for visualizing a normalized float That varies over the surface. */
+export declare function debugPbrMaterial(luminance: number): PbrMaterial;
+export declare function mixPbrMaterials(a: PbrMaterial, b: PbrMaterial, amount: number): PbrMaterial;

package/dist/cube-vertices.d.ts

@@ -0,0 +1 @@
+export declare const cubeVertices: import("typegpu").TgpuConst<import("typegpu/data").WgslArray<import("typegpu/data").Vec3f>>;

package/dist/glossy.js

@@ -0,0 +1,336 @@
+import { f32 as e, struct as t, vec3f as n } from "typegpu/data";
+import { dot as r, max as i, normalize as a, pow as o, saturate as s } from "typegpu/std";
+//#region src/appearances/glossy/appearance.ts
+function c({ material: e, lighting: t }) {
+	return /*#__PURE__*/ ((c) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(c.f = (function(c) {
+		"use gpu";
+		let l = e(c);
+		if (!c.isHit) return n(0);
+		let u = t(), d = __tsover_add(__tsover_mul(l.baseColor, u.ambient), l.emission), f = __tsover_mul(-1, c.rayDirection), p = r(c.normal, f) > 0, m = i(l.shininess, 1);
+		for (let e of u.directionalLights) {
+			if (e.intensity === 0) continue;
+			let t = __tsover_mul(-1, a(e.direction)), n = s(r(c.normal, t));
+			if (n === 0) continue;
+			let i = __tsover_mul(l.baseColor, n);
+			if (p) {
+				let e = a(__tsover_add(f, t)), n = o(s(r(c.normal, e)), m);
+				i = __tsover_add(i, __tsover_mul(l.specular, n));
+			}
+			d = __tsover_add(d, __tsover_mul(__tsover_mul(e.color, e.intensity), i));
+		}
+		return d;
+	}), {
+		v: 2,
+		name: "glossyAppearance",
+		ast: {
+			params: [{
+				type: "i",
+				name: "result"
+			}],
+			body: [0, [
+				[
+					13,
+					"materialSample",
+					[
+						6,
+						"material",
+						["result"]
+					]
+				],
+				[
+					11,
+					[
+						4,
+						"!",
+						[
+							7,
+							"result",
+							"isHit"
+						]
+					],
+					[10, [
+						6,
+						"vec3f",
+						[[5, "0"]]
+					]]
+				],
+				[
+					13,
+					"lights",
+					[
+						6,
+						"lighting",
+						[]
+					]
+				],
+				[
+					12,
+					"color",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"materialSample",
+								"baseColor"
+							],
+							"*",
+							[
+								7,
+								"lights",
+								"ambient"
+							]
+						],
+						"+",
+						[
+							7,
+							"materialSample",
+							"emission"
+						]
+					]
+				],
+				[
+					13,
+					"viewDirection",
+					[
+						1,
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						"*",
+						[
+							7,
+							"result",
+							"rayDirection"
+						]
+					]
+				],
+				[
+					13,
+					"facingCamera",
+					[
+						1,
+						[
+							6,
+							"dot",
+							[[
+								7,
+								"result",
+								"normal"
+							], "viewDirection"]
+						],
+						">",
+						[5, "0"]
+					]
+				],
+				[
+					13,
+					"shininess",
+					[
+						6,
+						"max",
+						[[
+							7,
+							"materialSample",
+							"shininess"
+						], [5, "1"]]
+					]
+				],
+				[
+					18,
+					[13, "light"],
+					[
+						7,
+						"lights",
+						"directionalLights"
+					],
+					[0, [
+						[
+							11,
+							[
+								1,
+								[
+									7,
+									"light",
+									"intensity"
+								],
+								"===",
+								[5, "0"]
+							],
+							[16]
+						],
+						[
+							13,
+							"lightDirection",
+							[
+								1,
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								"*",
+								[
+									6,
+									"normalize",
+									[[
+										7,
+										"light",
+										"direction"
+									]]
+								]
+							]
+						],
+						[
+							13,
+							"diffuse",
+							[
+								6,
+								"saturate",
+								[[
+									6,
+									"dot",
+									[[
+										7,
+										"result",
+										"normal"
+									], "lightDirection"]
+								]]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"diffuse",
+								"===",
+								[5, "0"]
+							],
+							[16]
+						],
+						[
+							12,
+							"response",
+							[
+								1,
+								[
+									7,
+									"materialSample",
+									"baseColor"
+								],
+								"*",
+								"diffuse"
+							]
+						],
+						[
+							11,
+							"facingCamera",
+							[0, [
+								[
+									13,
+									"halfwayDirection",
+									[
+										6,
+										"normalize",
+										[[
+											1,
+											"viewDirection",
+											"+",
+											"lightDirection"
+										]]
+									]
+								],
+								[
+									13,
+									"highlight",
+									[
+										6,
+										"pow",
+										[[
+											6,
+											"saturate",
+											[[
+												6,
+												"dot",
+												[[
+													7,
+													"result",
+													"normal"
+												], "halfwayDirection"]
+											]]
+										], "shininess"]
+									]
+								],
+								[
+									2,
+									"response",
+									"+=",
+									[
+										1,
+										[
+											7,
+											"materialSample",
+											"specular"
+										],
+										"*",
+										"highlight"
+									]
+								]
+							]]
+						],
+						[
+							2,
+							"color",
+							"+=",
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"light",
+										"color"
+									],
+									"*",
+									[
+										7,
+										"light",
+										"intensity"
+									]
+								],
+								"*",
+								"response"
+							]
+						]
+					]]
+				],
+				[10, "color"]
+			]]
+		},
+		externals: {
+			material: () => e,
+			vec3f: () => n,
+			lighting: () => t,
+			dot: () => r,
+			max: () => i,
+			normalize: () => a,
+			saturate: () => s,
+			pow: () => o
+		}
+	}) && c.f)({});
+}
+//#endregion
+//#region src/appearances/glossy/material.ts
+var l = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t({
+	baseColor: n,
+	specular: n,
+	shininess: e,
+	emission: n
+}), "GlossyMaterial");
+//#endregion
+export { l as GlossyMaterial, c as createGlossyAppearance };
+
+//# sourceMappingURL=glossy.js.map

package/dist/glossy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossy.js","names":[],"sources":["../src/appearances/glossy/appearance.ts","../src/appearances/glossy/material.ts"],"sourcesContent":["import { type v3f, vec3f } from 'typegpu/data'\nimport { dot, max, normalize, pow, saturate } from 'typegpu/std'\nimport type { RaymarchLighting } from '../../lighting'\nimport type { RaymarchAppearance, RaymarchResult } from '../../program'\nimport type { GlossyMaterial } from './material'\n\n/** GPU function sampling a glossy material from the raymarch result. */\nexport type GlossyMaterialSampler = (result: RaymarchResult) => GlossyMaterial\n\n/**\n * Creates a glossy appearance using diffuse lighting and Blinn-Phong highlights.\n * Ambient fill affects the diffuse color; emission is added independently.\n *\n * Material sampling runs for hits and misses so derivatives remain available.\n * Lighting runs only for hits. Colors and lighting values are linear RGB.\n */\nexport function createGlossyAppearance({\n\tmaterial,\n\tlighting,\n}: {\n\tmaterial: GlossyMaterialSampler\n\tlighting: () => RaymarchLighting\n}): RaymarchAppearance {\n\treturn function glossyAppearance(result: RaymarchResult): v3f {\n\t\t'use gpu'\n\t\tconst materialSample = material(result)\n\t\tif (!result.isHit) return vec3f(0)\n\n\t\tconst lights = lighting()\n\t\tlet color =\n\t\t\tmaterialSample.baseColor * lights.ambient + materialSample.emission\n\t\tconst viewDirection = -1 * result.rayDirection\n\t\tconst facingCamera = dot(result.normal, viewDirection) > 0\n\t\tconst shininess = max(materialSample.shininess, 1)\n\n\t\tfor (const light of lights.directionalLights) {\n\t\t\tif (light.intensity === 0) continue\n\n\t\t\tconst lightDirection = -1 * normalize(light.direction)\n\t\t\tconst diffuse = saturate(dot(result.normal, lightDirection))\n\t\t\tif (diffuse === 0) continue\n\n\t\t\tlet response = materialSample.baseColor * diffuse\n\t\t\tif (facingCamera) {\n\t\t\t\tconst halfwayDirection = normalize(viewDirection + lightDirection)\n\t\t\t\tconst highlight = pow(\n\t\t\t\t\tsaturate(dot(result.normal, halfwayDirection)),\n\t\t\t\t\tshininess,\n\t\t\t\t)\n\t\t\t\tresponse += materialSample.specular * highlight\n\t\t\t}\n\n\t\t\tcolor += light.color * light.intensity * response\n\t\t}\n\n\t\treturn color\n\t}\n}\n","import { f32, type Infer, struct, vec3f } from 'typegpu/data'\n\n/**\n * GPU material schema for an opaque surface with adjustable shiny highlights.\n * Colors are linear RGB. Callers must supply finite values within the documented\n * ranges; constructing this struct does not clamp or validate material values.\n */\nexport const GlossyMaterial = struct({\n\t/** Diffuse surface color. Each channel is in [0, 1]. */\n\tbaseColor: vec3f,\n\n\t/** Highlight color and strength. Each channel is in [0, 1]; black disables highlights. */\n\tspecular: vec3f,\n\n\t/**\n\t * Highlight tightness: lower values produce broad highlights, higher values\n\t * small ones. Use values of at least 1; shading applies an internal floor of 1.\n\t */\n\tshininess: f32,\n\n\t/** Nonnegative outgoing linear RGB added independently of illumination; may exceed 1. */\n\temission: vec3f,\n})\nexport type GlossyMaterial = Infer<typeof GlossyMaterial>\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { AABB } from './aabb';
+export { createRaymarchConstantLighting, RaymarchDirectionalLight, type RaymarchLighting, } from './lighting';
+export { createRaymarchProgram, type RaymarchAppearance, type RaymarchBoundsProvider, RaymarchCamera, type RaymarchDistanceFunction, type RaymarchInitializer, type RaymarchProgram, type RaymarchProgramDefinition, type RaymarchProgramOptions, RaymarchResult, type RaymarchSurface, type RaymarchVisibilityTest, } from './program';
+export { createRaymarchRenderer, type RaymarchRenderOptions, type RaymarchRenderTargetOptions, } from './renderer';