@tinypoly/gpu-renderer 0.1.0 → 0.1.1

package/src/frameLayout.ts

@@ -35,6 +35,7 @@ export const FRAME_LAYOUT = layoutStruct("Frame", [
   { name: "localLightCount", type: "u32", doc: "How many leading lights sit in the scene, which the light tree picks." },
   { name: "localLightPick", type: "f32", doc: "The chance of picking one of them, the last one's cumulative probability." },
   { name: "lightTree", type: "u32", doc: "Where the light tree's nodes start in the texture buffer; zero picks by power alone." },
+  { name: "lightList", type: "u32", doc: "Where the lights of the tree's leaves are listed in the texture buffer." },
   { name: "lightLeaves", type: "u32", doc: "Where the leaf of every local light starts in the texture buffer." },
   { name: "clampIndirect", type: "f32", doc: "Maximum luminance one indirect contribution may add; zero leaves it." },
   { name: "shadowSpread", type: "f32", doc: "Tangent of half the angular diameter shadow rays spread over." },
@@ -63,6 +64,7 @@ export const FRAME_LAYOUT = layoutStruct("Frame", [
   { name: "lensDistortion", type: "f32", doc: "Radial distortion of the camera ray: positive is barrel, negative pincushion." },
   { name: "rouletteThreshold", type: "f32", doc: "Throughput under which a path may be ended by chance; zero never." },
   { name: "rouletteStart", type: "u32", doc: "Bounces every path takes before the roulette may end it." },
+  { name: "subsurfaceDepth", type: "u32", doc: "Bounces at which light still walks inside a material; deeper it reflects." },
   { name: "subsurfaceEnabled", type: "u32", doc: "Whether materials that scatter light inside do; 0 renders them opaque." },
   { name: "bevelEnabled", type: "u32", doc: "Whether materials with a bevel radius round their edges." },
   { name: "volumesEnabled", type: "u32", doc: "Whether volumes scatter light; 0 leaves their meshes out altogether." },

package/src/lightTree.ts

@@ -24,9 +24,23 @@ export interface TreeLight {
 /** Sixteen words a node: low and power, high and cos theta_o, axis and cos theta_e, then the links. */
 export const TREE_NODE_WORDS = 16;
 
-/** The high bit of a node's first link marks a leaf, whose low bits are its light's index. */
+/**
+ * The high bit of a node's first link marks a leaf, whose low bits say where its lights start in the list after the
+ * nodes; its second link says how many there are.
+ */
 export const TREE_LEAF = 0x80000000;
 
+/** Four words a light in a leaf's list: the light, its chance within the leaf, its area density, the running chance. */
+export const TREE_ENTRY_WORDS = 4;
+
+/**
+ * A leaf holds up to this many lights, when they are so close together, against how far the lights spread, that from
+ * any point the tree could not tell them apart: the triangles of one small lamp. Lights further apart each keep a leaf,
+ * which keeps every choice between them by distance and facing.
+ */
+const LEAF_LIGHTS = 8;
+const LEAF_EXTENT = 0.02;
+
 export const TREE_ROOT_PARENT = 0xffffffff;
 
 interface Cone {
@@ -77,18 +91,22 @@ interface Node {
   left: number;
   right: number;
   parent: number;
-  /** The light of a leaf, or -1. */
-  light: number;
-  density: number;
+  /** The lights of a leaf, or none. */
+  lights: number[];
 }
 
 /**
- * The tree over these lights, as words for the texture buffer, and the leaf each light ended in. Split at the median
- * of the longest axis of the centres, which needs no cost model and keeps the depth near log2 of the count.
+ * The tree over these lights, as words for the texture buffer, the leaf and list slot each light ended in, and where
+ * the list of the leaves' lights starts. Split at the middle of the longest axis of the centres, which needs no cost
+ * model and keeps a tight group, such as one lamp's triangles, on one side to share a leaf.
  */
-export function buildLightTree(lights: readonly TreeLight[]): { words: Uint32Array; leafOf: Uint32Array } {
+export function buildLightTree(lights: readonly TreeLight[]): {
+  words: Uint32Array; leafOf: Uint32Array; listAt: number;
+} {
   const nodes: Node[] = [];
-  const leafOf = new Uint32Array(lights.length);
+  // Two words a light: its leaf, and where it sits in the list of lights after the nodes.
+  const leafOf = new Uint32Array(lights.length * 2);
+  let span = 0;
 
   const build = (indices: number[], parent: number): number => {
     const index = nodes.length;
@@ -111,29 +129,35 @@ export function buildLightTree(lights: readonly TreeLight[]): { words: Uint32Arr
       cone = cone ? unionCone(cone, own) : own;
     }
 
-    const node: Node = { low, high, power, cone: cone as Cone, left: -1, right: -1, parent, light: -1, density: 1 };
+    const node: Node = { low, high, power, cone: cone as Cone, left: -1, right: -1, parent, lights: [] };
 
     nodes.push(node);
 
-    if (indices.length === 1) {
-      node.light = indices[0];
-      node.density = lights[indices[0]].density;
-      leafOf[indices[0]] = index;
+    const extent = Math.hypot(high[0] - low[0], high[1] - low[1], high[2] - low[2]);
+
+    if (index === 0) span = extent;
+
+    if (indices.length === 1 || (indices.length <= LEAF_LIGHTS && extent <= span * LEAF_EXTENT)) {
+      node.lights = indices;
 
       return index;
     }
 
     const centre = (i: number, k: number) => (lights[i].low[k] + lights[i].high[k]) / 2;
 
-    const extent = [0, 1, 2].map(k => {
+    const spread = [0, 1, 2].map(k => {
       const values = indices.map(i => centre(i, k));
 
       return Math.max(...values) - Math.min(...values);
     });
 
-    const axis = extent.indexOf(Math.max(...extent));
+    const axis = spread.indexOf(Math.max(...spread));
     const sorted = [...indices].sort((a, b) => centre(a, axis) - centre(b, axis));
-    const half = sorted.length >> 1;
+    // Split at the middle of the extent, which keeps a tight group of lights together on one side; the median only
+    // when that leaves a side empty, as lights all at one place do.
+    const middle = (centre(sorted[0], axis) + centre(sorted[sorted.length - 1], axis)) / 2;
+    const below = sorted.findIndex(i => centre(i, axis) > middle);
+    const half = below > 0 ? below : sorted.length >> 1;
 
     node.left = build(sorted.slice(0, half), index);
     node.right = build(sorted.slice(half), index);
@@ -143,8 +167,11 @@ export function buildLightTree(lights: readonly TreeLight[]): { words: Uint32Arr
 
   if (lights.length) build(lights.map((_, i) => i), TREE_ROOT_PARENT);
 
-  const words = new Uint32Array(nodes.length * TREE_NODE_WORDS);
+  const listAt = nodes.length * TREE_NODE_WORDS;
+  const entries = nodes.reduce((sum, node) => sum + node.lights.length, 0);
+  const words = new Uint32Array(listAt + entries * TREE_ENTRY_WORDS);
   const floats = new Float32Array(words.buffer);
+  let entry = 0;
 
   nodes.forEach((node, k) => {
     const at = k * TREE_NODE_WORDS;
@@ -157,9 +184,28 @@ export function buildLightTree(lights: readonly TreeLight[]): { words: Uint32Arr
     floats.set(node.cone.axis, at + 8);
     floats[at + 11] = Math.cos(Math.min(node.cone.thetaE, Math.PI));
 
-    if (node.light >= 0) {
-      words[at + 12] = (TREE_LEAF | node.light) >>> 0;
-      floats[at + 13] = node.density;
+    if (node.lights.length) {
+      words[at + 12] = (TREE_LEAF | entry) >>> 0;
+      words[at + 13] = node.lights.length;
+
+      // Within a leaf, by power: the lights are too close together for anything else to tell them apart.
+      const total = node.lights.reduce((sum, i) => sum + lights[i].power, 0);
+      let running = 0;
+
+      node.lights.forEach((light, j) => {
+        const chance = total > 0 ? lights[light].power / total : 1 / node.lights.length;
+        const slot = listAt + entry * TREE_ENTRY_WORDS;
+
+        running += chance;
+        words[slot] = light;
+        floats[slot + 1] = chance;
+        floats[slot + 2] = lights[light].density;
+        // The last closes the range exactly, so a unit sample never falls past it.
+        floats[slot + 3] = j === node.lights.length - 1 ? 1 : running;
+        leafOf[light * 2] = k;
+        leafOf[light * 2 + 1] = entry;
+        entry++;
+      });
     } else {
       words[at + 12] = node.left;
       words[at + 13] = node.right;
@@ -168,5 +214,5 @@ export function buildLightTree(lights: readonly TreeLight[]): { words: Uint32Arr
     words[at + 14] = node.parent >>> 0;
   });
 
-  return { words, leafOf };
+  return { words, leafOf, listAt };
 }

package/src/lights.ts

@@ -71,6 +71,8 @@ export interface PackedLights {
   /** Where the light tree's nodes start in the texture buffer, and the leaf of every local entry; zero for no tree. */
   treeAt: number;
   leavesAt: number;
+  /** Where the lights of the tree's leaves are listed in the texture buffer. */
+  listAt: number;
 }
 
 const luminance = (color: ArrayLike<number>) => 0.2126 * color[0] + 0.7152 * color[1] + 0.0722 * color[2];
@@ -425,12 +427,13 @@ export function packLights(
 
   for (let index = 0; index < areas.length; index++) extra.push(words[index * LIGHT_WORDS + 3]);
 
-  let treeAt = 0, leavesAt = 0;
+  let treeAt = 0, leavesAt = 0, listAt = 0;
 
   if (localCount > 0) {
     const tree = buildLightTree(candidates.slice(0, localCount).map(candidate => candidate.tree as TreeLight));
 
     treeAt = base + extra.length;
+    listAt = treeAt + tree.listAt;
     for (const word of tree.words) extra.push(word);
     leavesAt = base + extra.length;
     for (const leaf of tree.leafOf) extra.push(leaf);
@@ -441,6 +444,7 @@ export function packLights(
     localPick: localCount > 0 ? floats[(localCount - 1) * LIGHT_WORDS + 1] : 0,
     treeAt,
     leavesAt,
+    listAt,
     cdfAt,
     trianglesAt,
     entries,

package/src/renderer.ts

@@ -156,12 +156,30 @@ const SHOW_EVERY_MS = 16;
  */
 const BANDS_IN_FLIGHT = 2;
 
-/** Throughput under which Russian roulette may end a path, with the chance of carrying on equal to the throughput. */
-const ROULETTE_THRESHOLD = 0.2;
+/**
+ * Throughput under which Russian roulette may end a path, with the chance of carrying on equal to the throughput. One
+ * plays it on every path past the first bounces, as PBRT does: a path off a light wall carries on as long as it
+ * carries light, instead of seven bounces before the roulette ever looks at it. The mean stays exact.
+ */
+const ROULETTE_THRESHOLD = 1;
+
+/** How often the lens pass grades the canvas again while a frame traces without the denoiser. */
+const LENS_EVERY_MS = 100;
 
-/** How often the canvas takes a freshly denoised image while a frame traces. */
+/** How often the canvas takes a freshly denoised image while a frame traces, for an image of DENOISE_REFERENCE work. */
 const DENOISE_EVERY_MS = 200;
 
+/** The filtering of a 1080p image with three passes, which the interval above was set for. */
+const DENOISE_REFERENCE = 1920 * 1080 * 3;
+
+/**
+ * How long the canvas waits between denoised images: longer for a larger image or more passes, in proportion, so the
+ * filter takes the same share of the device from tracing whatever the size. The finished image is filtered regardless.
+ */
+export function denoiseInterval(width: number, height: number, passes: number): number {
+  return DENOISE_EVERY_MS * Math.max(1, width * height * Math.max(1, passes) / DENOISE_REFERENCE);
+}
+
 /** The most paths per pixel one dispatch takes, while no pixel can stop yet. */
 const BATCH_PATHS = 4;
 
@@ -274,6 +292,10 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
   private resolve: CaptureResolvePass | null = null;
   private denoisePass: DenoisePass | null = null;
   private lensPass: LensPass | null = null;
+  // What the lens pass last graded, and when: its input only changes when the denoiser runs or the accumulation grows.
+  private lensKey = "";
+  private lensAt = -Infinity;
+  private denoiseVersion = 0;
   private denoiserSettings: DenoiserSettings = { ...DEFAULT_DENOISER };
   // The size of the last frame that finished, which setDenoiser filters again; null while a frame traces.
   private finished: { width: number; height: number } | null = null;
@@ -716,7 +738,8 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
 
       // The canvas shows the denoised image, refreshed a few times a second while the bands refine underneath it:
       // filtering the whole image after every pass would cost a cheap scene as much as tracing it.
-      if (denoise && this.canvas && this.context && performance.now() - denoisedAt >= DENOISE_EVERY_MS) {
+      if (denoise && this.canvas && this.context && performance.now() - denoisedAt
+        >= denoiseInterval(width, height, this.denoiserSettings.passes)) {
         const encoder = gpu.device.createCommandEncoder();
 
         this.encodeDenoise(gpu, encoder, width, height);
@@ -1060,13 +1083,25 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
    * buffer of graded colour the display transform reads instead, or the input as it was.
    */
   private encodeLens(gpu: RenderDevice, encoder: GPUCommandEncoder, width: number, height: number,
-    denoised: GPUBuffer | null): GPUBuffer | null {
+    denoised: GPUBuffer | null, force = false): GPUBuffer | null {
     const effects = lensEffects(this.current);
 
     if (!effects) return denoised;
 
     this.lensPass ??= new LensPass(gpu.device);
 
+    // The canvas is drawn about once a display frame, but a denoised image only changes a few times a second: grading
+    // the same one again would take the device from tracing for nothing. Straight from the accumulation, the image
+    // grows with every pass, and is graded again at most every LENS_EVERY_MS.
+    const key = JSON.stringify([this.revision, width, height, denoised ? this.denoiseVersion : -1, effects]);
+    const now = performance.now();
+    const fresh = key === this.lensKey && (denoised !== null || now - this.lensAt < LENS_EVERY_MS);
+
+    if (!force && fresh && this.lensPass.output) return this.lensPass.output;
+
+    this.lensKey = key;
+    this.lensAt = now;
+
     return this.lensPass.encode(encoder, (this.accumulator as Accumulator).buffer, denoised, width, height, effects);
   }
 
@@ -1076,6 +1111,7 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
     this.denoisePass.encode(encoder, (this.accumulator as Accumulator).buffer, width, height, this.denoiserSettings,
       this.denoiseView);
     this.denoised = true;
+    this.denoiseVersion++;
   }
 
   private frameUniforms(
@@ -1145,6 +1181,7 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
       rouletteStart: Math.max(0, Math.round(this.current.globalIllumination.rouletteStart ?? 0)),
       lensDistortion: Number.isFinite(this.current.lens.distortion) ? this.current.lens.distortion : 0,
       subsurfaceEnabled: this.current.subsurface.enabled,
+      subsurfaceDepth: Math.max(0, Math.round(Number(this.current.subsurface.depth ?? 2))),
       bevelEnabled: this.current.bevel.enabled,
       volumesEnabled: this.current.volumes.enabled,
       cameraVolume: this.current.volumes.enabled
@@ -1163,6 +1200,7 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
       localLightPick: buffers?.localLightPick ?? 0,
       lightTree: this.current.globalIllumination.lightTree === false ? 0 : buffers?.lightTree ?? 0,
       lightLeaves: buffers?.lightLeaves ?? 0,
+      lightList: buffers?.lightList ?? 0,
       clampIndirect: Math.max(0, this.current.globalIllumination.clamp),
       // The setting is the angular diameter a light covers, in degrees, as it is for the CPU renderer's shadow blur.
       shadowSpread: shadows.enabled ? Math.tan(Math.max(0, shadows.softness) * Math.PI / 360) : 0,
@@ -1206,7 +1244,7 @@ export class GpuRenderer extends EventEmitter<GpuRendererEvents> {
 
     // The lens's effects are encoded on their own, ahead of the resolve, which reads the colour they leave.
     const encoder = gpu.device.createCommandEncoder({ label: "lens" });
-    const graded = this.encodeLens(gpu, encoder, width, height, denoised);
+    const graded = this.encodeLens(gpu, encoder, width, height, denoised, true);
 
     gpu.device.queue.submit([encoder.finish()]);
 

package/src/sceneUpload.ts

@@ -52,6 +52,7 @@ export interface SceneBuffers {
   localLightPick: number;
   lightTree: number;
   lightLeaves: number;
+  lightList: number;
   /** Radiance an ambient or hemisphere light adds, which no shadow ray can reach. */
   ambient: PackedLights["ambient"];
   /** Where the surrounding image and its distributions ended up, for the frame uniform. */
@@ -206,6 +207,7 @@ export function uploadScene(
     localLightPick: lights.localPick,
     lightTree: lights.treeAt,
     lightLeaves: lights.leavesAt,
+    lightList: lights.listAt,
     ambient: lights.ambient,
     environment: {
       texture: environment ? textures.indexOf.get(environment.texture.id) ?? NO_TEXTURE : NO_TEXTURE,

package/src/settings.ts

@@ -78,6 +78,12 @@ export interface GpuRenderSettings extends Omit<RenderSettings, "globalIlluminat
   subsurface: {
     /** Materials with `userData.cpuRenderer.subsurface` scatter light inside themselves. Off renders them opaque. */
     enabled: boolean;
+    /**
+     * Bounces at which light still walks inside such a material: past them it reflects off it as a diffuse surface of
+     * the same colour. Light that has already bounced that often hardly shows the difference, and every walk costs as
+     * much as many bounces.
+     */
+    depth: number;
   };
   /**
    * Aerial perspective: the air between the camera and what it sees, which fades distant things towards the colour of
@@ -123,13 +129,13 @@ export const DEFAULT_GPU_RENDER_SETTINGS: Readonly<GpuRenderSettings> = Object.f
     ...DEFAULT_RENDER_SETTINGS,
     // AgX rolls highlights off as film does, where ACES pushes saturated colours to the gamut's edge.
     toneMapping: "agx",
-    globalIllumination: { ...DEFAULT_RENDER_SETTINGS.globalIllumination, russianRoulette: true, rouletteStart: 3,
+    globalIllumination: { ...DEFAULT_RENDER_SETTINGS.globalIllumination, russianRoulette: true, rouletteStart: 1,
       lightTree: true },
     bloom: { enabled: true, intensity: 0.04, radius: 0.65 },
     glare: { enabled: true, intensity: 0.06, blades: 6, length: 0.25, rotation: 15 },
     lens: { chromaticAberration: 0.2, distortion: 0 },
     camera: { physicalExposure: false, iso: 100, shutterSpeed: 1 / 125, whiteBalance: 6500 },
-    subsurface: { enabled: true },
+    subsurface: { enabled: true, depth: 2 },
     atmosphere: { enabled: true, visibility: 20000, haze: 0.6, color: "" },
     volumes: { enabled: true },
     bevel: { enabled: true },

package/src/wgsl/lens.wgsl.ts

@@ -260,21 +260,6 @@ fn streakBilinear(position: vec2<f32>) -> vec3<f32> {
   return mix(mix(streakTexel(x, y), streakTexel(x + 1, y), b.z), mix(streakTexel(x, y + 1), streakTexel(x + 1, y + 1), b.z), b.w);
 }
 
-/** The folded halo at full resolution: a tent over its largest level, which is half the image's size. */
-fn tentHalo(position: vec2<f32>) -> vec3<f32> {
-  var sum = vec3<f32>(0.0);
-
-  for (var dy = -1; dy <= 1; dy = dy + 1) {
-    for (var dx = -1; dx <= 1; dx = dx + 1) {
-      let weight = f32((2 - abs(dx)) * (2 - abs(dy))) / 16.0;
-
-      sum = sum + upBilinear(lens.haloOffset, lens.haloSize, position + vec2<f32>(f32(dx), f32(dy)) * 0.5) * weight;
-    }
-  }
-
-  return sum;
-}
-
 /** The image as the lens delivers it: fringed towards the corners, with its halo, balanced for the camera's white. */
 @compute @workgroup_size(8, 8, 1)
 fn composite(@builtin(global_invocation_id) id: vec3<u32>) {
@@ -298,7 +283,8 @@ fn composite(@builtin(global_invocation_id) id: vec3<u32>) {
   }
 
   if (lens.intensity > 0.0) {
-    let halo = tentHalo(position * vec2<f32>(lens.haloSize) / size);
+    // The largest folded level is already a tent over the levels below it, so one bilinear read of it is smooth.
+    let halo = upBilinear(lens.haloOffset, lens.haloSize, position * vec2<f32>(lens.haloSize) / size);
 
     color = mix(color, halo, lens.intensity);
   }

package/src/wgsl/lights.wgsl.ts

@@ -55,6 +55,7 @@ fn lightByProbability(u: f32) -> Light {
 const TREE_NODE_WORDS: u32 = 16u;
 const TREE_LEAF: u32 = 0x80000000u;
 const TREE_ROOT_PARENT: u32 = 0xffffffffu;
+const TREE_ENTRY_WORDS: u32 = 4u;
 const NO_LIGHT: u32 = 0xffffffffu;
 
 /**
@@ -67,39 +68,58 @@ fn lightNodeImportance(node: u32, position: vec3<f32>, normal: vec3<f32>) -> f32
   let at = frame.lightTree + node * TREE_NODE_WORDS;
   let low = extraVec4(at);
   let high = extraVec4(at + 4u);
-  let cone = extraVec4(at + 8u);
 
   if (low.w <= 0.0) {
     return 0.0;
   }
 
   let centre = (low.xyz + high.xyz) * 0.5;
-  let radius = length(high.xyz - low.xyz) * 0.5;
+  let radius2 = dot(high.xyz - low.xyz, high.xyz - low.xyz) * 0.25;
   let offset = position - centre;
   let distance2 = dot(offset, offset);
 
-  if (distance2 <= radius * radius) {
-    return low.w / max(radius * radius, 1e-12);
+  if (distance2 <= radius2) {
+    return low.w / max(radius2, 1e-12);
   }
 
-  let distance = sqrt(distance2);
-  let spread = asin(clamp(radius / distance, 0.0, 1.0));
+  let away = offset * inverseSqrt(distance2);
+  // The angle the box takes from the point, as its sine and cosine: the angles below are widened by it without a
+  // single inverse trigonometric function, by the sum and difference formulas.
+  let sinU2 = radius2 / distance2;
+  let cosU = sqrt(1.0 - sinU2);
+  let sinU = sqrt(sinU2);
   var orientation = 1.0;
 
   // A cone of minus one is the whole sphere: such lights shine towards every point alike.
   if (high.w > -1.0) {
-    let theta = acos(clamp(dot(cone.xyz, offset / distance), -1.0, 1.0));
-    let past = max(0.0, theta - acos(high.w) - spread);
-
-    orientation = select(0.0, cos(past), past <= acos(clamp(cone.w, -1.0, 1.0)));
+    let cone = extraVec4(at + 8u);
+    let cosO = high.w;
+    let sinO = sqrt(max(0.0, 1.0 - cosO * cosO));
+    // The cone widened by the box: cos and sin of theta_o + theta_u, the whole sphere once that passes pi.
+    let cosWide = cosO * cosU - sinO * sinU;
+    let sinWide = sinO * cosU + cosO * sinU;
+    let cosTheta = dot(cone.xyz, away);
+
+    // cos(max(0, theta - theta_o - theta_u)), which is one while the point lies within the widened cone.
+    if (sinWide >= 0.0 && cosTheta < cosWide) {
+      let sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));
+      let cosPast = cosTheta * cosWide + sinTheta * sinWide;
+
+      orientation = select(0.0, cosPast, cosPast >= cone.w);
+    }
   }
 
   var facing = 1.0;
 
   if (any(normal != vec3<f32>(0.0))) {
-    let past = max(0.0, acos(clamp(dot(normal, -offset / distance), -1.0, 1.0)) - spread);
+    let cosN = -dot(normal, away);
+
+    // cos(max(0, theta_n - theta_u)), and nothing once that reaches a right angle.
+    if (cosN < cosU) {
+      let sinN = sqrt(max(0.0, 1.0 - cosN * cosN));
 
-    facing = select(0.0, cos(past), past < 0.5 * PI);
+      facing = max(0.0, cosN * cosU + sinN * sinU);
+    }
   }
 
   return low.w * orientation * facing / distance2;
@@ -130,11 +150,23 @@ fn sampleLightTree(position: vec3<f32>, normal: vec3<f32>, u: f32, pdf: ptr<func
     let at = frame.lightTree + node * TREE_NODE_WORDS;
     let first = textures[at + 12u];
 
+    // A leaf lists its lights, too close together to tell apart from here: one is picked by its share of the power.
     if ((first & TREE_LEAF) != 0u) {
-      *pdf = chance;
-      *density = extraFloat(at + 13u);
+      let start = frame.lightList + (first & ~TREE_LEAF) * TREE_ENTRY_WORDS;
+      let count = textures[at + 13u];
+      var slot = start + (count - 1u) * TREE_ENTRY_WORDS;
+
+      for (var j = 0u; j + 1u < count; j = j + 1u) {
+        if (x < extraFloat(start + j * TREE_ENTRY_WORDS + 3u)) {
+          slot = start + j * TREE_ENTRY_WORDS;
+          break;
+        }
+      }
+
+      *pdf = chance * extraFloat(slot + 1u);
+      *density = extraFloat(slot + 2u);
 
-      return first & ~TREE_LEAF;
+      return textures[slot];
     }
 
     let second = textures[at + 13u];
@@ -162,8 +194,10 @@ fn sampleLightTree(position: vec3<f32>, normal: vec3<f32>, u: f32, pdf: ptr<func
 
 /** The chance the tree would have picked the local light at this index from this point, walked up from its leaf. */
 fn lightTreePdf(index: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
-  var node = textures[frame.lightLeaves + index];
-  var chance = extraFloat(frame.lightTree + node * TREE_NODE_WORDS + 13u);
+  var node = textures[frame.lightLeaves + index * 2u];
+  let slot = frame.lightList + textures[frame.lightLeaves + index * 2u + 1u] * TREE_ENTRY_WORDS;
+  // Its share within its leaf, and the area density of a point on it.
+  var chance = extraFloat(slot + 1u) * extraFloat(slot + 2u);
 
   for (var depth = 0u; depth < 64u; depth = depth + 1u) {
     let parent = textures[frame.lightTree + node * TREE_NODE_WORDS + 14u];

package/src/wgsl/pathTrace.wgsl.ts

@@ -456,55 +456,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);
+    // 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;
+
+      throughput = throughput * sigma * walkAlbedo * travelled / max(density, 1e-20);
+      walkSteps = walkSteps + 1u;
+
+      let survival = max3(throughput);
+
+      if (walkSteps >= MAX_WALK || survival <= 0.0) {
+        break;
+      }
 
-    if (VOLUMES) {
-      mediumSample = sample2D(rng);
+      if (survival < 0.2) {
+        if (chance > survival) {
+          break;
+        }
+
+        throughput = throughput / survival;
+      }
+
+      origin = origin + direction * limit;
+      direction = sampleHenyeyGreenstein(direction, walkG, turn);
+      limit = walkDistance(throughput, sigma, next, &walkOdds);
+      continue;
     }
 
-    if (BEVEL) {
-      bevelSample = vec4<f32>(sample2D(rng), sample2D(rng));
+    // 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) {
-      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;
-
-        let survival = max3(throughput);
-
-        if (walkSteps >= MAX_WALK || survival <= 0.0) {
-          break;
-        }
-
-        if (survival < 0.2) {
-          if (coverage.x > survival) {
-            break;
-          }
-
-          throughput = throughput / survival;
-        }
-
-        origin = origin + direction * limit;
-        direction = sampleHenyeyGreenstein(direction, walkG, lobe);
-        limit = walkDistance(throughput, sigma, pick, &walkOdds);
-        continue;
-      }
-
       // The walk reached the surface before scattering again: the chance of travelling that far, per colour.
       let travelled = exp(-sigma * hit.distance);
 
@@ -631,8 +633,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);
     }
     }
 

package/src/wgsl/random.wgsl.ts

@@ -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.