@tinypoly/gpu-renderer 0.0.0-stage → 0.0.1

package/dist/canvas.d.ts

@@ -0,0 +1,9 @@
+import type { GpuRenderer } from "./renderer.js";
+/**
+ * Sends the renderer's output to a canvas. It configures the WebGPU context, sizes the canvas to the render
+ * resolution and presents after every submit, so the image refines in place while it converges.
+ *
+ * Returns the function that detaches it.
+ */
+export declare function attachCanvas(renderer: GpuRenderer, canvas: HTMLCanvasElement): () => void;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../src/canvas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAIzF"}

package/dist/canvas.js

@@ -0,0 +1,11 @@
+/**
+ * Sends the renderer's output to a canvas. It configures the WebGPU context, sizes the canvas to the render
+ * resolution and presents after every submit, so the image refines in place while it converges.
+ *
+ * Returns the function that detaches it.
+ */
+export function attachCanvas(renderer, canvas) {
+    renderer.setOutputCanvas(canvas);
+    return () => renderer.setOutputCanvas(null);
+}
+//# sourceMappingURL=canvas.js.map

package/dist/canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../src/canvas.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,QAAqB,EAAE,MAAyB;IAC3E,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAEjC,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC"}

package/dist/denoise.d.ts

@@ -0,0 +1,69 @@
+/** How the denoiser filters. Every field is optional where it is taken, and falls back to `DEFAULT_DENOISER`. */
+export interface DenoiserSettings {
+    /** How much of the filtered image replaces the traced one, from 0 (none) to 1. */
+    strength: number;
+    /** Wavelet passes, 1 to 5: how far the filter reaches, from 2 to 62 pixels. */
+    passes: number;
+    /**
+     * How large a luminance difference between two pixels still counts as noise, in standard deviations of the pixel's
+     * own noise. Lower keeps more detail and removes less noise.
+     */
+    edge: number;
+    /** Leave the pixels that have converged as they were traced, and filter only where noise is still visible. */
+    onlyNoisy: boolean;
+    /** Clamp a pixel brighter than every one of its neighbours to the brightest of them, before filtering. */
+    antiFirefly: boolean;
+}
+export declare const DEFAULT_DENOISER: Readonly<DenoiserSettings>;
+/** The settings with `input` applied, each field kept in range. */
+export declare function mergeDenoiser(base: DenoiserSettings, input?: Partial<DenoiserSettings>): DenoiserSettings;
+/** The error a pixel counts as converged under, the one adaptive sampling stops at. */
+export declare const CONVERGED_ERROR = 0.004;
+/** What the camera says about how large things look, which the specular filter's radius depends on. */
+export interface DenoiseView {
+    /** World units one pixel spans at unit distance (perspective) or anywhere (orthographic). */
+    pixelScale: number;
+    orthographic: boolean;
+}
+/**
+ * The denoiser: the spatial half of SVGF (Schied and others, 2017), with the diffuse and the specular light filtered
+ * apart, as NVIDIA's RELAX and REBLUR do.
+ *
+ * The path tracer splits every path at its first scatter, by the lobe it took, so each pixel holds a diffuse and a
+ * specular signal, each with its own variance. Each is divided by its own albedo (the diffuse colour, and the GGX
+ * lobe's directional albedo), so the filter sees light and never blurs a texture or a colour; both are multiplied back
+ * at the end. A pixel brighter than all of its neighbours is first clamped to the brightest of them.
+ *
+ * Then a few passes of an edge-avoiding a-trous wavelet, its taps twice as far apart each pass. The diffuse light is
+ * weighed by the agreement of normals and depths and by its luminance against the pixel's own variance. The specular
+ * light also by roughness, by normals more sharply the smoother the surface, and within the footprint its lobe leaves on
+ * the screen: the lobe's angle times the distance to what it reflects, seen from the camera. A sharp reflection of
+ * something near is left almost alone; a rough reflection of something far is smoothed across a wide area.
+ *
+ * The weights are normalized, which keeps every flat area at exactly its mean, and each signal is mixed with what was
+ * traced by how noisy it still is, so what has converged keeps exactly its traced value.
+ */
+export declare const DENOISE_WGSL = "\nstruct Params {\n  size: vec2<u32>,\n  step: u32,\n  count: u32,\n  edge: f32,\n  strength: f32,\n  onlyNoisy: u32,\n  converged: f32,\n  pixelScale: f32,\n  orthographic: u32,\n  padding: vec2<u32>,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> diffuseIn: array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read> specularIn: array<vec4<f32>>;\n@group(0) @binding(4) var<storage, read_write> diffuseOut: array<vec4<f32>>;\n@group(0) @binding(5) var<storage, read_write> specularOut: array<vec4<f32>>;\n\nfn luminance(color: vec3<f32>) -> f32 {\n  return dot(color, vec3<f32>(0.2126, 0.7152, 0.0722));\n}\n\nfn samples(index: u32) -> f32 {\n  return max(accumulation[index].w, 1.0);\n}\n\n/** Each signal's mean radiance: the diffuse one stored apart, the specular one the rest. */\nfn diffuseMean(index: u32) -> vec3<f32> {\n  return accumulation[4u * params.count + index].rgb / samples(index);\n}\n\nfn specularMean(index: u32) -> vec3<f32> {\n  return accumulation[index].rgb / samples(index) - diffuseMean(index);\n}\n\n/** The albedos the light is divided by, kept off zero so the division never explodes. */\nfn diffuseAlbedo(index: u32) -> vec3<f32> {\n  return max(accumulation[2u * params.count + index].rgb / samples(index), vec3<f32>(0.01));\n}\n\nfn specularAlbedo(index: u32) -> vec3<f32> {\n  return max(accumulation[5u * params.count + index].rgb / samples(index), vec3<f32>(0.01));\n}\n\nfn guideNormal(index: u32) -> vec3<f32> {\n  let sum = accumulation[3u * params.count + index].xyz;\n  let size = length(sum);\n\n  return select(vec3<f32>(0.0), sum / size, size > 1e-6);\n}\n\nfn guideDepth(index: u32) -> f32 {\n  return accumulation[3u * params.count + index].w / samples(index);\n}\n\nfn guideRoughness(index: u32) -> f32 {\n  return accumulation[2u * params.count + index].w / samples(index);\n}\n\nfn specularDistance(index: u32) -> f32 {\n  return accumulation[4u * params.count + index].w / samples(index);\n}\n\n/** The variance of a signal's mean, in the space of its demodulated light. */\nfn variance(mean: vec3<f32>, square: f32, count: f32, albedo: vec3<f32>) -> f32 {\n  let m = luminance(mean);\n  let a = max(luminance(albedo), 0.01);\n\n  return max(square / count - m * m, 0.0) / count / (a * a);\n}\n\n/** Both signals, divided by their albedos, with the variance of their means. */\n@compute @workgroup_size(8, 8, 1)\nfn prepare(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= params.size.x || id.y >= params.size.y) {\n    return;\n  }\n\n  let index = id.y * params.size.x + id.x;\n  let count = accumulation[index].w;\n\n  if (count <= 0.0) {\n    diffuseOut[index] = vec4<f32>(0.0);\n    specularOut[index] = vec4<f32>(0.0);\n\n    return;\n  }\n\n  let squares = accumulation[params.count + index];\n  let diffuse = diffuseMean(index);\n  let specular = specularMean(index);\n\n  diffuseOut[index] = vec4<f32>(diffuse / diffuseAlbedo(index), variance(diffuse, squares.z, count, diffuseAlbedo(index)));\n  specularOut[index] = vec4<f32>(\n    specular / specularAlbedo(index), variance(specular, squares.w, count, specularAlbedo(index)));\n}\n\nfn inside(q: vec2<i32>) -> bool {\n  return q.x >= 0 && q.y >= 0 && q.x < i32(params.size.x) && q.y < i32(params.size.y);\n}\n\n/** A value brighter than every neighbour, scaled down to the brightest of them: a firefly, not a feature. */\nfn clampFirefly(value: vec4<f32>, brightest: f32) -> vec4<f32> {\n  let own = luminance(value.rgb);\n\n  if (own <= brightest || own <= 0.0) {\n    return value;\n  }\n\n  return vec4<f32>(value.rgb * (brightest / own), value.w);\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn antiFirefly(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= params.size.x || id.y >= params.size.y) {\n    return;\n  }\n\n  let pixel = vec2<i32>(id.xy);\n  let index = id.y * params.size.x + id.x;\n  var diffuse = 0.0;\n  var specular = 0.0;\n\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let q = pixel + vec2<i32>(dx, dy);\n\n      if ((dx == 0 && dy == 0) || !inside(q)) {\n        continue;\n      }\n\n      let other = u32(q.y) * params.size.x + u32(q.x);\n      diffuse = max(diffuse, luminance(diffuseIn[other].rgb));\n      specular = max(specular, luminance(specularIn[other].rgb));\n    }\n  }\n\n  diffuseOut[index] = clampFirefly(diffuseIn[index], diffuse);\n  specularOut[index] = clampFirefly(specularIn[index], specular);\n}\n\nconst KERNEL = array<f32, 5>(0.0625, 0.25, 0.375, 0.25, 0.0625);\n\n/** The variance around a pixel, blurred over 3 x 3, which steadies the luminance test on a few samples. */\nfn localVariance(pixel: vec2<i32>, specular: bool) -> f32 {\n  var sum = 0.0;\n  var weight = 0.0;\n\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let q = pixel + vec2<i32>(dx, dy);\n\n      if (!inside(q)) {\n        continue;\n      }\n\n      let other = u32(q.y) * params.size.x + u32(q.x);\n      let w = select(0.5, 1.0, dx == 0) * select(0.5, 1.0, dy == 0);\n      sum = sum + select(diffuseIn[other].w, specularIn[other].w, specular) * w;\n      weight = weight + w;\n    }\n  }\n\n  return sum / max(weight, 1e-6);\n}\n\n/**\n * How many pixels the specular lobe's footprint covers: the lobe's angle times the distance to what it reflects, seen\n * from the camera across the distance to the surface plus that.\n */\nfn specularRadius(index: u32, depth: f32) -> f32 {\n  let alpha = guideRoughness(index) * guideRoughness(index);\n  let reflected = specularDistance(index);\n\n  if (params.orthographic != 0u) {\n    return min(alpha * reflected / params.pixelScale, 64.0);\n  }\n\n  return min(alpha * reflected / max(depth + reflected, 1e-6) / params.pixelScale, 64.0);\n}\n\n/** One a-trous pass over both signals, its taps params.step pixels apart. */\n@compute @workgroup_size(8, 8, 1)\nfn atrous(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= params.size.x || id.y >= params.size.y) {\n    return;\n  }\n\n  let pixel = vec2<i32>(id.xy);\n  let index = id.y * params.size.x + id.x;\n  let diffuseCenter = diffuseIn[index];\n  let specularCenter = specularIn[index];\n\n  if (accumulation[index].w <= 0.0) {\n    diffuseOut[index] = diffuseCenter;\n    specularOut[index] = specularCenter;\n\n    return;\n  }\n\n  let normal = guideNormal(index);\n  let depth = guideDepth(index);\n  let roughness = guideRoughness(index);\n  let diffuseSigma = params.edge * sqrt(max(localVariance(pixel, false), 0.0)) + 1e-6;\n  let specularSigma = params.edge * sqrt(max(localVariance(pixel, true), 0.0)) + 1e-6;\n  let radius = specularRadius(index, depth);\n  // A smoother surface's reflection turns faster with its normal: the normal test sharpens with it.\n  let specularPower = min(128.0 / max(roughness * roughness, 0.03), 4096.0);\n  let step = i32(params.step);\n  var diffuse = vec4<f32>(0.0);\n  var specular = vec4<f32>(0.0);\n  var diffuseTotal = 0.0;\n  var specularTotal = 0.0;\n\n  for (var dy = -2; dy <= 2; dy = dy + 1) {\n    for (var dx = -2; dx <= 2; dx = dx + 1) {\n      let q = pixel + vec2<i32>(dx, dy) * step;\n\n      if (!inside(q)) {\n        continue;\n      }\n\n      let other = u32(q.y) * params.size.x + u32(q.x);\n      let d = diffuseIn[other];\n      let s = specularIn[other];\n      let base = KERNEL[dx + 2] * KERNEL[dy + 2];\n      var wd = base;\n      var ws = base;\n\n      if (dx != 0 || dy != 0) {\n        if (accumulation[other].w <= 0.0) {\n          continue;\n        }\n\n        let offset = length(vec2<f32>(f32(dx * step), f32(dy * step)));\n        let alignment = max(dot(normal, guideNormal(other)), 0.0);\n        let depthWeight = exp(-abs(depth - guideDepth(other)) / (0.02 * depth * offset + 1e-3));\n\n        wd = wd * pow(alignment, 128.0) * depthWeight\n          * exp(-abs(luminance(d.rgb) - luminance(diffuseCenter.rgb)) / diffuseSigma);\n\n        ws = ws * pow(alignment, specularPower) * depthWeight\n          * exp(-abs(guideRoughness(other) - roughness) * 10.0)\n          * exp(-abs(luminance(s.rgb) - luminance(specularCenter.rgb)) / specularSigma)\n          * select(0.0, exp(-offset * offset / (radius * radius)), radius >= 0.5);\n      }\n\n      diffuse = diffuse + vec4<f32>(d.rgb * wd, d.w * wd * wd);\n      specular = specular + vec4<f32>(s.rgb * ws, s.w * ws * ws);\n      diffuseTotal = diffuseTotal + wd;\n      specularTotal = specularTotal + ws;\n    }\n  }\n\n  diffuseOut[index] = vec4<f32>(diffuse.rgb / diffuseTotal, diffuse.w / (diffuseTotal * diffuseTotal));\n  specularOut[index] = vec4<f32>(specular.rgb / specularTotal, specular.w / (specularTotal * specularTotal));\n}\n\n/** How much of the filtered signal replaces the traced one: by how noisy the signal still is, when asked. */\nfn amount(mean: vec3<f32>, square: f32, count: f32) -> f32 {\n  if (params.onlyNoisy == 0u || count <= 1.0) {\n    return params.strength;\n  }\n\n  let m = luminance(mean);\n  let error = sqrt(max(square / count - m * m, 0.0) / count) / sqrt(max(m, 0.0) + 1e-3);\n\n  return params.strength * smoothstep(params.converged, 4.0 * params.converged, error);\n}\n\n/** Both filtered signals, times the albedos they were divided by, each mixed with what was traced. */\n@compute @workgroup_size(8, 8, 1)\nfn finish(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= params.size.x || id.y >= params.size.y) {\n    return;\n  }\n\n  let index = id.y * params.size.x + id.x;\n  let count = accumulation[index].w;\n\n  if (count <= 0.0) {\n    diffuseOut[index] = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n\n    return;\n  }\n\n  let squares = accumulation[params.count + index];\n  let diffuse = diffuseMean(index);\n  let specular = specularMean(index);\n  let filteredDiffuse = diffuseIn[index].rgb * diffuseAlbedo(index);\n  let filteredSpecular = specularIn[index].rgb * specularAlbedo(index);\n\n  diffuseOut[index] = vec4<f32>(\n    mix(diffuse, filteredDiffuse, amount(diffuse, squares.z, count))\n    + mix(specular, filteredSpecular, amount(specular, squares.w, count)), 1.0);\n}\n";
+export declare class DenoisePass {
+    private readonly device;
+    private readonly layout;
+    private readonly prepare;
+    private readonly antiFirefly;
+    private readonly atrous;
+    private readonly finish;
+    /** One uniform per stage, so a whole denoise is a single submit. */
+    private readonly params;
+    /** Two ping-pong pairs, diffuse and specular, and the output. */
+    private buffers;
+    private width;
+    private height;
+    /** The denoised radiance, one vec4 per pixel, once `encode` has run. */
+    output: GPUBuffer | null;
+    constructor(device: GPUDevice);
+    private resize;
+    private writeParams;
+    /** Denoises what `accumulation` holds into `output`. */
+    encode(encoder: GPUCommandEncoder, accumulation: GPUBuffer, width: number, height: number, settings?: DenoiserSettings, view?: DenoiseView): void;
+    destroy(): void;
+}
+//# sourceMappingURL=denoise.d.ts.map

