@tinypoly/gpu-renderer 0.0.4 → 0.1.0

package/dist/wgsl/bsdf.wgsl.js

@@ -175,6 +175,12 @@ fn coatTransmittance(surface: Surface, view: vec3<f32>) -> f32 {
   return 1.0 - surface.clearcoat * schlick3(vec3<f32>(0.04), 1.0, nv).x;
 }
 
+/**
+ * A point inside a volume, where light scatters by the medium's phase function instead of off a surface. Only the
+ * integrator makes one: its normal faces back along the ray, its albedo is the medium's, its anisotropy the phase's.
+ */
+const KIND_VOLUME: u32 = 100u;
+
 /** How often each lobe is chosen, as (diffuse, specular, clearcoat): by how much of the reflection each accounts for. */
 fn lobeWeights(surface: Surface, view: vec3<f32>) -> vec3<f32> {
   let nv = max(dot(surface.normal, view), 1e-4);
@@ -192,7 +198,8 @@ fn lobeWeights(surface: Surface, view: vec3<f32>) -> vec3<f32> {
 
   let base = coatTransmittance(surface, view);
   // The floors keep every lobe reachable: the diffuse one also carries the sheen and the multiple scattering term.
-  let diffuse = (luminanceOf(surface.albedo * (1.0 - surface.metalness)) + max3(surface.sheenColor)) * base + 0.02;
+  let diffuse = (luminanceOf(surface.albedo * ((1.0 - surface.metalness) * (1.0 - surface.subsurface)))
+    + max3(surface.sheenColor)) * base + 0.02;
   let specular = luminanceOf(schlick3(surface.specularColor, surface.specularF90, nv)
     * (1.0 - surface.metalness) + surface.albedo * surface.metalness) * base + 0.05;
   let coat = select(0.0, (1.0 - base) + 0.02, surface.clearcoat > 0.0);
@@ -235,7 +242,8 @@ fn physicalValue(surface: Surface, view: vec3<f32>, light: vec3<f32>) -> vec3<f3
     let average = f0 + (vec3<f32>(1.0) - f0) * 0.047619;
     let multiple = essV * essL * average / (vec3<f32>(1.0) - emsV * emsL * average + 1e-7) * (emsV * emsL);
 
-    var diffuse = surface.albedo * (1.0 - surface.metalness) / PI;
+    // What scatters inside the material leaves it elsewhere, by the random walk, not from this point.
+    var diffuse = surface.albedo * ((1.0 - surface.metalness) * (1.0 - surface.subsurface)) / PI;
     var specular = single + multiple;
 
     // Three's sheen: its lobe sits on top and takes back the energy it reflects from the layers below.
@@ -344,6 +352,16 @@ fn evaluateBsdf(surface: Surface, view: vec3<f32>, light: vec3<f32>) -> BsdfEval
   let nl = dot(normal, light);
   let nv = dot(normal, view);
 
+  // In a medium every direction is open: the phase function stands for the lobes, and samples itself exactly.
+  if (surface.kind == KIND_VOLUME) {
+    let phase = henyeyGreenstein(dot(-view, light), surface.anisotropy);
+
+    result.value = surface.albedo * phase;
+    result.pdf = phase;
+
+    return result;
+  }
+
   if (nv <= 0.0) {
     return result;
   }
@@ -507,6 +525,15 @@ fn sampleBsdf(surface: Surface, view: vec3<f32>, lobe: f32, u: vec2<f32>) -> Bsd
   result.pdf = 0.0;
   result.diffuse = true;
 
+  if (surface.kind == KIND_VOLUME) {
+    result.direction = sampleHenyeyGreenstein(-view, surface.anisotropy, u);
+    result.weight = surface.albedo;
+    result.pdf = henyeyGreenstein(dot(-view, result.direction), surface.anisotropy);
+    result.valid = true;
+
+    return result;
+  }
+
   if (dot(normal, view) <= 0.0) {
     return result;
   }
@@ -574,6 +601,11 @@ fn diffuseValue(surface: Surface, view: vec3<f32>, light: vec3<f32>) -> vec3<f32
     return surface.albedo / PI * toonRamp(surface.gradientMap, nl);
   }
 
+  // Light scattered in a medium is all diffuse, as the denoiser sees it.
+  if (surface.kind == KIND_VOLUME) {
+    return surface.albedo * henyeyGreenstein(dot(-view, light), surface.anisotropy);
+  }
+
   if (nl <= 0.0) {
     return vec3<f32>(0.0);
   }
@@ -582,7 +614,7 @@ fn diffuseValue(surface: Surface, view: vec3<f32>, light: vec3<f32>) -> vec3<f32
     return surface.albedo / PI * nl;
   }
 
