@tinypoly/gpu-renderer 0.1.0 → 0.2.0

package/dist/wgsl/pathTrace.wgsl.js

@@ -42,7 +42,9 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
     return frame.background.rgb;
   }
 
-  // A procedural sky paints the background without the strength it lights with, and its foreground over it.
+  // A procedural sky paints the background with the strength it lights with, and its foreground over it. The CPU
+  // renderer leaves that strength out of what the camera sees, which a renderer exposing for the light cannot: the sky
+  // that lights a wall five times brighter than itself would show as a dark band behind it.
   if (frame.skyProgram != NO_PROGRAM || frame.skyIntensity > 0.0) {
     if (frame.skyBackground == 0u) {
       return vec3<f32>(0.0);
@@ -54,10 +56,10 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
       input.direction = direction;
       input.diffuseColor = vec4<f32>(1.0);
 
-      return runProgram(frame.skyProgram, input).color.rgb;
+      return runProgram(frame.skyProgram, input).color.rgb * frame.skyIntensity;
     }
 
-    return environmentRadiance(direction) / frame.skyIntensity;
+    return environmentRadiance(direction);
   }
 
   return environmentRadiance(direction);
@@ -67,7 +69,7 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
  * How much of the sky a bounce ray that escaped keeps. Direct sampling aims at the bright parts of an image too, so the
  * two share it; when direct sampling took all of it, as it does from a toon surface, the bounce keeps none.
  */
-fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f32 {
+fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool, scatteredAt: vec3<f32>) -> f32 {
   if (frame.environmentPick <= 0.0) {
     return 1.0;
   }
@@ -80,7 +82,8 @@ fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f3
     return 1.0;
   }
 
-  return misWeight(bsdfPdf, frame.environmentPick * environmentPdf(direction));
+  // The sky was aimed at from the vertex the bounce left, through its windows as well when that vertex is inside.
+  return misWeight(bsdfPdf, frame.environmentPick * skyPdf(scatteredAt, direction, portalChance(scatteredAt)));
 }
 
 /** Scales a contribution down to the luminance ceiling, which trades a little bias for the fireflies it removes. */