package/dist/denoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"denoise.d.ts","sourceRoot":"","sources":["../src/denoise.ts"],"names":[],"mappings":"AAEA,iHAAiH;AACjH,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,8GAA8G;IAC9G,SAAS,EAAE,OAAO,CAAC;IACnB,0GAA0G;IAC1G,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB,CAMtD,CAAC;AAEH,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAAG,gBAAgB,CAU7G;AAED,uFAAuF;AACvF,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,uGAAuG;AACvG,MAAM,WAAW,WAAW;IAC1B,6FAA6F;IAC7F,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,28TA2SxB,CAAC;AAQF,qBAAa,WAAW;IAgBV,OAAO,CAAC,QAAQ,CAAC,MAAM;IAfnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,iEAAiE;IACjE,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,MAAM,CAAK;IAEnB,wEAAwE;IACxE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAQ;gBAEH,MAAM,EAAE,SAAS;IA2B9C,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,WAAW;IAmBnB,wDAAwD;IACxD,MAAM,CACJ,OAAO,EAAE,iBAAiB,EAC1B,YAAY,EAAE,SAAS,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,gBAAmC,EAC7C,IAAI,GAAE,WAA6D;IAiDrE,OAAO;CAMR"}

package/dist/denoise.js

@@ -0,0 +1,455 @@
+import { createShaderModule } from "./shaderModule.js";
+export const DEFAULT_DENOISER = Object.freeze({
+    strength: 1,
+    passes: 3,
+    edge: 2,
+    onlyNoisy: true,
+    antiFirefly: true,
+});
+/** The settings with `input` applied, each field kept in range. */
+export function mergeDenoiser(base, input = {}) {
+    const merged = { ...base, ...Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined)) };
+    return {
+        strength: Math.min(1, Math.max(0, Number(merged.strength) || 0)),
+        passes: Math.min(5, Math.max(1, Math.round(Number(merged.passes) || 1))),
+        edge: Math.max(0.01, Number(merged.edge) || DEFAULT_DENOISER.edge),
+        onlyNoisy: Boolean(merged.onlyNoisy),
+        antiFirefly: Boolean(merged.antiFirefly),
+    };
+}
+/** The error a pixel counts as converged under, the one adaptive sampling stops at. */
+export const CONVERGED_ERROR = 0.004;
+/**
+ * The denoiser: the spatial half of SVGF (Schied and others, 2017), with the diffuse and the specular light filtered
+ * apart, as NVIDIA's RELAX and REBLUR do.
+ *
+ * The path tracer splits every path at its first scatter, by the lobe it took, so each pixel holds a diffuse and a
+ * specular signal, each with its own variance. Each is divided by its own albedo (the diffuse colour, and the GGX
+ * lobe's directional albedo), so the filter sees light and never blurs a texture or a colour; both are multiplied back
+ * at the end. A pixel brighter than all of its neighbours is first clamped to the brightest of them.
+ *
+ * Then a few passes of an edge-avoiding a-trous wavelet, its taps twice as far apart each pass. The diffuse light is
+ * weighed by the agreement of normals and depths and by its luminance against the pixel's own variance. The specular
+ * light also by roughness, by normals more sharply the smoother the surface, and within the footprint its lobe leaves on
+ * the screen: the lobe's angle times the distance to what it reflects, seen from the camera. A sharp reflection of
+ * something near is left almost alone; a rough reflection of something far is smoothed across a wide area.
+ *
+ * The weights are normalized, which keeps every flat area at exactly its mean, and each signal is mixed with what was
+ * traced by how noisy it still is, so what has converged keeps exactly its traced value.
+ */
+export const DENOISE_WGSL = /* wgsl */ `
+struct Params {
+  size: vec2<u32>,
+  step: u32,
+  count: u32,
+  edge: f32,
+  strength: f32,
+  onlyNoisy: u32,
+  converged: f32,
+  pixelScale: f32,
+  orthographic: u32,
+  padding: vec2<u32>,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> diffuseIn: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read> specularIn: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> diffuseOut: array<vec4<f32>>;
+@group(0) @binding(5) var<storage, read_write> specularOut: array<vec4<f32>>;
+
+fn luminance(color: vec3<f32>) -> f32 {
+  return dot(color, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+fn samples(index: u32) -> f32 {
+  return max(accumulation[index].w, 1.0);
+}
+
+/** Each signal's mean radiance: the diffuse one stored apart, the specular one the rest. */
+fn diffuseMean(index: u32) -> vec3<f32> {
+  return accumulation[4u * params.count + index].rgb / samples(index);
+}
+
+fn specularMean(index: u32) -> vec3<f32> {
+  return accumulation[index].rgb / samples(index) - diffuseMean(index);
+}
+
+/** The albedos the light is divided by, kept off zero so the division never explodes. */
+fn diffuseAlbedo(index: u32) -> vec3<f32> {
+  return max(accumulation[2u * params.count + index].rgb / samples(index), vec3<f32>(0.01));
+}
+
+fn specularAlbedo(index: u32) -> vec3<f32> {
+  return max(accumulation[5u * params.count + index].rgb / samples(index), vec3<f32>(0.01));
+}
+
+fn guideNormal(index: u32) -> vec3<f32> {
+  let sum = accumulation[3u * params.count + index].xyz;
+  let size = length(sum);
+
+  return select(vec3<f32>(0.0), sum / size, size > 1e-6);
+}
+
+fn guideDepth(index: u32) -> f32 {
+  return accumulation[3u * params.count + index].w / samples(index);
+}
+
+fn guideRoughness(index: u32) -> f32 {
+  return accumulation[2u * params.count + index].w / samples(index);
+}
+
+fn specularDistance(index: u32) -> f32 {
+  return accumulation[4u * params.count + index].w / samples(index);
+}
+
+/** The variance of a signal's mean, in the space of its demodulated light. */
+fn variance(mean: vec3<f32>, square: f32, count: f32, albedo: vec3<f32>) -> f32 {
+  let m = luminance(mean);
+  let a = max(luminance(albedo), 0.01);
+
+  return max(square / count - m * m, 0.0) / count / (a * a);
+}
+
+/** Both signals, divided by their albedos, with the variance of their means. */
+@compute @workgroup_size(8, 8, 1)
+fn prepare(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.size.x || id.y >= params.size.y) {
+    return;
+  }
+
+  let index = id.y * params.size.x + id.x;
+  let count = accumulation[index].w;
+
+  if (count <= 0.0) {
+    diffuseOut[index] = vec4<f32>(0.0);
+    specularOut[index] = vec4<f32>(0.0);
+
+    return;
+  }
+
+  let squares = accumulation[params.count + index];
+  let diffuse = diffuseMean(index);
+  let specular = specularMean(index);
+
+  diffuseOut[index] = vec4<f32>(diffuse / diffuseAlbedo(index), variance(diffuse, squares.z, count, diffuseAlbedo(index)));
+  specularOut[index] = vec4<f32>(
+    specular / specularAlbedo(index), variance(specular, squares.w, count, specularAlbedo(index)));
+}
+
+fn inside(q: vec2<i32>) -> bool {
+  return q.x >= 0 && q.y >= 0 && q.x < i32(params.size.x) && q.y < i32(params.size.y);
+}
+
+/** A value brighter than every neighbour, scaled down to the brightest of them: a firefly, not a feature. */
+fn clampFirefly(value: vec4<f32>, brightest: f32) -> vec4<f32> {
+  let own = luminance(value.rgb);
+
+  if (own <= brightest || own <= 0.0) {
+    return value;
+  }
+
+  return vec4<f32>(value.rgb * (brightest / own), value.w);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn antiFirefly(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.size.x || id.y >= params.size.y) {
+    return;
+  }
+
+  let pixel = vec2<i32>(id.xy);
+  let index = id.y * params.size.x + id.x;
+  var diffuse = 0.0;
+  var specular = 0.0;
+
+  for (var dy = -1; dy <= 1; dy = dy + 1) {
+    for (var dx = -1; dx <= 1; dx = dx + 1) {
+      let q = pixel + vec2<i32>(dx, dy);
+
+      if ((dx == 0 && dy == 0) || !inside(q)) {
+        continue;
+      }
+
+      let other = u32(q.y) * params.size.x + u32(q.x);
+      diffuse = max(diffuse, luminance(diffuseIn[other].rgb));
+      specular = max(specular, luminance(specularIn[other].rgb));
+    }
+  }
+
+  diffuseOut[index] = clampFirefly(diffuseIn[index], diffuse);
+  specularOut[index] = clampFirefly(specularIn[index], specular);
+}
+
+const KERNEL = array<f32, 5>(0.0625, 0.25, 0.375, 0.25, 0.0625);
+
+/** The variance around a pixel, blurred over 3 x 3, which steadies the luminance test on a few samples. */
+fn localVariance(pixel: vec2<i32>, specular: bool) -> f32 {
+  var sum = 0.0;
+  var weight = 0.0;
+
+  for (var dy = -1; dy <= 1; dy = dy + 1) {
+    for (var dx = -1; dx <= 1; dx = dx + 1) {
+      let q = pixel + vec2<i32>(dx, dy);
+
+      if (!inside(q)) {
+        continue;
+      }
+
+      let other = u32(q.y) * params.size.x + u32(q.x);
+      let w = select(0.5, 1.0, dx == 0) * select(0.5, 1.0, dy == 0);
+      sum = sum + select(diffuseIn[other].w, specularIn[other].w, specular) * w;
+      weight = weight + w;
+    }
+  }
+
+  return sum / max(weight, 1e-6);
+}
+
+/**
+ * How many pixels the specular lobe's footprint covers: the lobe's angle times the distance to what it reflects, seen
+ * from the camera across the distance to the surface plus that.
+ */
+fn specularRadius(index: u32, depth: f32) -> f32 {
+  let alpha = guideRoughness(index) * guideRoughness(index);
+  let reflected = specularDistance(index);
+
+  if (params.orthographic != 0u) {
+    return min(alpha * reflected / params.pixelScale, 64.0);
+  }
+
+  return min(alpha * reflected / max(depth + reflected, 1e-6) / params.pixelScale, 64.0);
+}
+
+/** One a-trous pass over both signals, its taps params.step pixels apart. */
+@compute @workgroup_size(8, 8, 1)
+fn atrous(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.size.x || id.y >= params.size.y) {
+    return;
+  }
+
+  let pixel = vec2<i32>(id.xy);
+  let index = id.y * params.size.x + id.x;
+  let diffuseCenter = diffuseIn[index];
+  let specularCenter = specularIn[index];
+
+  if (accumulation[index].w <= 0.0) {
+    diffuseOut[index] = diffuseCenter;
+    specularOut[index] = specularCenter;
+
+    return;
+  }
+
+  let normal = guideNormal(index);
+  let depth = guideDepth(index);
+  let roughness = guideRoughness(index);
+  let diffuseSigma = params.edge * sqrt(max(localVariance(pixel, false), 0.0)) + 1e-6;
+  let specularSigma = params.edge * sqrt(max(localVariance(pixel, true), 0.0)) + 1e-6;
+  let radius = specularRadius(index, depth);
+  // A smoother surface's reflection turns faster with its normal: the normal test sharpens with it.
+  let specularPower = min(128.0 / max(roughness * roughness, 0.03), 4096.0);
+  let step = i32(params.step);
+  var diffuse = vec4<f32>(0.0);
+  var specular = vec4<f32>(0.0);
+  var diffuseTotal = 0.0;
+  var specularTotal = 0.0;
+
+  for (var dy = -2; dy <= 2; dy = dy + 1) {
+    for (var dx = -2; dx <= 2; dx = dx + 1) {
+      let q = pixel + vec2<i32>(dx, dy) * step;
+
+      if (!inside(q)) {
+        continue;
+      }
+
+      let other = u32(q.y) * params.size.x + u32(q.x);
+      let d = diffuseIn[other];
+      let s = specularIn[other];
+      let base = KERNEL[dx + 2] * KERNEL[dy + 2];
+      var wd = base;
+      var ws = base;
+
+      if (dx != 0 || dy != 0) {
+        if (accumulation[other].w <= 0.0) {
+          continue;
+        }
+
+        let offset = length(vec2<f32>(f32(dx * step), f32(dy * step)));
+        let alignment = max(dot(normal, guideNormal(other)), 0.0);
+        let depthWeight = exp(-abs(depth - guideDepth(other)) / (0.02 * depth * offset + 1e-3));
+
+        wd = wd * pow(alignment, 128.0) * depthWeight
+          * exp(-abs(luminance(d.rgb) - luminance(diffuseCenter.rgb)) / diffuseSigma);
+
+        ws = ws * pow(alignment, specularPower) * depthWeight
+          * exp(-abs(guideRoughness(other) - roughness) * 10.0)
+          * exp(-abs(luminance(s.rgb) - luminance(specularCenter.rgb)) / specularSigma)
+          * select(0.0, exp(-offset * offset / (radius * radius)), radius >= 0.5);
+      }
+
+      diffuse = diffuse + vec4<f32>(d.rgb * wd, d.w * wd * wd);
+      specular = specular + vec4<f32>(s.rgb * ws, s.w * ws * ws);
+      diffuseTotal = diffuseTotal + wd;
+      specularTotal = specularTotal + ws;
+    }
+  }
+
+  diffuseOut[index] = vec4<f32>(diffuse.rgb / diffuseTotal, diffuse.w / (diffuseTotal * diffuseTotal));
+  specularOut[index] = vec4<f32>(specular.rgb / specularTotal, specular.w / (specularTotal * specularTotal));
+}
+
+/** How much of the filtered signal replaces the traced one: by how noisy the signal still is, when asked. */
+fn amount(mean: vec3<f32>, square: f32, count: f32) -> f32 {
+  if (params.onlyNoisy == 0u || count <= 1.0) {
+    return params.strength;
+  }
+
+  let m = luminance(mean);
+  let error = sqrt(max(square / count - m * m, 0.0) / count) / sqrt(max(m, 0.0) + 1e-3);
+
+  return params.strength * smoothstep(params.converged, 4.0 * params.converged, error);
+}
+
+/** Both filtered signals, times the albedos they were divided by, each mixed with what was traced. */
+@compute @workgroup_size(8, 8, 1)
+fn finish(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x >= params.size.x || id.y >= params.size.y) {
+    return;
+  }
+
+  let index = id.y * params.size.x + id.x;
+  let count = accumulation[index].w;
+
+  if (count <= 0.0) {
+    diffuseOut[index] = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+
+    return;
+  }
+
+  let squares = accumulation[params.count + index];
+  let diffuse = diffuseMean(index);
+  let specular = specularMean(index);
+  let filteredDiffuse = diffuseIn[index].rgb * diffuseAlbedo(index);
+  let filteredSpecular = specularIn[index].rgb * specularAlbedo(index);
+
+  diffuseOut[index] = vec4<f32>(
+    mix(diffuse, filteredDiffuse, amount(diffuse, squares.z, count))
+    + mix(specular, filteredSpecular, amount(specular, squares.w, count)), 1.0);
+}
+`;
+/** The a-trous passes, their taps 1, 2, 4, 8 and 16 pixels apart. */
+const STEPS = [1, 2, 4, 8, 16];
+/** Uniforms: prepare, anti-firefly, one per a-trous pass, finish. */
+const STAGES = STEPS.length + 3;
+export class DenoisePass {
+    device;
+    layout;
+    prepare;
+    antiFirefly;
+    atrous;
+    finish;
+    /** One uniform per stage, so a whole denoise is a single submit. */
+    params;
+    /** Two ping-pong pairs, diffuse and specular, and the output. */
+    buffers = [];
+    width = 0;
+    height = 0;
+    /** The denoised radiance, one vec4 per pixel, once `encode` has run. */
+    output = null;
+    constructor(device) {
+        this.device = device;
+        const module = createShaderModule(device, "denoise", DENOISE_WGSL);
+        const storage = (type) => ({ type });
+        const visibility = GPUShaderStage.COMPUTE;
+        this.layout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility, buffer: { type: "uniform" } },
+                { binding: 1, visibility, buffer: storage("read-only-storage") },
+                { binding: 2, visibility, buffer: storage("read-only-storage") },
+                { binding: 3, visibility, buffer: storage("read-only-storage") },
+                { binding: 4, visibility, buffer: storage("storage") },
+                { binding: 5, visibility, buffer: storage("storage") },
+            ],
+        });
+        const layout = device.createPipelineLayout({ bindGroupLayouts: [this.layout] });
+        const pipeline = (entryPoint) => device.createComputePipeline({ layout, compute: { module, entryPoint } });
+        this.prepare = pipeline("prepare");
+        this.antiFirefly = pipeline("antiFirefly");
+        this.atrous = pipeline("atrous");
+        this.finish = pipeline("finish");
+        this.params = Array.from({ length: STAGES }, () => device.createBuffer({ size: 48, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }));
+    }
+    resize(width, height) {
+        if (width === this.width && height === this.height && this.buffers.length)
+            return;
+        for (const buffer of this.buffers)
+            buffer.destroy();
+        const size = Math.max(16, width * height * 16);
+        this.buffers = Array.from({ length: 5 }, () => this.device.createBuffer({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC }));
+        this.output = this.buffers[4];
+        this.width = width;
+        this.height = height;
+    }
+    writeParams(width, height, settings, view) {
+        const steps = [1, 1, ...STEPS, 1];
+        steps.forEach((step, k) => {
+            const values = new ArrayBuffer(48);
+            const words = new Uint32Array(values);
+            const floats = new Float32Array(values);
+            words.set([width, height, step, width * height]);
+            floats[4] = settings.edge;
+            floats[5] = settings.strength;
+            words[6] = settings.onlyNoisy ? 1 : 0;
+            floats[7] = CONVERGED_ERROR;
+            floats[8] = view.pixelScale;
+            words[9] = view.orthographic ? 1 : 0;
+            this.device.queue.writeBuffer(this.params[k], 0, values);
+        });
+    }
+    /** Denoises what `accumulation` holds into `output`. */
+    encode(encoder, accumulation, width, height, settings = DEFAULT_DENOISER, view = { pixelScale: 1 / height, orthographic: false }) {
+        this.resize(width, height);
+        this.writeParams(width, height, settings, view);
+        const [diffuseA, diffuseB, specularA, specularB, output] = this.buffers;
+        const groups = [Math.ceil(width / 8), Math.ceil(height / 8)];
+        const run = (pipeline, params, sources, targets) => {
+            const group = this.device.createBindGroup({
+                layout: this.layout,
+                entries: [
+                    { binding: 0, resource: { buffer: params } },
+                    { binding: 1, resource: { buffer: accumulation } },
+                    { binding: 2, resource: { buffer: sources[0] } },
+                    { binding: 3, resource: { buffer: sources[1] } },
+                    { binding: 4, resource: { buffer: targets[0] } },
+                    { binding: 5, resource: { buffer: targets[1] } },
+                ],
+            });
+            const pass = encoder.beginComputePass({ label: "denoise" });
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(0, group);
+            pass.dispatchWorkgroups(groups[0], groups[1]);
+            pass.end();
+        };
+        // prepare reads nothing from its sources; the B buffers stand in so the bindings are valid.
+        run(this.prepare, this.params[0], [diffuseB, specularB], [diffuseA, specularA]);
+        let from = [diffuseA, specularA];
+        let to = [diffuseB, specularB];
+        if (settings.antiFirefly) {
+            run(this.antiFirefly, this.params[1], from, to);
+            [from, to] = [to, from];
+        }
+        STEPS.slice(0, settings.passes).forEach((_, k) => {
+            run(this.atrous, this.params[k + 2], from, to);
+            [from, to] = [to, from];
+        });
+        // finish writes the result to the output; the free specular buffer fills the second, unused, target.
+        run(this.finish, this.params[STAGES - 1], from, [output, to[1]]);
+    }
+    destroy() {
+        for (const buffer of [...this.buffers, ...this.params])
+            buffer.destroy();
+        this.buffers = [];
+        this.output = null;
+    }
+}
+//# sourceMappingURL=denoise.js.map