-  var diffuse = surface.albedo * (1.0 - surface.metalness) / PI;
+  var diffuse = surface.albedo * ((1.0 - surface.metalness) * (1.0 - surface.subsurface)) / PI;
 
   if (any(surface.sheenColor > vec3<f32>(0.0))) {
     diffuse = diffuse * (1.0 - max3(surface.sheenColor)

package/dist/wgsl/bsdf.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"bsdf.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/bsdf.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8lBnC,CAAC"}
+{"version":3,"file":"bsdf.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/bsdf.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8nBnC,CAAC"}

package/dist/wgsl/bvh.wgsl.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"bvh.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/bvh.wgsl.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAC7G,eAAO,MAAM,QAAQ,y4MAuNpB,CAAC"}
+{"version":3,"file":"bvh.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/bvh.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,+5RAwRpB,CAAC"}

package/dist/wgsl/bvh.wgsl.js

@@ -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/dist/wgsl/bvh.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"bvh.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/bvh.wgsl.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAC7G,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuNlC,CAAC"}
+{"version":3,"file":"bvh.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/bvh.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwRlC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"common.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/common.wgsl.ts"],"names":[],"mappings":"AAGA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QA4LvB,CAAC"}
+{"version":3,"file":"common.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/common.wgsl.ts"],"names":[],"mappings":"AAIA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QA4MvB,CAAC"}

package/dist/wgsl/common.wgsl.js

@@ -1,14 +1,20 @@
 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. */
@@ -92,6 +98,10 @@ const MATERIAL_OBJECT_NORMAL_MAP: u32 = 256u;
 const MATERIAL_PATCHED: u32 = 512u;
 const MATERIAL_ALPHA_HASH: u32 = 2048u;
 const MATERIAL_SPECULAR: u32 = 4096u;
+// The mesh only bounds a medium: its surface is invisible and the space inside scatters light.
+const MATERIAL_VOLUME: u32 = 8192u;
+// An unlit material of a fixed colour, which direct sampling aims at: it emits what it shows.
+const MATERIAL_UNLIT_LIGHT: u32 = 16384u;
 
 const KIND_STANDARD: u32 = ${MATERIAL_KIND.standard}u;
 const KIND_PHYSICAL: u32 = ${MATERIAL_KIND.physical}u;
@@ -118,14 +128,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>;
@@ -173,7 +190,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/dist/wgsl/common.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/common.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;EACpC,YAAY,CAAC,IAAI;;;;;;;;;;EAUjB,eAAe,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAiFO,aAAa,CAAC,QAAQ;6BACtB,aAAa,CAAC,QAAQ;4BACvB,aAAa,CAAC,OAAO;0BACvB,aAAa,CAAC,KAAK;yBACpB,aAAa,CAAC,IAAI;0BACjB,aAAa,CAAC,KAAK;2BAClB,aAAa,CAAC,MAAM;0BACrB,aAAa,CAAC,KAAK;2BAClB,aAAa,CAAC,MAAM;2BACpB,aAAa,CAAC,MAAM;2BACpB,aAAa,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsF9C,CAAC"}
+{"version":3,"file":"common.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/common.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE3E,6EAA6E;AAC7E,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;EACpC,YAAY,CAAC,IAAI;;;;;;;;;;;;;;;EAejB,eAAe,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAqFO,aAAa,CAAC,QAAQ;6BACtB,aAAa,CAAC,QAAQ;4BACvB,aAAa,CAAC,OAAO;0BACvB,aAAa,CAAC,KAAK;yBACpB,aAAa,CAAC,IAAI;0BACjB,aAAa,CAAC,KAAK;2BAClB,aAAa,CAAC,MAAM;0BACrB,aAAa,CAAC,KAAK;2BAClB,aAAa,CAAC,MAAM;2BACpB,aAAa,CAAC,MAAM;2BACpB,aAAa,CAAC,MAAM;;;;;;;;;;;;;;;;2BAgBpB,WAAW;0BACZ,UAAU;6BACP,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EzC,CAAC"}