@@ -456,55 +459,57 @@ fn traceRadiance(
   for (var step = 0u; step < MAX_STEPS + MAX_WALK; step = step + 1u) {
     let hit = traceScene(origin, direction, limit);
 
-    // Every vertex draws the same dimensions in the same order, whatever the path then does with them.
-    let coverage = sample2D(rng);
-    let pick = sample2D(rng);
-    let lightSample = sample2D(rng);
-    let lobe = sample2D(rng);
-    let bounceSample = sample2D(rng);
-    var mediumSample = vec2<f32>(0.0);
-    var bevelSample = vec4<f32>(0.0);
-
-    if (VOLUMES) {
-      mediumSample = sample2D(rng);
-    }
-
-    if (BEVEL) {
-      bevelSample = vec4<f32>(sample2D(rng), sample2D(rng));
-    }
-
-    // The walk left the material here, and the surface below is its way out rather than what the material shows.
-    var exiting = false;
+    // A step of the walk inside a material that ends in the medium: the light scatters there, keeping each colour's
+    // share of it. It needs three numbers, which a plain hash gives for a fraction of what the sequence costs.
+    if (SUBSURFACE_WALK && inMedium && hit.triangle == NO_HIT) {
+      let travelled = exp(-sigma * limit);
+      let density = dot(walkOdds, sigma * travelled);
+      // A new direction, the next distance (a colour and how far), and the roulette's chance.
+      let turn = hashSample2D(rng);
+      let next = hashSample2D(rng);
+      let chance = hashSample2D(rng).x;
 
-    if (SUBSURFACE_WALK && inMedium) {
-      if (hit.triangle == NO_HIT) {
-        // Nothing within the drawn distance: the light scatters there, keeping each colour's share of the medium.
-        let travelled = exp(-sigma * limit);
-        let density = dot(walkOdds, sigma * travelled);
+      throughput = throughput * sigma * walkAlbedo * travelled / max(density, 1e-20);
+      walkSteps = walkSteps + 1u;
 
-        throughput = throughput * sigma * walkAlbedo * travelled / max(density, 1e-20);
-        walkSteps = walkSteps + 1u;
+      let survival = max3(throughput);
 
-        let survival = max3(throughput);
+      if (walkSteps >= MAX_WALK || survival <= 0.0) {
+        break;
+      }
 
-        if (walkSteps >= MAX_WALK || survival <= 0.0) {
+      if (survival < 0.2) {
+        if (chance > survival) {
           break;
         }
 
-        if (survival < 0.2) {
-          if (coverage.x > survival) {
-            break;
-          }
+        throughput = throughput / survival;
+      }
 
-          throughput = throughput / survival;
-        }
+      origin = origin + direction * limit;
+      direction = sampleHenyeyGreenstein(direction, walkG, turn);
+      limit = walkDistance(throughput, sigma, next, &walkOdds);
+      continue;
+    }
 
-        origin = origin + direction * limit;
-        direction = sampleHenyeyGreenstein(direction, walkG, lobe);
-        limit = walkDistance(throughput, sigma, pick, &walkOdds);
-        continue;
-      }
+    // Every vertex draws the same dimensions in the same order, whatever the path then does with them: from the
+    // sequence for the first vertices, from a hash past SEQUENCE_DEPTH bounces.
+    let deep = bounce >= SEQUENCE_DEPTH;
+    let coverage = pathSample2D(rng, deep);
+    let pick = pathSample2D(rng, deep);
+    let lightSample = pathSample2D(rng, deep);
+    let lobe = pathSample2D(rng, deep);
+    let bounceSample = pathSample2D(rng, deep);
+    var mediumSample = vec2<f32>(0.0);
+
+    if (VOLUMES) {
+      mediumSample = pathSample2D(rng, deep);
+    }
+
+    // The walk left the material here, and the surface below is its way out rather than what the material shows.
+    var exiting = false;
 
+    if (SUBSURFACE_WALK && inMedium) {
       // The walk reached the surface before scattering again: the chance of travelling that far, per colour.
       let travelled = exp(-sigma * hit.distance);
 
@@ -546,7 +551,7 @@ fn traceRadiance(
         if (escapeMap != NO_TEXTURE) {
           sky = sky + sampleEquirect(escapeMap, direction).rgb * escapeIntensity;
         } else {
-          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect);
+          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect, lastPosition);
         }
 
         let contribution = throughput * sky;
@@ -631,8 +636,16 @@ fn traceRadiance(
 
     surface = resolveSurfaceFrom(hit.triangle, bary, direction, base);
 
+    // Deep in the path, light reflects off a material that scatters inside as off a diffuse one of the same colour.
+    if (SUBSURFACE_WALK && bounce >= frame.subsurfaceDepth) {
+      surface.subsurface = 0.0;
+    }
+
     if (BEVEL && frame.bevelEnabled != 0u && materials[m].bevel > 0.0) {
-      surface.normal = bevelNormal(m, point, surface, -direction, materials[m].bevel, bevelSample.xy, bevelSample.zw);
+      let disk = hashSample2D(rng);
+      let axis = hashSample2D(rng);
+
+      surface.normal = bevelNormal(m, point, surface, -direction, materials[m].bevel, disk, axis);
     }
     }
 
@@ -693,8 +706,14 @@ fn traceRadiance(
       depth = length(point - rayOrigin);
     }
 
+    // A window the camera ray goes straight through is not what the camera sees: what lies behind it is, so the
+    // denoiser takes its guides there, and the air its distance. Glass has next to no diffuse colour and one flat
+    // normal, which would leave everything seen through it unfiltered. The window's own guides stand until then, for
+    // the paths that reflect off it instead.
+    let window = surface.transmission > 0.0 && surface.thickness <= 0.0;
+
     if (straight && !guided) {
-      guided = true;
+      guided = !window;
       diffuseAlbedo = diffuseGuide(surface);
       specularAlbedoGuide = select(specularAlbedo(surface, -direction), vec3<f32>(1.0), (surface.flags & MATERIAL_LIT) == 0u);
       guideNormal = surface.normal;
@@ -735,7 +754,7 @@ fn traceRadiance(
         }
       }
 
-      if (!hazed && frame.atmosphereColor.w > 0.0) {
+      if (!hazed && !window && frame.atmosphereColor.w > 0.0) {
         hazed = true;
         // From the eye, where the camera ray only starts on the near plane; an orthographic view has no eye.
         hazeDistance = length(point - select(frame.cameraToWorld[3].xyz, rayOrigin, frame.cameraKind == 1u));
@@ -755,7 +774,11 @@ fn traceRadiance(
     }
 
     // Three does not light a basic, points, line or sprite material, so nothing carries on from one.
-    if ((surface.flags & MATERIAL_LIT) == 0u || bounce >= frame.bounces) {
+    // Past the last bounce a path still crosses a window straight on, which scatters nothing, to find the sky behind
+    // it: cut there, the daylight a room gets through its glazing would go missing from every last bounce.
+    let spent = bounce >= frame.bounces;
+
+    if ((surface.flags & MATERIAL_LIT) == 0u || (spent && !window)) {
       break;
     }
 
@@ -778,8 +801,105 @@ fn traceRadiance(
     var nextOrigin = point + direction * RAY_EPSILON;
 
     // Transmission replaces part of the diffuse layer, so that share of the time the surface is a dielectric instead.
-    // Choosing it in proportion to its weight leaves both halves unweighted, and only the opaque half aims at a light.
-    if (surface.transmission > 0.0 && lobe.y < surface.transmission) {
+    // Choosing it in proportion to its weight leaves both halves unweighted. The opaque half aims at a light; on a
+    // window that lets only part of the light through, it does so on every path, weighed by its share, rather than on
+    // the paths that chose it: a sunlit pane seen against a dim room would otherwise be lit on one path in five and
+    // dark on the rest, which is the grain glass shows.
+    let dielectric = surface.transmission > 0.0 && lobe.y < surface.transmission;
+    let windowLight = window && !spent && surface.transmission < 1.0 && surface.subsurface <= 0.0;
+
+    if (!dielectric || windowLight) {
+      var chance = 0.0;
+
+      if (!dielectric) {
+        // Light that enters the material: a random walk inside it from here, in place of the share of the diffuse
+        // layer that scatters inside. Chosen by chance, so neither branch is weighted against the other.
+        // The window's opaque share is a surface like any other, which a spent path stops at.
+        if (spent) {
+          break;
+        }
+
+        if (SUBSURFACE_WALK) {
+          chance = subsurfaceChance(surface, view);
+        }
+
+        if (SUBSURFACE_WALK && lobe.x < chance) {
+          let medium = materials[surface.material].subsurface;
+
+          throughput = throughput
+            * ((1.0 - surface.metalness) * surface.subsurface * coatTransmittance(surface, view) / chance);
+          sigma = vec3<f32>(1.0) / max(medium.rgb, vec3<f32>(1e-6));
+          walkAlbedo = subsurfaceAlbedo(surface.albedo);
+          walkG = materials[surface.material].subsurfaceAnisotropy;
+          walkSteps = 0u;
+
+          // Light that scattered inside is diffuse light, which is the signal it feeds.
+          if (!split) {
+            split = true;
+            splitBase = radiance;
+            splitDiffuse = true;
+          }
+
+          inMedium = true;
+          primary = false;
+          straight = false;
+          bsdfPdf = 0.0;
+          lightsOwnDirect = false;
+          escapeMap = NO_TEXTURE;
+          bounce = bounce + 1u;
+          direction = cosineDirection(-surface.facing, bounceSample);
+          origin = point - surface.facing * RAY_EPSILON;
+          limit = walkDistance(throughput, sigma, pick, &walkOdds);
+          continue;
+        }
+
+        throughput = throughput / (1.0 - chance);
+      }
+
+      let position = point + surface.normal * RAY_EPSILON;
+      var directDiffuse: vec3<f32>;
+      let lit = select(throughput, throughput * (1.0 - surface.transmission), windowLight);
+      let direct = lit * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse,
+        select(0.0, volumeDensity, inVolume));
+      let added = select(direct, clampIndirect(direct), bounce > 0u);
+      let before = radiance;
+
+      radiance = radiance + added;
+
+      if (!dielectric) {
+        let scattered = sampleBsdf(surface, view, (lobe.x - chance) / (1.0 - chance), bounceSample);
+
+        // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.
+        if (!split) {
+          split = true;
+          splitBase = before;
+          splitDirect = added;
+          splitDirectDiffuse = lit * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),
+            bounce > 0u);
+          splitDiffuse = !scattered.valid || scattered.diffuse;
+          waitingForSpecular = scattered.valid && !scattered.diffuse;
+        }
+
+        if (!scattered.valid) {
+          break;
+        }
+
+        throughput = throughput * scattered.weight;
+        bsdfPdf = scattered.pdf;
+        lastPosition = position;
+        lastNormal = treeNormal(surface);
+        lightsOwnDirect = surface.kind == KIND_TOON;
+        escapeMap = surface.envMap;
+        escapeIntensity = surface.envMapIntensity;
+        next = scattered.direction;
+        nextOrigin = position;
+        primary = false;
+        straight = false;
+        bounce = bounce + 1u;
+      }
+    }
+
+    if (dielectric) {
       var ior = surface.ior;
 
       // Three's dispersion: each colour refracts with its own index, spread around the material's. The path picks one
@@ -799,7 +919,8 @@ fn traceRadiance(
 
       let crossing = sampleDielectric(surface, view, ior, lobe.y / surface.transmission, bounceSample);
 
-      if (!crossing.valid) {
+      // A reflection off the glass is a scattering, which a spent path no longer has.
+      if (!crossing.valid || (spent && !crossing.straight)) {
         break;
       }
 
@@ -834,85 +955,6 @@ fn traceRadiance(
       if (!primary) {
         bounce = bounce + 1u;
       }
-    } else {
-      // Light that enters the material: a random walk inside it from here, in place of the share of the diffuse
-      // layer that scatters inside. Chosen by chance, so neither branch is weighted against the other.
-      var chance = 0.0;
-
-      if (SUBSURFACE_WALK) {
-        chance = subsurfaceChance(surface, view);
-      }
-
-      if (SUBSURFACE_WALK && lobe.x < chance) {
-        let medium = materials[surface.material].subsurface;
-
-        throughput = throughput
-          * ((1.0 - surface.metalness) * surface.subsurface * coatTransmittance(surface, view) / chance);
-        sigma = vec3<f32>(1.0) / max(medium.rgb, vec3<f32>(1e-6));
-        walkAlbedo = subsurfaceAlbedo(surface.albedo);
-        walkG = materials[surface.material].subsurfaceAnisotropy;
-        walkSteps = 0u;
-
-        // Light that scattered inside is diffuse light, which is the signal it feeds.
-        if (!split) {
-          split = true;
-          splitBase = radiance;
-          splitDiffuse = true;
-        }
-
-        inMedium = true;
-        primary = false;
-        straight = false;
-        bsdfPdf = 0.0;
-        lightsOwnDirect = false;
-        escapeMap = NO_TEXTURE;
-        bounce = bounce + 1u;
-        direction = cosineDirection(-surface.facing, bounceSample);
-        origin = point - surface.facing * RAY_EPSILON;
-        limit = walkDistance(throughput, sigma, pick, &walkOdds);
-        continue;
-      }
-
-      throughput = throughput / (1.0 - chance);
-
-      let position = point + surface.normal * RAY_EPSILON;
-      var directDiffuse: vec3<f32>;
-      let direct = throughput * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse,
-        select(0.0, volumeDensity, inVolume));
-      let added = select(direct, clampIndirect(direct), bounce > 0u);
-      let before = radiance;
-
-      radiance = radiance + added;
-
-      let scattered = sampleBsdf(surface, view, (lobe.x - chance) / (1.0 - chance), bounceSample);
-
-      // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.
-      if (!split) {
-        split = true;
-        splitBase = before;
-        splitDirect = added;
-        splitDirectDiffuse = throughput * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),
-          bounce > 0u);
-        splitDiffuse = !scattered.valid || scattered.diffuse;
-        waitingForSpecular = scattered.valid && !scattered.diffuse;
-      }
-
-      if (!scattered.valid) {
-        break;
-      }
-
-      throughput = throughput * scattered.weight;
-      bsdfPdf = scattered.pdf;
-      lastPosition = position;
-      lastNormal = treeNormal(surface);
-      lightsOwnDirect = surface.kind == KIND_TOON;
-      escapeMap = surface.envMap;
-      escapeIntensity = surface.envMapIntensity;
-      next = scattered.direction;
-      nextOrigin = position;
-      primary = false;
-      straight = false;
-      bounce = bounce + 1u;
     }
 
     // A path that carries almost nothing is ended by chance rather than by a cut, which keeps the estimate unbiased.

package/dist/wgsl/pathTrace.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathTrace.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/pathTrace.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+2CzC,CAAC"}
+{"version":3,"file":"pathTrace.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/pathTrace.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAy5CzC,CAAC"}

package/dist/wgsl/present.wgsl.d.ts

@@ -3,5 +3,5 @@
  * vignette and grain. The operators are ports of `color.ts` in the CPU renderer, which are in turn Three's ACES, AgX
  * and Khronos neutral curves, so the two renderers agree on the display transform even when they disagree on the light.
  */
-export declare const PRESENT_WGSL = "\nstruct Present {\n  resolution: vec2<u32>,\n  exposure: f32,\n  toneMapping: u32,\n  vignette: f32,\n  grain: f32,\n  frameIndex: u32,\n  // A transparent background: the canvas gets the coverage as alpha, premultiplied as it is configured.\n  transparent: u32,\n  // Whether the colour comes from the denoiser's output rather than straight from the accumulation.\n  denoised: u32,\n};\n\n@group(0) @binding(0) var<uniform> present: Present;\n@group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> denoised: array<vec4<f32>>;\n\n@vertex\nfn vertexMain(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {\n  // One oversized triangle covers the viewport with no vertex buffer.\n  let x = f32(index / 2u) * 4.0 - 1.0;\n  let y = f32(index & 1u) * 4.0 - 1.0;\n\n  return vec4<f32>(x, y, 0.0, 1.0);\n}\n\nfn toneMapAces(color: vec3<f32>) -> vec3<f32> {\n  let toAces = mat3x3<f32>(\n    vec3<f32>(0.59719, 0.076, 0.0284),\n    vec3<f32>(0.35458, 0.90834, 0.13383),\n    vec3<f32>(0.04823, 0.01566, 0.83777));\n  let fromAces = mat3x3<f32>(\n    vec3<f32>(1.60475, -0.10208, -0.00327),\n    vec3<f32>(-0.53108, 1.10813, -0.07276),\n    vec3<f32>(-0.07367, -0.00605, 1.07602));\n  let v = toAces * (color / 0.6);\n\n  return fromAces * ((v * (v + 0.0245786) - 0.000090537) / (v * (0.983729 * v + 0.432951) + 0.238081));\n}\n\nfn toneMapAgx(color: vec3<f32>) -> vec3<f32> {\n  let toAgx = mat3x3<f32>(\n    vec3<f32>(0.6274, 0.0691, 0.0164),\n    vec3<f32>(0.3293, 0.9195, 0.088),\n    vec3<f32>(0.0433, 0.0113, 0.8956));\n  let inset = mat3x3<f32>(\n    vec3<f32>(0.856627153315983, 0.137318972929847, 0.11189821299995),\n    vec3<f32>(0.0951212405381588, 0.761241990602591, 0.0767994186031903),\n    vec3<f32>(0.0482516061458583, 0.101439036467562, 0.811302368396859));\n  let outset = mat3x3<f32>(\n    vec3<f32>(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),\n    vec3<f32>(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),\n    vec3<f32>(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405));\n  let fromAgx = mat3x3<f32>(\n    vec3<f32>(1.6605, -0.1246, -0.0182),\n    vec3<f32>(-0.5876, 1.1329, -0.1006),\n    vec3<f32>(-0.0728, -0.0083, 1.1187));\n  let logged = inset * (toAgx * color);\n  let x = clamp((log2(max(logged, vec3<f32>(1e-10))) + 12.47393) / 16.499999, vec3<f32>(0.0), vec3<f32>(1.0));\n  let curved = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))\n    - 6.868 * pow(x, vec3<f32>(3.0)) + 0.4298 * x * x + 0.1191 * x - 0.00232;\n\n  return fromAgx * pow(max(outset * curved, vec3<f32>(0.0)), vec3<f32>(2.2));\n}\n\nfn toneMapNeutral(color: vec3<f32>) -> vec3<f32> {\n  let low = min(color.r, min(color.g, color.b));\n  let offset = select(0.04, low - 6.25 * low * low, low < 0.08);\n  let shifted = color - offset;\n  let peak = max(shifted.r, max(shifted.g, shifted.b));\n\n  if (peak < 0.76) {\n    return shifted;\n  }\n\n  let newPeak = 1.0 - 0.24 * 0.24 / (peak + 0.24 - 0.76);\n  let g = 1.0 - 1.0 / (0.15 * (peak - newPeak) + 1.0);\n\n  return shifted * (newPeak / peak) * (1.0 - g) + newPeak * g;\n}\n\nfn toneMap(color: vec3<f32>) -> vec3<f32> {\n  let exposed = max(color * present.exposure, vec3<f32>(0.0));\n  var mapped = exposed;\n\n  if (present.toneMapping == 0u) {\n    mapped = toneMapAces(exposed);\n  } else if (present.toneMapping == 1u) {\n    mapped = toneMapAgx(exposed);\n  } else if (present.toneMapping == 2u) {\n    mapped = toneMapNeutral(exposed);\n  }\n\n  return clamp(mapped, vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\nfn linearToSrgb(color: vec3<f32>) -> vec3<f32> {\n  let low = color * 12.92;\n  let high = 1.055 * pow(max(color, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;\n\n  return select(high, low, color <= vec3<f32>(0.0031308));\n}\n\nfn hash(value: u32) -> f32 {\n  var state = value * 747796405u + 2891336453u;\n  state = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n\n  return f32((state >> 22u) ^ state) * 2.3283064365386963e-10;\n}\n\n@fragment\nfn fragmentMain(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {\n  let pixel = vec2<u32>(position.xy);\n  let index = pixel.y * present.resolution.x + pixel.x;\n  let stored = accumulation[index];\n\n  // Nothing has been traced into this pixel yet: it stays see-through, so whatever is under the canvas shows.\n  if (stored.w <= 0.0) {\n    return vec4<f32>(0.0);\n  }\n\n  var color = select(stored.rgb / stored.w, vec3<f32>(0.0), stored.w <= 0.0);\n\n  if (present.denoised != 0u) {\n    color = denoised[index].rgb;\n  }\n  var alpha = 1.0;\n\n  if (present.transparent != 0u) {\n    let coverage = accumulation[present.resolution.x * present.resolution.y + index].x;\n    alpha = select(clamp(coverage / stored.w, 0.0, 1.0), 0.0, stored.w <= 0.0);\n    // The radiance is premultiplied by the coverage; the tone curve applies to the colour itself.\n    color = select(color / alpha, vec3<f32>(0.0), alpha <= 0.0);\n  }\n\n  let centred = position.xy / vec2<f32>(present.resolution) - 0.5;\n  let falloff = 1.0 - present.vignette * dot(centred, centred) * 2.0;\n  var output = linearToSrgb(toneMap(color * max(falloff, 0.0)));\n\n  if (present.grain > 0.0) {\n    let noise = hash(index * 9781u + present.frameIndex * 6151u) - 0.5;\n    output = clamp(output + noise * present.grain * 0.1, vec3<f32>(0.0), vec3<f32>(1.0));\n  }\n\n  return vec4<f32>(output * alpha, alpha);\n}\n";
+export declare const PRESENT_WGSL = "\nstruct Present {\n  resolution: vec2<u32>,\n  exposure: f32,\n  toneMapping: u32,\n  vignette: f32,\n  grain: f32,\n  frameIndex: u32,\n  // A transparent background: the canvas gets the coverage as alpha, premultiplied as it is configured.\n  transparent: u32,\n  // Whether the colour comes from the denoiser's output rather than straight from the accumulation.\n  denoised: u32,\n  // How much of AgX's Punchy look goes over its base curve.\n  contrast: f32,\n};\n\n@group(0) @binding(0) var<uniform> present: Present;\n@group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> denoised: array<vec4<f32>>;\n\n@vertex\nfn vertexMain(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {\n  // One oversized triangle covers the viewport with no vertex buffer.\n  let x = f32(index / 2u) * 4.0 - 1.0;\n  let y = f32(index & 1u) * 4.0 - 1.0;\n\n  return vec4<f32>(x, y, 0.0, 1.0);\n}\n\nfn toneMapAces(color: vec3<f32>) -> vec3<f32> {\n  let toAces = mat3x3<f32>(\n    vec3<f32>(0.59719, 0.076, 0.0284),\n    vec3<f32>(0.35458, 0.90834, 0.13383),\n    vec3<f32>(0.04823, 0.01566, 0.83777));\n  let fromAces = mat3x3<f32>(\n    vec3<f32>(1.60475, -0.10208, -0.00327),\n    vec3<f32>(-0.53108, 1.10813, -0.07276),\n    vec3<f32>(-0.07367, -0.00605, 1.07602));\n  let v = toAces * (color / 0.6);\n\n  return fromAces * ((v * (v + 0.0245786) - 0.000090537) / (v * (0.983729 * v + 0.432951) + 0.238081));\n}\n\nfn toneMapAgx(color: vec3<f32>) -> vec3<f32> {\n  let toAgx = mat3x3<f32>(\n    vec3<f32>(0.6274, 0.0691, 0.0164),\n    vec3<f32>(0.3293, 0.9195, 0.088),\n    vec3<f32>(0.0433, 0.0113, 0.8956));\n  let inset = mat3x3<f32>(\n    vec3<f32>(0.856627153315983, 0.137318972929847, 0.11189821299995),\n    vec3<f32>(0.0951212405381588, 0.761241990602591, 0.0767994186031903),\n    vec3<f32>(0.0482516061458583, 0.101439036467562, 0.811302368396859));\n  let outset = mat3x3<f32>(\n    vec3<f32>(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),\n    vec3<f32>(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),\n    vec3<f32>(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405));\n  let fromAgx = mat3x3<f32>(\n    vec3<f32>(1.6605, -0.1246, -0.0182),\n    vec3<f32>(-0.5876, 1.1329, -0.1006),\n    vec3<f32>(-0.0728, -0.0083, 1.1187));\n  let logged = inset * (toAgx * color);\n  let x = clamp((log2(max(logged, vec3<f32>(1e-10))) + 12.47393) / 16.499999, vec3<f32>(0.0), vec3<f32>(1.0));\n  let base = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))\n    - 6.868 * pow(x, vec3<f32>(3.0)) + 0.4298 * x * x + 0.1191 * x - 0.00232;\n  // A look in the spirit of Blender's Punchy, a power of 1.35 and more saturation, but pivoted on middle grey: Punchy\n  // raises the power around zero, which takes middle grey from half the display down to a third and darkens the whole\n  // image. Here the highlights rise and the shadows fall while grey, which the automatic exposure aims at, stands.\n  let pivot = 0.49673;\n  let contrasted = pivot * pow(max(base, vec3<f32>(0.0)) / pivot, vec3<f32>(1.35));\n  let luma = dot(contrasted, vec3<f32>(0.2126, 0.7152, 0.0722));\n  let punchy = luma + 1.2 * (contrasted - luma);\n  let curved = mix(base, punchy, clamp(present.contrast, 0.0, 1.0));\n\n  return fromAgx * pow(max(outset * curved, vec3<f32>(0.0)), vec3<f32>(2.2));\n}\n\nfn toneMapNeutral(color: vec3<f32>) -> vec3<f32> {\n  let low = min(color.r, min(color.g, color.b));\n  let offset = select(0.04, low - 6.25 * low * low, low < 0.08);\n  let shifted = color - offset;\n  let peak = max(shifted.r, max(shifted.g, shifted.b));\n\n  if (peak < 0.76) {\n    return shifted;\n  }\n\n  let newPeak = 1.0 - 0.24 * 0.24 / (peak + 0.24 - 0.76);\n  let g = 1.0 - 1.0 / (0.15 * (peak - newPeak) + 1.0);\n\n  return shifted * (newPeak / peak) * (1.0 - g) + newPeak * g;\n}\n\nfn toneMap(color: vec3<f32>) -> vec3<f32> {\n  let exposed = max(color * present.exposure, vec3<f32>(0.0));\n  var mapped = exposed;\n\n  if (present.toneMapping == 0u) {\n    mapped = toneMapAces(exposed);\n  } else if (present.toneMapping == 1u) {\n    mapped = toneMapAgx(exposed);\n  } else if (present.toneMapping == 2u) {\n    mapped = toneMapNeutral(exposed);\n  }\n\n  return clamp(mapped, vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\nfn linearToSrgb(color: vec3<f32>) -> vec3<f32> {\n  let low = color * 12.92;\n  let high = 1.055 * pow(max(color, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;\n\n  return select(high, low, color <= vec3<f32>(0.0031308));\n}\n\nfn hash(value: u32) -> f32 {\n  var state = value * 747796405u + 2891336453u;\n  state = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n\n  return f32((state >> 22u) ^ state) * 2.3283064365386963e-10;\n}\n\n@fragment\nfn fragmentMain(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {\n  let pixel = vec2<u32>(position.xy);\n  let index = pixel.y * present.resolution.x + pixel.x;\n  let stored = accumulation[index];\n\n  // Nothing has been traced into this pixel yet: it stays see-through, so whatever is under the canvas shows.\n  if (stored.w <= 0.0) {\n    return vec4<f32>(0.0);\n  }\n\n  var color = select(stored.rgb / stored.w, vec3<f32>(0.0), stored.w <= 0.0);\n\n  if (present.denoised != 0u) {\n    color = denoised[index].rgb;\n  }\n  var alpha = 1.0;\n\n  if (present.transparent != 0u) {\n    let coverage = accumulation[present.resolution.x * present.resolution.y + index].x;\n    alpha = select(clamp(coverage / stored.w, 0.0, 1.0), 0.0, stored.w <= 0.0);\n    // The radiance is premultiplied by the coverage; the tone curve applies to the colour itself.\n    color = select(color / alpha, vec3<f32>(0.0), alpha <= 0.0);\n  }\n\n  let centred = position.xy / vec2<f32>(present.resolution) - 0.5;\n  let falloff = 1.0 - present.vignette * dot(centred, centred) * 2.0;\n  var output = linearToSrgb(toneMap(color * max(falloff, 0.0)));\n\n  if (present.grain > 0.0) {\n    let noise = hash(index * 9781u + present.frameIndex * 6151u) - 0.5;\n    output = clamp(output + noise * present.grain * 0.1, vec3<f32>(0.0), vec3<f32>(1.0));\n  }\n\n  return vec4<f32>(output * alpha, alpha);\n}\n";
 //# sourceMappingURL=present.wgsl.d.ts.map

package/dist/wgsl/present.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"present.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/present.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,YAAY,63KAmJxB,CAAC"}
+{"version":3,"file":"present.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/present.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,YAAY,ulMA6JxB,CAAC"}

package/dist/wgsl/present.wgsl.js

@@ -15,6 +15,8 @@ struct Present {
   transparent: u32,
   // Whether the colour comes from the denoiser's output rather than straight from the accumulation.
   denoised: u32,
+  // How much of AgX's Punchy look goes over its base curve.
+  contrast: f32,
 };
 
 @group(0) @binding(0) var<uniform> present: Present;
@@ -63,8 +65,16 @@ fn toneMapAgx(color: vec3<f32>) -> vec3<f32> {
     vec3<f32>(-0.0728, -0.0083, 1.1187));
   let logged = inset * (toAgx * color);
   let x = clamp((log2(max(logged, vec3<f32>(1e-10))) + 12.47393) / 16.499999, vec3<f32>(0.0), vec3<f32>(1.0));
-  let curved = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))
+  let base = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))
     - 6.868 * pow(x, vec3<f32>(3.0)) + 0.4298 * x * x + 0.1191 * x - 0.00232;
+  // A look in the spirit of Blender's Punchy, a power of 1.35 and more saturation, but pivoted on middle grey: Punchy
+  // raises the power around zero, which takes middle grey from half the display down to a third and darkens the whole
+  // image. Here the highlights rise and the shadows fall while grey, which the automatic exposure aims at, stands.
+  let pivot = 0.49673;
+  let contrasted = pivot * pow(max(base, vec3<f32>(0.0)) / pivot, vec3<f32>(1.35));
+  let luma = dot(contrasted, vec3<f32>(0.2126, 0.7152, 0.0722));
+  let punchy = luma + 1.2 * (contrasted - luma);
+  let curved = mix(base, punchy, clamp(present.contrast, 0.0, 1.0));
 
   return fromAgx * pow(max(outset * curved, vec3<f32>(0.0)), vec3<f32>(2.2));
 }

