@tinypoly/gpu-renderer 0.0.4 → 0.0.5

package/src/sceneUpload.ts

@@ -11,7 +11,7 @@ export interface SceneByteLength {
   materials: number;
   /** Vertex normals, the UV sets, vertex colours and shader varyings, in one buffer. */
   attributes: number;
-  /** One material index per triangle and then the hierarchy's triangle order, in one buffer. */
+  /** One material index per triangle, then the hierarchy's triangle order and its inverse, in one buffer. */
   indices: number;
   nodes: number;
   lights: number;
@@ -37,11 +37,16 @@ export interface SceneBuffers {
   varyingOffset: number;
   hasColors: boolean;
   orderOffset: number;
+  /** Where each triangle's position in the leaf order starts inside `indices`. */
+  leafOffset: number;
   triangleCount: number;
   /** Everything the integrator can aim a shadow ray at. */
   lightCount: number;
   /** How many of those are emissive triangles, which lead the buffer. */
   areaLightCount: number;
+  /** Where the lights' cumulative probabilities and the emissive ones' triangles sit in `textures`. */
+  lightCdf: number;
+  lightTriangles: 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. */
@@ -76,7 +81,7 @@ export function sceneByteLength(
   const lengths = {
     positions: sized(geometry.positions.byteLength),
     attributes: sized(attributeBytes(geometry)),
-    indices: sized(geometry.materials.byteLength + bvh.order.byteLength),
+    indices: sized(geometry.materials.byteLength + 2 * bvh.order.byteLength),
     materials: sized(Math.max(1, geometry.materialCount) * MATERIAL_WORDS * 4),
     nodes: sized(bvh.nodes.byteLength),
     lights: sized(lights.entries.byteLength),
@@ -110,6 +115,25 @@ export function environmentPower(environment: PackedEnvironment | null): number
   return environment ? environment.total * 2 * Math.PI ** 2 / (environment.width * environment.height) : 0;
 }
 
+/**
+ * The positions in the hierarchy's leaf order, which is the order its traversal reads them in, so a leaf is one run of
+ * the buffer; and where each triangle went, for everything that reads a triangle by its own number.
+ */
+export function leafOrder(
+  positions: Float32Array, order: Uint32Array): { positions: Float32Array; inverse: Uint32Array } {
+  const ordered = new Float32Array(order.length * 9);
+  const inverse = new Uint32Array(order.length);
+
+  for (let at = 0; at < order.length; at++) {
+    const triangle = order[at];
+
+    ordered.set(positions.subarray(triangle * 9, triangle * 9 + 9), at * 9);
+    inverse[triangle] = at;
+  }
+
+  return { positions: ordered, inverse };
+}
+
 export function uploadScene(
   device: GPUDevice,
   geometry: PackedGeometry,
@@ -147,11 +171,12 @@ export function uploadScene(
 
   const colors = geometry.colors ?? new Float32Array(0);
   const varyings = geometry.varyings ?? new Float32Array(0);
+  const leaves = leafOrder(geometry.positions, bvh.order);
 
   const buffers = {
-    positions: write(geometry.positions, lengths.positions),
+    positions: write(leaves.positions, lengths.positions),
     attributes: join([geometry.normals, geometry.uvs, colors, varyings], lengths.attributes),
-    indices: join([geometry.materials, bvh.order], lengths.indices),
+    indices: join([geometry.materials, bvh.order, leaves.inverse], lengths.indices),
     materials: write(new Uint8Array(packMaterials(geometry)), lengths.materials),
     nodes: write(new Uint8Array(bvh.nodes), lengths.nodes),
     lights: write(new Uint8Array(lights.entries), lengths.lights),
@@ -166,9 +191,12 @@ export function uploadScene(
     varyingOffset: geometry.normals.length + geometry.uvs.length + colors.length,
     hasColors: colors.length > 0,
     orderOffset: geometry.materials.length,
+    leafOffset: geometry.materials.length + bvh.order.length,
     triangleCount: geometry.triangleCount,
     lightCount: lights.count,
     areaLightCount: lights.areaCount,
+    lightCdf: lights.cdfAt,
+    lightTriangles: lights.trianglesAt,
     ambient: lights.ambient,
     environment: {
       texture: environment ? textures.indexOf.get(environment.texture.id) ?? NO_TEXTURE : NO_TEXTURE,

package/src/texturePack.ts

@@ -10,10 +10,10 @@ import type { SerializedScene, SerializedTexture } from "./upstream.js";
  */
 export interface PackedTextures {
   /**
-   * One buffer for all of it: `TEXTURE_WORDS` words per texture first, as `TextureInfo` in `wgsl/common.wgsl.ts`, then
-   * the texels each entry points at. A byte texture takes one word per texel, RGBA in the low to high bytes; a float
-   * texture takes four, each the bits of one linear channel. Keeping the two in one binding is what holds the shader
-   * inside the eight storage buffers a WebGPU device has to offer.
+   * One buffer for all of it: the lookup tables first (see `TEXTURE_TABLE`), then `TEXTURE_WORDS` words per texture, as
+   * `TextureInfo` in `wgsl/common.wgsl.ts`, then the texels each entry points at. A byte texture takes one word per
+   * texel, RGBA in the low to high bytes; a float texture takes four, each the bits of one linear channel. Keeping them
+   * in one binding is what holds the shader inside the eight storage buffers a WebGPU device has to offer.
    */
   data: Uint32Array;
   count: number;
@@ -32,6 +32,62 @@ export interface TextureExtras {
 /** Sixteen words per entry: see `TextureInfo` in `wgsl/common.wgsl.ts`. */
 export const TEXTURE_WORDS = 16;
 
+/**
+ * Lookup tables that lead the buffer, at offsets the shader knows as constants: the second Sobol dimension one byte of
+ * the index at a time (four tables of 256), then the linear value of each of the 256 sRGB codes. Both replace work the
+ * kernel did on every read with the very numbers it computed, so nothing they feed changes.
+ */
+export const SOBOL_TABLE = 0;
+export const SRGB_TABLE = SOBOL_TABLE + 4 * 256;
+/** Where the texture table starts, after the lookup tables. */
+export const TEXTURE_TABLE = SRGB_TABLE + 256;
+
+/** The four byte tables of the Sobol sequence's second dimension, whose generator matrix is Pascal's triangle mod 2. */
+function sobolTables(): Uint32Array {
+  const directions: number[] = [];
+  let direction = 0x80000000;
+
+  for (let bit = 0; bit < 32; bit++) {
+    directions.push(direction >>> 0);
+    direction = (direction ^ (direction >>> 1)) >>> 0;
+  }
+
+  const tables = new Uint32Array(4 * 256);
+
+  for (let byte = 0; byte < 4; byte++) {
+    for (let value = 0; value < 256; value++) {
+      let xor = 0;
+
+      for (let bit = 0; bit < 8; bit++) if (value & (1 << bit)) xor ^= directions[byte * 8 + bit];
+
+      tables[byte * 256 + value] = xor >>> 0;
+    }
+  }
+
+  return tables;
+}
+
+/** The linear value of every sRGB code, worked out in double precision and rounded once. */
+function srgbTable(): Float32Array {
+  return Float32Array.from({ length: 256 }, (_, code) => {
+    const value = Math.fround(code / 255);
+
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+}
+
+const LOOKUP = (() => {
+  const words = new Uint32Array(TEXTURE_TABLE);
+
+  words.set(sobolTables(), SOBOL_TABLE);
+  words.set(new Uint32Array(srgbTable().buffer), SRGB_TABLE);
+
+  return words;
+})();
+
+/** Where a texture's entry starts in the buffer. */
+export const textureEntry = (index: number) => TEXTURE_TABLE + index * TEXTURE_WORDS;
+
 /** What a material's map index means when the material has no such map. */
 export const NO_TEXTURE = 0xffffffff;
 
@@ -49,6 +105,9 @@ const MIRRORED_REPEAT = 1002;
 /** How many UV sets the geometry carries, and so the highest channel a texture may ask for. */
 export const UV_CHANNELS = 2;
 
+/** Whether a word's first byte is its lowest, as it is on the device: then RGBA bytes are already RGBA words. */
+const LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+
 const texelCount = (texture: SerializedTexture) => Math.max(0, texture.width) * Math.max(0, texture.height);
 
 const isFloat = (texture: SerializedTexture) => texture.data instanceof Float32Array;
@@ -66,6 +125,7 @@ const isEncoded = (texture: SerializedTexture) => !isFloat(texture) && texture.c
 export interface TexturePlan {
   textures: SerializedTexture[];
   indexOf: Map<string, number>;
+  /** The lookup tables and the texture table together: where the texels begin. */
   tableWords: number;
   /** Where the words appended after the texels begin. */
   extraOffset: number;
@@ -80,7 +140,7 @@ export function planTextures(scene: SerializedScene, extraTextures: readonly Ser
     .filter(texture => !seen.has(texture.id) && !!seen.add(texture.id));
 
   const indexOf = new Map(textures.map((texture, index) => [texture.id, index]));
-  const tableWords = Math.max(1, textures.length) * TEXTURE_WORDS;
+  const tableWords = TEXTURE_TABLE + Math.max(1, textures.length) * TEXTURE_WORDS;
   const texelWords = textures.reduce((sum, texture) => sum + texelCount(texture) * (isFloat(texture) ? 4 : 1), 0);
 
   return { textures, indexOf, tableWords, extraOffset: tableWords + texelWords };
@@ -100,8 +160,10 @@ export function writeTextures(plan: TexturePlan, extraWords: Uint32Array): Packe
   const floats = new Float32Array(data.buffer);
   let texelAt = tableWords;
 
+  data.set(LOOKUP, 0);
+
   textures.forEach((texture, index) => {
-    const at = index * TEXTURE_WORDS;
+    const at = textureEntry(index);
     const texels = texelCount(texture);
     const float = isFloat(texture);
 
@@ -131,13 +193,18 @@ export function writeTextures(plan: TexturePlan, extraWords: Uint32Array): Packe
     } else {
       const source = texture.data as Uint8Array;
 
-      for (let texel = 0; texel < texels; texel++) {
-        const offset = texel * 4;
-
-        words[texelAt + texel] = source[offset]
-          | (source[offset + 1] << 8)
-          | (source[offset + 2] << 16)
-          | (source[offset + 3] << 24);
+      if (LITTLE_ENDIAN) {
+        // The bytes already sit in the order the words want them: copied whole, as the GPU reads them.
+        new Uint8Array(data.buffer, texelAt * 4, texels * 4).set(source.subarray(0, texels * 4));
+      } else {
+        for (let texel = 0; texel < texels; texel++) {
+          const offset = texel * 4;
+
+          words[texelAt + texel] = source[offset]
+            | (source[offset + 1] << 8)
+            | (source[offset + 2] << 16)
+            | (source[offset + 3] << 24);
+        }
       }
 
       texelAt += texels;

package/src/wgsl/bvh.wgsl.ts

@@ -1,17 +1,33 @@
-/** Triangle intersection and the iterative traversal, with the fixed stack the builder caps its depth to. */
+/**
+ * Triangle intersection and the iterative traversal, with the fixed stack the builder caps its depth to.
+ *
+ * The positions are uploaded in the hierarchy's leaf order, so a leaf is a run of triangles read straight off the
+ * buffer; the scene's own triangle number is looked up once, for the hit a trace returns. Every other reader goes the
+ * other way, from a triangle number to where its corners sit.
+ */
 export const BVH_WGSL = /* wgsl */ `
-fn triangleVertex(triangle: u32, corner: u32) -> vec3<f32> {
-  let base = triangle * 9u + corner * 3u;
+/** A corner of the triangle at this position of the hierarchy's leaf order. */
+fn leafVertex(at: u32, corner: u32) -> vec3<f32> {
+  let base = at * 9u + corner * 3u;
 
   return vec3<f32>(positions[base], positions[base + 1u], positions[base + 2u]);
 }
 
+/** Where a triangle of the scene sits in the leaf order the positions are stored in. */
+fn leafOf(triangle: u32) -> u32 {
+  return indices[frame.leafOffset + triangle];
+}
+
+fn triangleVertex(triangle: u32, corner: u32) -> vec3<f32> {
+  return leafVertex(leafOf(triangle), corner);
+}
+
 /** Moller-Trumbore. Returns the distance in x and the barycentric coordinates in yz, or a negative distance. */
-fn intersectTriangle(triangle: u32, origin: vec3<f32>, direction: vec3<f32>) -> vec3<f32> {
+fn intersectTriangle(at: u32, origin: vec3<f32>, direction: vec3<f32>) -> vec3<f32> {
   let miss = vec3<f32>(-1.0, 0.0, 0.0);
-  let a = triangleVertex(triangle, 0u);
-  let edge1 = triangleVertex(triangle, 1u) - a;
-  let edge2 = triangleVertex(triangle, 2u) - a;
+  let a = leafVertex(at, 0u);
+  let edge1 = leafVertex(at, 1u) - a;
+  let edge2 = leafVertex(at, 2u) - a;
   let p = cross(direction, edge2);
   let determinant = dot(edge1, p);
 
@@ -37,10 +53,10 @@ fn intersectTriangle(triangle: u32, origin: vec3<f32>, direction: vec3<f32>) ->
   return vec3<f32>(dot(edge2, q) * inverse, u, v);
 }
 
-/** Where a ray enters a node's box, or 1e30 when it misses it or only meets it past maxDistance. */
-fn enterBox(node: BvhNode, origin: vec3<f32>, inverse: vec3<f32>, maxDistance: f32) -> f32 {
-  let first = (node.low - origin) * inverse;
-  let second = (node.high - origin) * inverse;
+/** Where a ray enters a box, or 1e30 when it misses it or only meets it past maxDistance. */
+fn enterBox(low: vec3<f32>, high: vec3<f32>, origin: vec3<f32>, inverse: vec3<f32>, maxDistance: f32) -> f32 {
+  let first = (low - origin) * inverse;
+  let second = (high - origin) * inverse;
   let near = min(first, second);
   let far = max(first, second);
   let enter = max(max(near.x, near.y), max(near.z, 0.0));
@@ -49,27 +65,67 @@ fn enterBox(node: BvhNode, origin: vec3<f32>, inverse: vec3<f32>, maxDistance: f
   return select(1e30, enter, enter <= exit);
 }
 
-/** The triangles of a leaf, against the closest hit so far. */
-fn intersectLeaf(node: BvhNode, origin: vec3<f32>, direction: vec3<f32>, hit: ptr<function, Hit>) {
-  let start = u32(-1 - node.link);
+/** The triangles of a leaf, against the closest hit so far, which records where in the leaf order it found one. */
+fn intersectLeaf(link: i32, count: i32, origin: vec3<f32>, direction: vec3<f32>, hit: ptr<function, Hit>) {
+  let start = u32(-1 - link);
 
-  for (var i = 0u; i < u32(node.count); i = i + 1u) {
-    let triangle = orderedTriangle(start + i);
-    let result = intersectTriangle(triangle, origin, direction);
+  for (var i = 0u; i < u32(count); i = i + 1u) {
+    let result = intersectTriangle(start + i, origin, direction);
 
     if (result.x > RAY_EPSILON && result.x < (*hit).distance) {
       (*hit).distance = result.x;
-      (*hit).triangle = triangle;
+      (*hit).triangle = start + i;
       (*hit).u = result.y;
       (*hit).v = result.z;
     }
   }
 }
 
+/** Whether any triangle of a leaf lies along the ray before maxDistance: its position in the leaf order, or NO_HIT. */
+fn anyInLeaf(link: i32, count: i32, origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
+  let start = u32(-1 - link);
+
+  for (var i = 0u; i < u32(count); i = i + 1u) {
+    let result = intersectTriangle(start + i, origin, direction);
+
+    if (result.x > RAY_EPSILON && result.x < maxDistance) {
+      return start + i;
+    }
+  }
+
+  return NO_HIT;
+}
+
+/** No node to go to: the traversal takes the next entry off the stack. */
+const NO_NODE: u32 = 0xffffffffu;
+
+/**
+ * A stack entry that is a leaf rather than a node: the node holding it and which of its two children it is. A leaf
+ * has no node of its own, so this is how one waits its turn.
+ */
+const LEAF_ENTRY: u32 = 0x80000000u;
+
+fn leafEntry(parent: u32, right: bool) -> u32 {
+  return LEAF_ENTRY | (parent << 1u) | select(0u, 1u, right);
+}
+
+/** A waiting leaf's link and count, read back from the node that holds it. */
+fn waitingLeaf(entry: u32) -> vec2<i32> {
+  let parent = (entry & ~LEAF_ENTRY) >> 1u;
+
+  if ((entry & 1u) != 0u) {
+    return vec2<i32>(nodes[parent].rightLink, nodes[parent].rightCount);
+  }
+
+  return vec2<i32>(nodes[parent].leftLink, nodes[parent].leftCount);
+}
+
 /**
- * The closest hit along a ray. Both children of a node are tested together and the nearer one is visited first, so
- * the closest hit shrinks the search early and whole subtrees behind it are skipped; each node remembers where the ray
- * entered it, and one whose entry is already past the closest hit is dropped without being opened.
+ * The closest hit along a ray. A node holds both of its children's boxes, so one read tests them both. The nearer is
+ * visited first, so the closest hit shrinks the search early and whole subtrees behind it are skipped; the farther one
+ * waits on the stack with where the ray entered it, and is dropped unopened if something closer turned up meanwhile.
+ * A leaf is tested at the top of the next step, the one place the loop tests triangles, which keeps the kernel small.
+ * This visits what the binary tree's traversal visited, in the same order, so it finds the same hit.
  */
 fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit {
   var hit: Hit;
@@ -85,74 +141,81 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
   // A huge finite reciprocal instead of an infinite one: an axis aligned slab would otherwise produce 0 * inf.
   let signs = select(vec3<f32>(-1.0), vec3<f32>(1.0), direction >= vec3<f32>(0.0));
   let inverse = signs / max(abs(direction), vec3<f32>(1e-20));
-  let rootEnter = enterBox(nodes[0], origin, inverse, hit.distance);
-
-  if (rootEnter >= 1e30) {
-    return hit;
-  }
 
   var stack: array<u32, 32>;
   var enters: array<f32, 32>;
-  var depth = 1u;
-  stack[0] = 0u;
-  enters[0] = rootEnter;
+  var depth = 0u;
+  var current = 0u;
+  // A leaf to test before anything else: its link, and its triangle count, zero when there is none.
+  var leaf = vec2<i32>(0, 0);
 
   loop {
-    if (depth == 0u) {
-      break;
+    if (leaf.y > 0) {
+      intersectLeaf(leaf.x, leaf.y, origin, direction, &hit);
+      leaf.y = 0;
     }
 
-    depth = depth - 1u;
+    if (current == NO_NODE) {
+      if (depth == 0u) {
+        break;
+      }
 
-    // Something closer was found since this node was pushed.
-    if (enters[depth] > hit.distance) {
-      continue;
-    }
+      depth = depth - 1u;
 
-    let node = nodes[stack[depth]];
+      // Something closer was found since this was pushed.
+      if (enters[depth] > hit.distance) {
+        continue;
+      }
 
-    if (node.link < 0) {
-      intersectLeaf(node, origin, direction, &hit);
-      continue;
-    }
+      let entry = stack[depth];
 
-    let leftIndex = u32(node.link);
-    let rightIndex = u32(node.count);
-    let leftEnter = enterBox(nodes[leftIndex], origin, inverse, hit.distance);
-    let rightEnter = enterBox(nodes[rightIndex], origin, inverse, hit.distance);
-    let leftHit = leftEnter < 1e30;
-    let rightHit = rightEnter < 1e30;
+      if ((entry & LEAF_ENTRY) != 0u) {
+        leaf = waitingLeaf(entry);
+        continue;
+      }
 
-    // The builder caps its depth so both children always fit; the guard keeps a malformed tree inside the stack.
-    if (depth + 2u > 32u) {
-      continue;
+      current = entry;
     }
 
-    if (leftHit && rightHit) {
-      // The farther first, so the nearer comes off the stack next.
-      let leftNearer = leftEnter <= rightEnter;
-      stack[depth] = select(leftIndex, rightIndex, leftNearer);
-      enters[depth] = select(leftEnter, rightEnter, leftNearer);
-      stack[depth + 1u] = select(rightIndex, leftIndex, leftNearer);
-      enters[depth + 1u] = select(rightEnter, leftEnter, leftNearer);
-      depth = depth + 2u;
-    } else if (leftHit) {
-      stack[depth] = leftIndex;
-      enters[depth] = leftEnter;
-      depth = depth + 1u;
-    } else if (rightHit) {
-      stack[depth] = rightIndex;
-      enters[depth] = rightEnter;
+    let node = nodes[current];
+    let leftEnter = enterBox(node.leftLow, node.leftHigh, origin, inverse, hit.distance);
+    let rightEnter = enterBox(node.rightLow, node.rightHigh, origin, inverse, hit.distance);
+    let leftFirst = leftEnter <= rightEnter;
+    let nearLink = select(node.rightLink, node.leftLink, leftFirst);
+    let farEnter = select(leftEnter, rightEnter, leftFirst);
+    let farLink = select(node.leftLink, node.rightLink, leftFirst);
+    let parent = current;
+
+    current = NO_NODE;
+
+    // The nearer child: a miss means both missed.
+    if (min(leftEnter, rightEnter) < 1e30) {
+      if (nearLink < 0) {
+        leaf = vec2<i32>(nearLink, select(node.rightCount, node.leftCount, leftFirst));
+      } else {
+        current = u32(nearLink);
+      }
+    }
+
+    // The builder caps its depth so the far children always fit; the guard keeps a malformed tree inside the stack.
+    if (farEnter < 1e30 && depth < 32u) {
+      stack[depth] = select(u32(farLink), leafEntry(parent, leftFirst), farLink < 0);
+      enters[depth] = farEnter;
       depth = depth + 1u;
     }
   }
 
+  if (hit.triangle != NO_HIT) {
+    hit.triangle = orderedTriangle(hit.triangle);
+  }
+
   return hit;
 }
 
 /**
  * Whether anything at all lies along a ray before maxDistance, stopping at the first triangle it finds rather than the
- * closest: what a shadow ray asks when every surface it could meet blocks it. Returns that triangle, or NO_HIT.
+ * closest: what a shadow ray asks when every surface it could meet blocks it. Returns that triangle, or NO_HIT. The
+ * right child goes first and the left one waits, the order the binary tree's traversal took.
  */
 fn traceAny(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
   if (frame.triangleCount == 0u) {
@@ -162,52 +225,60 @@ fn traceAny(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
   let signs = select(vec3<f32>(-1.0), vec3<f32>(1.0), direction >= vec3<f32>(0.0));
   let inverse = signs / max(abs(direction), vec3<f32>(1e-20));
 
-  if (enterBox(nodes[0], origin, inverse, maxDistance) >= 1e30) {
-    return NO_HIT;
-  }
-
   var stack: array<u32, 32>;
-  var depth = 1u;
-  stack[0] = 0u;
+  var depth = 0u;
+  var current = 0u;
+  var leaf = vec2<i32>(0, 0);
 
   loop {
-    if (depth == 0u) {
-      break;
-    }
+    if (leaf.y > 0) {
+      let found = anyInLeaf(leaf.x, leaf.y, origin, direction, maxDistance);
 
-    depth = depth - 1u;
+      if (found != NO_HIT) {
+        return orderedTriangle(found);
+      }
 
-    let node = nodes[stack[depth]];
+      leaf.y = 0;
+    }
 
-    if (node.link < 0) {
-      let start = u32(-1 - node.link);
+    if (current == NO_NODE) {
+      if (depth == 0u) {
+        break;
+      }
+
+      depth = depth - 1u;
 
-      for (var i = 0u; i < u32(node.count); i = i + 1u) {
-        let triangle = orderedTriangle(start + i);
-        let result = intersectTriangle(triangle, origin, direction);
+      let entry = stack[depth];
 
-        if (result.x > RAY_EPSILON && result.x < maxDistance) {
-          return triangle;
-        }
+      if ((entry & LEAF_ENTRY) != 0u) {
+        leaf = waitingLeaf(entry);
+        continue;
       }
 
-      continue;
+      current = entry;
     }
 
-    let leftIndex = u32(node.link);
-    let rightIndex = u32(node.count);
+    let node = nodes[current];
+    let rightHit = enterBox(node.rightLow, node.rightHigh, origin, inverse, maxDistance) < 1e30;
+    let leftHit = enterBox(node.leftLow, node.leftHigh, origin, inverse, maxDistance) < 1e30;
+    let parent = current;
 
-    if (depth + 2u > 32u) {
-      continue;
-    }
+    current = NO_NODE;
 
-    if (enterBox(nodes[leftIndex], origin, inverse, maxDistance) < 1e30) {
-      stack[depth] = leftIndex;
-      depth = depth + 1u;
+    // The right child is taken now and the left one waits; with only one of them hit, that one is taken now.
+    let takeRight = rightHit;
+    let takenLink = select(node.leftLink, node.rightLink, takeRight);
+
+    if (rightHit || leftHit) {
+      if (takenLink < 0) {
+        leaf = vec2<i32>(takenLink, select(node.leftCount, node.rightCount, takeRight));
+      } else {
+        current = u32(takenLink);
+      }
     }
 
-    if (enterBox(nodes[rightIndex], origin, inverse, maxDistance) < 1e30) {
-      stack[depth] = rightIndex;
+    if (rightHit && leftHit && depth < 32u) {
+      stack[depth] = select(u32(node.leftLink), leafEntry(parent, false), node.leftLink < 0);
       depth = depth + 1u;
     }
   }

package/src/wgsl/common.wgsl.ts

@@ -1,15 +1,21 @@
 import { FRAME_LAYOUT } from "../frameLayout.js";
 import { MATERIAL_KIND, MATERIAL_LAYOUT } from "../materialLayout.js";
+import { SOBOL_TABLE, SRGB_TABLE, TEXTURE_TABLE } from "../texturePack.js";
 
 /** Bindings and structs shared by every stage of the path tracing module. */
 export const COMMON_WGSL = /* wgsl */ `
 ${FRAME_LAYOUT.wgsl}
-// Thirty two bytes: a corner and a link, twice. A leaf stores -1 - start in place of its left child.
+// Sixty four bytes: the boxes of a node's two children, each a corner and a link, then a corner and a count. A link of
+// zero or more is the child's own node; a leaf stores -1 - start in it, into the hierarchy's leaf order. See bvh.ts.
 struct BvhNode {
-  low: vec3<f32>,
-  link: i32,
-  high: vec3<f32>,
-  count: i32,
+  leftLow: vec3<f32>,
+  leftLink: i32,
+  leftHigh: vec3<f32>,
+  leftCount: i32,
+  rightLow: vec3<f32>,
+  rightLink: i32,
+  rightHigh: vec3<f32>,
+  rightCount: i32,
 };
 
 /** As materialLayout.ts packs it. A map index of NO_TEXTURE means the slot is empty. */
@@ -119,14 +125,21 @@ const BLEND_MULTIPLY: u32 = 4u;
 const NO_TEXTURE: u32 = 0xffffffffu;
 const NO_PROGRAM: u32 = 0xffffffffu;
 
+// The lookup tables that lead the texture buffer, and where its table of textures starts after them: see texturePack.ts.
+const SOBOL_TABLE: u32 = ${SOBOL_TABLE}u;
+const SRGB_TABLE: u32 = ${SRGB_TABLE}u;
+const TEXTURE_TABLE: u32 = ${TEXTURE_TABLE}u;
+
 // A WebGPU device only has to offer eight storage buffers per stage, so arrays of the same kind share one binding and
 // the uniform says where the second one starts. See sceneUpload.ts, which joins them.
 @group(0) @binding(0) var<uniform> frame: Frame;
+// Nine coordinates per triangle, in the hierarchy's leaf order: see leafOf in bvh.wgsl.ts.
 @group(0) @binding(1) var<storage, read> positions: array<f32>;
 // Normals, then the UV sets from frame.uvOffset, vertex colours from frame.colorOffset and shader varyings from
 // frame.varyingOffset.
 @group(0) @binding(2) var<storage, read> attributes: array<f32>;
-// One material index per triangle, then the hierarchy's triangle order from frame.orderOffset on.
+// One material index per triangle, then the hierarchy's triangle order from frame.orderOffset on (the triangle at each
+// position of the leaf order), then from frame.leafOffset on the other way (the position of each triangle).
 @group(0) @binding(3) var<storage, read> indices: array<u32>;
 @group(0) @binding(4) var<storage, read> materials: array<Material>;
 @group(0) @binding(5) var<storage, read> nodes: array<BvhNode>;
@@ -174,7 +187,7 @@ fn extraVec4(at: u32) -> vec4<f32> {
 
 /** One entry of the texture table, unpacked from the words it shares with the texels. */
 fn textureInfo(index: u32) -> TextureInfo {
-  let at = index * 16u;
+  let at = TEXTURE_TABLE + index * 16u;
   var info: TextureInfo;
 
   info.size = vec2<u32>(textures[at], textures[at + 1u]);

package/src/wgsl/lights.wgsl.ts

@@ -41,7 +41,8 @@ fn lightByProbability(u: f32) -> Light {
 
     let middle = (low + high) / 2u;
 
-    if (lights[middle].cdf > u) {
+    // The probabilities packed tight in the texture buffer: the same floats as lights[].cdf, a word apart.
+    if (extraFloat(frame.lightCdf + middle) > u) {
       high = middle;
     } else {
       low = middle + 1u;
@@ -65,7 +66,7 @@ fn lightPdfOfTriangle(triangle: u32) -> f32 {
     }
 
     let middle = (low + high) / 2u;
-    let candidate = lights[middle].triangle;
+    let candidate = textures[frame.lightTriangles + middle];
 
     if (candidate == triangle) {
       return lights[middle].pdf;