package/dist/wgsl/lens.wgsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What the lens and the sensor do to the light before it is exposed: a halo around bright light (bloom), colour
+ * fringes towards the corners (lateral chromatic aberration) and the camera's white balance. Everything here is linear
+ * light, between the traced (or denoised) radiance and the presentation pass, which exposes and tone maps the result.
+ *
+ * The halo is built over a pyramid of half sized copies of the image, as Jimenez's "Next generation post processing in
+ * Call of Duty" (2014) builds it: each level is a 13 tap filter of the one above, and the levels are folded back from
+ * the smallest up with a tent filter, each mixed with the one below by the radius. The result is a wide, smooth spread
+ * whose weights sum to one, so a flat image is left as it was and the halo takes light from where it is rather than
+ * adding any: the image keeps its exact mean.
+ *
+ * The rays a bright light throws through the aperture are gathered the same way, from a quarter sized level: each
+ * texel takes the light of the texels behind it along every ray's direction, fading with the distance, with weights
+ * that again sum to one.
+ */
+export declare const LENS_WGSL = "\nstruct Lens {\n  resolution: vec2<u32>,\n  // Whether the colour comes from the denoiser's output rather than straight from the accumulation.\n  denoised: u32,\n  // Upsampling only: the level read from sits in the downsampled pyramid (the smallest one) instead of the folded one.\n  fromDown: u32,\n  sourceSize: vec2<u32>,\n  // Where the level read from starts in its pyramid; a size of the full resolution reads the image itself.\n  sourceOffset: u32,\n  // The first downsample reads the image itself, and averages its taps by luminance against fireflies.\n  fromImage: u32,\n  targetSize: vec2<u32>,\n  targetOffset: u32,\n  // Where the largest level of the folded pyramid starts, which the composite reads the halo from.\n  haloOffset: u32,\n  haloSize: vec2<u32>,\n  // How much of the light the halo takes, and how much each level takes from the one below it.\n  intensity: f32,\n  radius: f32,\n  // How far red and blue move apart at the corners, as a share of the distance from the centre.\n  aberration: f32,\n  // How much of the light the aperture's rays take, how many there are, and how far they reach in streak texels.\n  glare: f32,\n  rays: u32,\n  glareLength: f32,\n  // The white balance, a linear sRGB matrix, row by row.\n  white0: vec4<f32>,\n  white1: vec4<f32>,\n  white2: vec4<f32>,\n  // The size of the level the rays are gathered at, and the angle of the first ray, in radians.\n  streakSize: vec2<u32>,\n  glareAngle: f32,\n  pad0: f32,\n};\n\nconst PI: f32 = 3.14159265358979;\n\n/** Taps along each of the aperture's rays. */\nconst STREAK_TAPS: i32 = 24;\n\n@group(0) @binding(0) var<uniform> lens: Lens;\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@group(0) @binding(3) var<storage, read_write> down: array<vec4<f32>>;\n@group(0) @binding(4) var<storage, read_write> up: array<vec4<f32>>;\n@group(0) @binding(5) var<storage, read_write> graded: array<vec4<f32>>;\n@group(0) @binding(6) var<storage, read_write> streaked: array<vec4<f32>>;\n\n/** The image's own texel: its mean so far, or nothing where no path has landed yet. */\nfn imageTexel(x: i32, y: i32) -> vec3<f32> {\n  let size = vec2<i32>(lens.resolution);\n  let index = u32(clamp(y, 0, size.y - 1) * size.x + clamp(x, 0, size.x - 1));\n\n  if (lens.denoised != 0u) {\n    return denoised[index].rgb;\n  }\n\n  let stored = accumulation[index];\n\n  return select(stored.rgb / stored.w, vec3<f32>(0.0), stored.w <= 0.0);\n}\n\nfn downTexel(offset: u32, size: vec2<u32>, x: i32, y: i32) -> vec3<f32> {\n  let s = vec2<i32>(size);\n\n  return down[offset + u32(clamp(y, 0, s.y - 1) * s.x + clamp(x, 0, s.x - 1))].rgb;\n}\n\nfn upTexel(offset: u32, size: vec2<u32>, x: i32, y: i32) -> vec3<f32> {\n  let s = vec2<i32>(size);\n\n  return up[offset + u32(clamp(y, 0, s.y - 1) * s.x + clamp(x, 0, s.x - 1))].rgb;\n}\n\n/** Bilinear weights and the texel below and left of a point given in texels, edges clamped. */\nfn bilinearAt(position: vec2<f32>) -> vec4<f32> {\n  let p = position - 0.5;\n  let base = floor(p);\n\n  return vec4<f32>(base, p - base);\n}\n\nfn imageBilinear(position: vec2<f32>) -> vec3<f32> {\n  let b = bilinearAt(position);\n  let x = i32(b.x);\n  let y = i32(b.y);\n\n  return mix(\n    mix(imageTexel(x, y), imageTexel(x + 1, y), b.z),\n    mix(imageTexel(x, y + 1), imageTexel(x + 1, y + 1), b.z), b.w);\n}\n\nfn downBilinear(offset: u32, size: vec2<u32>, position: vec2<f32>) -> vec3<f32> {\n  let b = bilinearAt(position);\n  let x = i32(b.x);\n  let y = i32(b.y);\n\n  return mix(\n    mix(downTexel(offset, size, x, y), downTexel(offset, size, x + 1, y), b.z),\n    mix(downTexel(offset, size, x, y + 1), downTexel(offset, size, x + 1, y + 1), b.z), b.w);\n}\n\nfn upBilinear(offset: u32, size: vec2<u32>, position: vec2<f32>) -> vec3<f32> {\n  let b = bilinearAt(position);\n  let x = i32(b.x);\n  let y = i32(b.y);\n\n  return mix(\n    mix(upTexel(offset, size, x, y), upTexel(offset, size, x + 1, y), b.z),\n    mix(upTexel(offset, size, x, y + 1), upTexel(offset, size, x + 1, y + 1), b.z), b.w);\n}\n\n/** The level being filtered, read bilinearly at a point given in its own texels. */\nfn sourceAt(position: vec2<f32>) -> vec3<f32> {\n  if (lens.fromImage != 0u) {\n    return imageBilinear(position);\n  }\n\n  return downBilinear(lens.sourceOffset, lens.sourceSize, position);\n}\n\nfn luminance(color: vec3<f32>) -> f32 {\n  return dot(color, vec3<f32>(0.2126, 0.7152, 0.0722));\n}\n\n/** Karis' average: a group of taps weighed by one over one plus its luminance, so a lone firefly cannot flare. */\nfn karis(sum: vec3<f32>) -> vec4<f32> {\n  let weight = 1.0 / (1.0 + luminance(sum));\n\n  return vec4<f32>(sum * weight, weight);\n}\n\n/** One level of the pyramid from the one above it: Jimenez's 13 taps, four overlapping boxes and a centre one. */\n@compute @workgroup_size(8, 8, 1)\nfn downsample(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= lens.targetSize.x || id.y >= lens.targetSize.y) {\n    return;\n  }\n\n  let scale = vec2<f32>(lens.sourceSize) / vec2<f32>(lens.targetSize);\n  let centre = (vec2<f32>(id.xy) + 0.5) * scale;\n  let a = sourceAt(centre + vec2<f32>(-2.0, -2.0));\n  let b = sourceAt(centre + vec2<f32>(0.0, -2.0));\n  let c = sourceAt(centre + vec2<f32>(2.0, -2.0));\n  let d = sourceAt(centre + vec2<f32>(-2.0, 0.0));\n  let e = sourceAt(centre);\n  let f = sourceAt(centre + vec2<f32>(2.0, 0.0));\n  let g = sourceAt(centre + vec2<f32>(-2.0, 2.0));\n  let h = sourceAt(centre + vec2<f32>(0.0, 2.0));\n  let i = sourceAt(centre + vec2<f32>(2.0, 2.0));\n  let j = sourceAt(centre + vec2<f32>(-1.0, -1.0));\n  let k = sourceAt(centre + vec2<f32>(1.0, -1.0));\n  let l = sourceAt(centre + vec2<f32>(-1.0, 1.0));\n  let m = sourceAt(centre + vec2<f32>(1.0, 1.0));\n  var result: vec3<f32>;\n\n  if (lens.fromImage != 0u) {\n    let groups = karis((j + k + l + m) * 0.25) * 0.5\n      + karis((a + b + d + e) * 0.25) * 0.125\n      + karis((b + c + e + f) * 0.25) * 0.125\n      + karis((d + e + g + h) * 0.25) * 0.125\n      + karis((e + f + h + i) * 0.25) * 0.125;\n\n    result = groups.rgb / max(groups.w, 1e-6);\n  } else {\n    result = e * 0.125 + (a + c + g + i) * 0.03125 + (b + d + f + h) * 0.0625 + (j + k + l + m) * 0.125;\n  }\n\n  down[lens.targetOffset + id.y * lens.targetSize.x + id.x] = vec4<f32>(max(result, vec3<f32>(0.0)), 1.0);\n}\n\n/** A 3 x 3 tent over the smaller level, read at a point given in its texels. */\nfn tent(position: vec2<f32>) -> vec3<f32> {\n  var sum = vec3<f32>(0.0);\n\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let weight = f32((2 - abs(dx)) * (2 - abs(dy))) / 16.0;\n      let at = position + vec2<f32>(f32(dx), f32(dy));\n\n      if (lens.fromDown != 0u) {\n        sum = sum + downBilinear(lens.sourceOffset, lens.sourceSize, at) * weight;\n      } else {\n        sum = sum + upBilinear(lens.sourceOffset, lens.sourceSize, at) * weight;\n      }\n    }\n  }\n\n  return sum;\n}\n\n/** One level folded back: its own light, mixed by the radius with the wider spread of every level below it. */\n@compute @workgroup_size(8, 8, 1)\nfn upsample(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= lens.targetSize.x || id.y >= lens.targetSize.y) {\n    return;\n  }\n\n  let scale = vec2<f32>(lens.sourceSize) / vec2<f32>(lens.targetSize);\n  let wider = tent((vec2<f32>(id.xy) + 0.5) * scale);\n  let index = lens.targetOffset + id.y * lens.targetSize.x + id.x;\n\n  up[index] = vec4<f32>(mix(down[index].rgb, wider, lens.radius), 1.0);\n}\n\n/** The aperture's rays at one texel of the streak level: the light behind it along each ray, fading with distance. */\n@compute @workgroup_size(8, 8, 1)\nfn streaks(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= lens.targetSize.x || id.y >= lens.targetSize.y) {\n    return;\n  }\n\n  let centre = vec2<f32>(id.xy) + 0.5;\n  var sum = vec3<f32>(0.0);\n  var total = 0.0;\n\n  for (var r = 0u; r < lens.rays; r = r + 1u) {\n    let angle = lens.glareAngle + f32(r) * 2.0 * PI / f32(lens.rays);\n    let along = vec2<f32>(cos(angle), sin(angle));\n\n    for (var j = 1; j <= STREAK_TAPS; j = j + 1) {\n      let t = f32(j) / f32(STREAK_TAPS);\n      let weight = exp(-4.0 * t);\n\n      sum = sum + downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength)) * weight;\n      total = total + weight;\n    }\n  }\n\n  streaked[id.y * lens.targetSize.x + id.x] = vec4<f32>(sum / max(total, 1e-6), 1.0);\n}\n\nfn streakTexel(x: i32, y: i32) -> vec3<f32> {\n  let s = vec2<i32>(lens.streakSize);\n\n  return streaked[u32(clamp(y, 0, s.y - 1) * s.x + clamp(x, 0, s.x - 1))].rgb;\n}\n\nfn streakBilinear(position: vec2<f32>) -> vec3<f32> {\n  let b = bilinearAt(position);\n  let x = i32(b.x);\n  let y = i32(b.y);\n\n  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);\n}\n\n/** The folded halo at full resolution: a tent over its largest level, which is half the image's size. */\nfn tentHalo(position: vec2<f32>) -> vec3<f32> {\n  var sum = vec3<f32>(0.0);\n\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let weight = f32((2 - abs(dx)) * (2 - abs(dy))) / 16.0;\n\n      sum = sum + upBilinear(lens.haloOffset, lens.haloSize, position + vec2<f32>(f32(dx), f32(dy)) * 0.5) * weight;\n    }\n  }\n\n  return sum;\n}\n\n/** The image as the lens delivers it: fringed towards the corners, with its halo, balanced for the camera's white. */\n@compute @workgroup_size(8, 8, 1)\nfn composite(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= lens.resolution.x || id.y >= lens.resolution.y) {\n    return;\n  }\n\n  let size = vec2<f32>(lens.resolution);\n  let position = vec2<f32>(id.xy) + 0.5;\n  var color = imageTexel(i32(id.x), i32(id.y));\n\n  // Lateral chromatic aberration: each colour is magnified a little differently, red outwards and blue inwards,\n  // in proportion to the distance from the centre, which is how a lens's dispersion moves them.\n  if (lens.aberration > 0.0) {\n    let centre = size * 0.5;\n    let away = position - centre;\n    let red = imageBilinear(centre + away * (1.0 - lens.aberration));\n    let blue = imageBilinear(centre + away * (1.0 + lens.aberration));\n\n    color = vec3<f32>(red.r, color.g, blue.b);\n  }\n\n  if (lens.intensity > 0.0) {\n    let halo = tentHalo(position * vec2<f32>(lens.haloSize) / size);\n\n    color = mix(color, halo, lens.intensity);\n  }\n\n  if (lens.glare > 0.0) {\n    color = mix(color, streakBilinear(position * vec2<f32>(lens.streakSize) / size), lens.glare);\n  }\n\n  let balanced = vec3<f32>(dot(lens.white0.xyz, color), dot(lens.white1.xyz, color), dot(lens.white2.xyz, color));\n\n  graded[id.y * lens.resolution.x + id.x] = vec4<f32>(max(balanced, vec3<f32>(0.0)), 1.0);\n}\n";
+//# sourceMappingURL=lens.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lens.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/lens.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,suVA0SrB,CAAC"}