package/dist/wgsl/present.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"present.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/present.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJtC,CAAC"}
+{"version":3,"file":"present.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/present.wgsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6JtC,CAAC"}

package/dist/wgsl/random.wgsl.d.ts

@@ -5,5 +5,5 @@
  * random numbers. Only the sample index, the pixel and a dimension counter feed the generator, so a pixel draws the same
  * numbers whichever dispatch happens to cover it and the image does not depend on the tiling.
  */
-export declare const RANDOM_WGSL = "\nfn pcgHash(value: u32) -> u32 {\n  let state = value * 747796405u + 2891336453u;\n  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n\n  return (word >> 22u) ^ word;\n}\n\nstruct PathSampler {\n  seed: u32,\n  index: u32,\n  dimension: u32,\n};\n\nfn makeSampler(pixel: vec2<u32>, index: u32) -> PathSampler {\n  var rng: PathSampler;\n  rng.seed = pcgHash(pixel.x * 1973u + pixel.y * 9277u + 1u);\n  rng.index = index;\n  rng.dimension = 0u;\n\n  return rng;\n}\n\n/**\n * The Laine-Karras hash, which permutes the high bits in a way that nests: what Owen scrambling asks for. Every\n * multiplier has to be even, or a bit stops depending on itself and the map is no longer a permutation.\n */\nfn laineKarras(value: u32, seed: u32) -> u32 {\n  var x = value + seed;\n  x = x ^ (x * 0x6c50b47cu);\n  x = x ^ (x * 0xb82f1e52u);\n  x = x ^ (x * 0xc7afe784u);\n  x = x ^ (x * 0x8d22f6e6u);\n\n  return x;\n}\n\nfn nestedScramble(value: u32, seed: u32) -> u32 {\n  return reverseBits(laineKarras(reverseBits(value), seed));\n}\n\n/**\n * The first two Sobol dimensions, as fixed point fractions. The second is the index times Pascal's triangle mod 2,\n * which is linear in the bits of the index, so it is read one byte at a time from the tables texturePack.ts writes\n * instead of folded in one bit at a time: four reads where the scrambled index made it thirty two steps.\n */\nfn sobol2(index: u32) -> vec2<u32> {\n  let second = textures[SOBOL_TABLE + (index & 0xffu)]\n    ^ textures[SOBOL_TABLE + 256u + ((index >> 8u) & 0xffu)]\n    ^ textures[SOBOL_TABLE + 512u + ((index >> 16u) & 0xffu)]\n    ^ textures[SOBOL_TABLE + 768u + (index >> 24u)];\n\n  return vec2<u32>(reverseBits(index), second);\n}\n\nfn toUnit(value: u32) -> f32 {\n  return min(f32(value) * 2.3283064365386963e-10, 0.99999994);\n}\n\n/**\n * The next pair of dimensions, in [0, 1). The sample index is shuffled per pair as well, which pads the two dimensional\n * sequence out to as many dimensions as a path needs without correlating them.\n */\nfn sample2D(rng: ptr<function, PathSampler>) -> vec2<f32> {\n  let pair = (*rng).seed + (*rng).dimension * 2654435761u;\n  (*rng).dimension = (*rng).dimension + 1u;\n\n  let shuffled = nestedScramble((*rng).index, pcgHash(pair));\n  let point = sobol2(shuffled);\n\n  return vec2<f32>(\n    toUnit(nestedScramble(point.x, pcgHash(pair + 0x9e3779b9u))),\n    toUnit(nestedScramble(point.y, pcgHash(pair + 0x3c6ef372u))));\n}\n";
+export declare const RANDOM_WGSL = "\nfn pcgHash(value: u32) -> u32 {\n  let state = value * 747796405u + 2891336453u;\n  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n\n  return (word >> 22u) ^ word;\n}\n\nstruct PathSampler {\n  seed: u32,\n  index: u32,\n  dimension: u32,\n};\n\nfn makeSampler(pixel: vec2<u32>, index: u32) -> PathSampler {\n  var rng: PathSampler;\n  rng.seed = pcgHash(pixel.x * 1973u + pixel.y * 9277u + 1u);\n  rng.index = index;\n  rng.dimension = 0u;\n\n  return rng;\n}\n\n/**\n * The Laine-Karras hash, which permutes the high bits in a way that nests: what Owen scrambling asks for. Every\n * multiplier has to be even, or a bit stops depending on itself and the map is no longer a permutation.\n */\nfn laineKarras(value: u32, seed: u32) -> u32 {\n  var x = value + seed;\n  x = x ^ (x * 0x6c50b47cu);\n  x = x ^ (x * 0xb82f1e52u);\n  x = x ^ (x * 0xc7afe784u);\n  x = x ^ (x * 0x8d22f6e6u);\n\n  return x;\n}\n\nfn nestedScramble(value: u32, seed: u32) -> u32 {\n  return reverseBits(laineKarras(reverseBits(value), seed));\n}\n\n/**\n * The first two Sobol dimensions, as fixed point fractions. The second is the index times Pascal's triangle mod 2,\n * which is linear in the bits of the index, so it is read one byte at a time from the tables texturePack.ts writes\n * instead of folded in one bit at a time: four reads where the scrambled index made it thirty two steps.\n */\nfn sobol2(index: u32) -> vec2<u32> {\n  let second = textures[SOBOL_TABLE + (index & 0xffu)]\n    ^ textures[SOBOL_TABLE + 256u + ((index >> 8u) & 0xffu)]\n    ^ textures[SOBOL_TABLE + 512u + ((index >> 16u) & 0xffu)]\n    ^ textures[SOBOL_TABLE + 768u + (index >> 24u)];\n\n  return vec2<u32>(reverseBits(index), second);\n}\n\nfn toUnit(value: u32) -> f32 {\n  return min(f32(value) * 2.3283064365386963e-10, 0.99999994);\n}\n\n/**\n * The next pair of dimensions from a plain hash instead of the scrambled sequence: for the deep dimensions of a random\n * walk, where stratification buys nothing and the sequence's table reads and scrambles cost a step more than its ray.\n * It takes a dimension of its own, so the sequence's draws after it stay where they would have been.\n */\nfn hashSample2D(rng: ptr<function, PathSampler>) -> vec2<f32> {\n  let first = pcgHash((*rng).seed ^ pcgHash((*rng).index * 2654435761u + (*rng).dimension * 0x9e3779b9u));\n  (*rng).dimension = (*rng).dimension + 1u;\n\n  return vec2<f32>(toUnit(first), toUnit(pcgHash(first)));\n}\n\n/**\n * How many vertices of a path draw from the scrambled sequence. Its stratification shows on the camera ray and the\n * first bounces, where the light a pixel sees is decided; past them the light has been averaged by every bounce\n * before, and a plain hash gives numbers as good for a fraction of the cost.\n */\nconst SEQUENCE_DEPTH: u32 = 3u;\n\n/** The next pair of dimensions of a path's vertex: from the sequence while the path is shallow, from a hash after. */\nfn pathSample2D(rng: ptr<function, PathSampler>, deep: bool) -> vec2<f32> {\n  if (deep) {\n    return hashSample2D(rng);\n  }\n\n  return sample2D(rng);\n}\n\n/**\n * The next pair of dimensions, in [0, 1). The sample index is shuffled per pair as well, which pads the two dimensional\n * sequence out to as many dimensions as a path needs without correlating them.\n */\nfn sample2D(rng: ptr<function, PathSampler>) -> vec2<f32> {\n  let pair = (*rng).seed + (*rng).dimension * 2654435761u;\n  (*rng).dimension = (*rng).dimension + 1u;\n\n  let shuffled = nestedScramble((*rng).index, pcgHash(pair));\n  let point = sobol2(shuffled);\n\n  return vec2<f32>(\n    toUnit(nestedScramble(point.x, pcgHash(pair + 0x9e3779b9u))),\n    toUnit(nestedScramble(point.y, pcgHash(pair + 0x3c6ef372u))));\n}\n";
 //# sourceMappingURL=random.wgsl.d.ts.map