package/dist/denoise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"denoise.js","sourceRoot":"","sources":["../src/denoise.ts"],"names":[],"mappings":"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"}

package/dist/device.d.ts

@@ -0,0 +1,37 @@
+/** Acquiring a device, and the questions a host asks before choosing this renderer at all. */
+/** What the renderer needs from the platform, and what is missing when it cannot run. */
+export interface WebGpuSupport {
+    /** True when an adapter answered. */
+    supported: boolean;
+    /** Why the renderer cannot run here, in one sentence. Empty when `supported`. */
+    reason: string;
+}
+export interface RenderDevice {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    /** Largest storage buffer this device accepts, which is the ceiling on how big a scene can be. */
+    maxStorageBufferBindingSize: number;
+    maxBufferSize: number;
+}
+export interface RenderDeviceOptions {
+    /** Called when the device is lost. The renderer stops; choosing what to do next is the host's decision. */
+    onLost?: (reason: string) => void;
+}
+/**
+ * Whether this context exposes WebGPU at all. It is a cheap, synchronous check for a fallback decision;
+ * it does not prove that an adapter exists, which only `requestWebGpuSupport` can tell.
+ */
+export declare function isWebGpuAvailable(): boolean;
+/**
+ * Asks the platform for an adapter, which is the only honest answer to "can this machine render?".
+ * A browser can expose `navigator.gpu` and still hand back no adapter (a blocklisted driver, a headless session
+ * without a software fallback), so hosts deciding between renderers should await this one.
+ */
+export declare function requestWebGpuSupport(): Promise<WebGpuSupport>;
+/**
+ * The device the renderer runs on, asking for everything the adapter offers. Scene geometry, the hierarchy and the
+ * accumulation buffer all live in storage buffers, so the default 128 MiB binding size is the first ceiling a real
+ * scene meets, and adapters routinely allow far more.
+ */
+export declare function requestRenderDevice(options?: RenderDeviceOptions): Promise<RenderDevice>;
+//# sourceMappingURL=device.d.ts.map

package/dist/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../src/device.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAE9F,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,kGAAkG;IAClG,2BAA2B,EAAE,MAAM,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,2GAA2G;IAC3G,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,aAAa,CAAC,CAanE;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CAwBlG"}