package/dist/wgsl/random.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/random.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,y6EA0EvB,CAAC"}
+{"version":3,"file":"random.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/random.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,mqHAsGvB,CAAC"}

package/dist/wgsl/random.wgsl.js

@@ -64,6 +64,34 @@ fn toUnit(value: u32) -> f32 {
   return min(f32(value) * 2.3283064365386963e-10, 0.99999994);
 }
 
+/**
+ * The next pair of dimensions from a plain hash instead of the scrambled sequence: for the deep dimensions of a random
+ * walk, where stratification buys nothing and the sequence's table reads and scrambles cost a step more than its ray.
+ * It takes a dimension of its own, so the sequence's draws after it stay where they would have been.
+ */
+fn hashSample2D(rng: ptr<function, PathSampler>) -> vec2<f32> {
+  let first = pcgHash((*rng).seed ^ pcgHash((*rng).index * 2654435761u + (*rng).dimension * 0x9e3779b9u));
+  (*rng).dimension = (*rng).dimension + 1u;
+
+  return vec2<f32>(toUnit(first), toUnit(pcgHash(first)));
+}
+
+/**
+ * How many vertices of a path draw from the scrambled sequence. Its stratification shows on the camera ray and the
+ * first bounces, where the light a pixel sees is decided; past them the light has been averaged by every bounce
+ * before, and a plain hash gives numbers as good for a fraction of the cost.
+ */
+const SEQUENCE_DEPTH: u32 = 3u;
+
+/** The next pair of dimensions of a path's vertex: from the sequence while the path is shallow, from a hash after. */
+fn pathSample2D(rng: ptr<function, PathSampler>, deep: bool) -> vec2<f32> {
+  if (deep) {
+    return hashSample2D(rng);
+  }
+
+  return sample2D(rng);
+}
+
 /**
  * The next pair of dimensions, in [0, 1). The sample index is shuffled per pair as well, which pads the two dimensional
  * sequence out to as many dimensions as a path needs without correlating them.

package/dist/wgsl/random.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"random.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/random.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0ErC,CAAC"}
+{"version":3,"file":"random.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/random.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGrC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinypoly/gpu-renderer",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "WebGPU path tracer for Three.js scenes: BVH traversal, progressive accumulation and tone mapping in WGSL compute shaders.",
   "keywords": [
     "three",
@@ -38,6 +38,7 @@
     "!dist/**/*.test.*",
     "src",
     "!src/**/*.test.ts",
+    "weights",
     "ARCHITECTURE.md"
   ],
   "engines": {
@@ -45,7 +46,8 @@
   },
   "dependencies": {
     "@tinypoly/cpu-renderer": "^0.3.1",
-    "naga-wasm": "30.2.0"
+    "naga-wasm": "30.2.0",
+    "oidn-webgpu": "0.6.0"
   },
   "peerDependencies": {
     "three": ">=0.185.0"

package/src/denoise.ts

@@ -1,10 +1,20 @@
 import { createShaderModule } from "./shaderModule.js";
 
+/**
+ * Which denoiser filters the image: `"oidn"`, Intel's Open Image Denoise, a neural network that keeps texture and fine
+ * detail, or `"svgf"`, the edge-aware wavelet filter, faster and with the controls below.
+ */
+export type DenoiserAlgorithm = "oidn" | "svgf";
+
 /** How the denoiser filters. Every field is optional where it is taken, and falls back to `DEFAULT_DENOISER`. */
 export interface DenoiserSettings {
+  /** The denoiser that runs; OIDN falls back to SVGF where its network cannot load. */
+  algorithm: DenoiserAlgorithm;
+  /** Where OIDN's weights are fetched from; empty takes the ones shipped with the package. */
+  oidnWeights: string;
   /** 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. */
+  /** SVGF only from here: 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
@@ -28,6 +38,8 @@ export interface DenoiserSettings {
 }
 
 export const DEFAULT_DENOISER: Readonly<DenoiserSettings> = Object.freeze({
+  algorithm: "oidn",
+  oidnWeights: "",
   strength: 1,
   passes: 3,
   edge: 2,
@@ -42,6 +54,8 @@ export function mergeDenoiser(base: DenoiserSettings, input: Partial<DenoiserSet
   const merged = { ...base, ...Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined)) };
 
   return {
+    algorithm: merged.algorithm === "svgf" ? "svgf" : "oidn",
+    oidnWeights: typeof merged.oidnWeights === "string" ? merged.oidnWeights : "",
     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),

package/src/device.ts

@@ -63,10 +63,19 @@ export async function requestRenderDevice(options: RenderDeviceOptions = {}): Pr
   if (!adapter)
     throw new Error("GPU renderer: no WebGPU adapter was available.");
 
+  // Half floats and the adapter's widest workgroups are what the OIDN denoiser runs fastest with; the path tracer
+  // needs neither, and an adapter without them still gets a device.
+  const requiredFeatures: GPUFeatureName[] = adapter.features.has("shader-f16") ? ["shader-f16"] : [];
+
   const device = await adapter.requestDevice({
+    requiredFeatures,
     requiredLimits: {
       maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
       maxBufferSize: adapter.limits.maxBufferSize,
+      maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,
+      maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,
+      maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,
+      maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,
     },
   });