@tinypoly/gpu-renderer 0.0.4 → 0.0.5

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,QAwMvB,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. */
@@ -118,14 +124,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 +186,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;2BAgBpB,WAAW;0BACZ,UAAU;6BACP,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EzC,CAAC"}

package/dist/wgsl/lights.wgsl.d.ts

@@ -6,5 +6,5 @@
  * The falloff, the spot cone and the rectangle's projected area follow `material.js` in the CPU renderer, so direct
  * light from an analytic light agrees with it.
  */
-export declare const LIGHTS_WGSL = "\nstruct LightSample {\n  // Unit vector from the shaded point towards the light.\n  direction: vec3<f32>,\n  // How far an occlusion ray may travel before it is past the light.\n  distance: f32,\n  // What the light delivers, already divided by the density it was sampled with.\n  value: vec3<f32>,\n  // Solid angle density of this direction, for the power heuristic. Zero when no bounce ray could find this light,\n  // which is every light that occupies no geometry, and then the light strategy keeps the whole contribution.\n  misPdf: f32,\n  valid: bool,\n  occlude: bool,\n  kind: u32,\n};\n\nfn noLight() -> LightSample {\n  var sample: LightSample;\n  sample.valid = false;\n\n  return sample;\n}\n\n/** The light whose cumulative probability range contains u. */\nfn lightByProbability(u: f32) -> Light {\n  var low = 0u;\n  var high = frame.lightCount - 1u;\n\n  loop {\n    if (low >= high) {\n      break;\n    }\n\n    let middle = (low + high) / 2u;\n\n    if (lights[middle].cdf > u) {\n      high = middle;\n    } else {\n      low = middle + 1u;\n    }\n  }\n\n  return lights[low];\n}\n\n/**\n * The area density with which direct sampling would have picked a point on this triangle, or zero if it never would.\n * Only the leading entries are emissive triangles, and they are in triangle order, so one binary search answers it.\n */\nfn lightPdfOfTriangle(triangle: u32) -> f32 {\n  var low = 0u;\n  var high = frame.areaLightCount;\n\n  loop {\n    if (low >= high) {\n      break;\n    }\n\n    let middle = (low + high) / 2u;\n    let candidate = lights[middle].triangle;\n\n    if (candidate == triangle) {\n      return lights[middle].pdf;\n    }\n\n    if (candidate < triangle) {\n      low = middle + 1u;\n    } else {\n      high = middle;\n    }\n  }\n\n  return 0.0;\n}\n\n/** The power heuristic: how much of a contribution the strategy that produced it keeps, against the other one. */\nfn misWeight(pdf: f32, other: f32) -> f32 {\n  let a = pdf * pdf;\n  let b = other * other;\n\n  return select(a / (a + b), 0.0, a + b <= 0.0);\n}\n\n/**\n * Spreads a direction over a cone, which is how a light of some apparent size softens its own shadow. The settings give\n * the angular diameter; a rasterizer would blur the shadow map by the same amount.\n */\nfn spreadDirection(direction: vec3<f32>, u: vec2<f32>) -> vec3<f32> {\n  if (frame.shadowSpread <= 0.0) {\n    return direction;\n  }\n\n  let basis = orthonormalBasis(direction);\n  let radius = sqrt(u.x) * frame.shadowSpread;\n  let angle = 2.0 * PI * u.y;\n\n  return normalize(direction + basis[0] * (radius * cos(angle)) + basis[1] * (radius * sin(angle)));\n}\n\n/** Three's getDistanceAttenuation: the inverse power law, cut off smoothly at the light's range. */\nfn distanceFalloff(light: Light, distance: f32) -> f32 {\n  var falloff = 1.0 / max(pow(distance, light.decay), 0.01);\n\n  if (light.cutoff > 0.0) {\n    let edge = clamp(1.0 - pow(distance / light.cutoff, 4.0), 0.0, 1.0);\n\n    falloff = falloff * edge * edge;\n  }\n\n  return falloff;\n}\n\n/** A point uniformly distributed over a rectangular light, and the axis it emits along. */\nfn rectanglePoint(light: Light, u: vec2<f32>) -> vec3<f32> {\n  return light.position + light.tangent * (u.x * 2.0 - 1.0) + light.bitangent * (u.y * 2.0 - 1.0);\n}\n\n/**\n * Where the light that pick selects arrives from, and how much of it. u places the point on a surface light or spreads a\n * point light's shadow, so the same two dimensions serve every kind.\n */\nfn sampleLight(position: vec3<f32>, pick: f32, u: vec2<f32>) -> LightSample {\n  if (frame.lightCount == 0u) {\n    return noLight();\n  }\n\n  return sampleLightEntry(lightByProbability(pick), position, u);\n}\n\n/** Three's spotLightMap: inside the projection's frustum the texture tints the light; outside it leaves it alone. */\nfn spotLightTint(light: Light, position: vec3<f32>) -> vec3<f32> {\n  if ((light.flags & LIGHT_HAS_MAP) == 0u) {\n    return vec3<f32>(1.0);\n  }\n\n  let at = light.triangle;\n  let map = textures[at];\n  let matrix = mat4x4<f32>(extraVec4(at + 1u), extraVec4(at + 5u), extraVec4(at + 9u), extraVec4(at + 13u));\n  let coordinate = matrix * vec4<f32>(position, 1.0);\n\n  if (coordinate.w <= 0.0) {\n    return vec3<f32>(1.0);\n  }\n\n  let projected = coordinate.xyz / coordinate.w;\n\n  if (any(projected <= vec3<f32>(0.0)) || any(projected >= vec3<f32>(1.0))) {\n    return vec3<f32>(1.0);\n  }\n\n  return sampleTextureRaw(map, projected.xy).rgb;\n}\n\nfn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSample {\n  var sample: LightSample;\n  sample.valid = true;\n  sample.kind = light.kind;\n  // Emissive geometry is always tested: a panel that lit the room through its own wall would not be a path tracer.\n  sample.occlude = light.kind == LIGHT_AREA\n    || ((light.flags & LIGHT_CASTS_SHADOW) != 0u && frame.shadowsEnabled != 0u);\n  sample.misPdf = 0.0;\n\n  if (light.kind == LIGHT_ENVIRONMENT) {\n    let drawn = sampleEnvironmentDirection(u);\n\n    if (drawn.pdf <= 0.0) {\n      return noLight();\n    }\n\n    let density = light.pdf * drawn.pdf;\n\n    sample.direction = drawn.direction;\n    sample.distance = 1e30;\n    sample.value = environmentRadiance(drawn.direction) / density;\n    // A bounce ray that escapes finds the same light, so the two strategies share it.\n    sample.misPdf = density;\n\n    return sample;\n  }\n\n  if (light.kind == LIGHT_DIRECTIONAL) {\n    sample.direction = spreadDirection(light.direction, u);\n    sample.distance = 1e30;\n    // The colour already carries the intensity, which for a directional light is the irradiance it delivers.\n    sample.value = light.color / light.pdf;\n\n    return sample;\n  }\n\n  if (light.kind == LIGHT_AREA || light.kind == LIGHT_RECT) {\n    let area = light.kind == LIGHT_AREA;\n    let bary = triangleBarycentric(u);\n    let point = select(rectanglePoint(light, u), trianglePointAt(light.triangle, bary), area);\n    let axis = select(normalize(cross(light.tangent, light.bitangent)), triangleNormal(light.triangle), area);\n    let offset = point - position;\n    let distanceSquared = dot(offset, offset);\n    let distance = sqrt(distanceSquared);\n\n    if (distance <= RAY_EPSILON) {\n      return noLight();\n    }\n\n    sample.direction = offset / distance;\n    // An emissive triangle radiates from both sides in this milestone; a rectangular light only from the side it faces.\n    let cosine = dot(axis, sample.direction);\n    let cosLight = select(max(cosine, 0.0), abs(cosine), area);\n\n    if (cosLight <= 1e-6) {\n      return noLight();\n    }\n\n    // Stop just short of the light so its own surface is not reported as the blocker.\n    sample.distance = distance * (1.0 - 1e-3);\n    let density = light.pdf * distanceSquared / cosLight;\n    // The emissive map is read at the very point that was sampled, so this agrees with what a bounce ray would find.\n    let emission = select(light.color, emissionAt(light.triangle, bary), area);\n\n    sample.value = emission / density;\n    // Only a triangle of the scene's geometry can also be found by a bounce ray, so only it needs the heuristic.\n    sample.misPdf = select(0.0, density, area);\n\n    return sample;\n  }\n\n  // A point or a spot light: both fall off with distance and are sampled at their centre.\n  let offset = light.position - position;\n  let distance = length(offset);\n\n  if (distance <= RAY_EPSILON) {\n    return noLight();\n  }\n\n  let towards = offset / distance;\n  var power = distanceFalloff(light, distance);\n\n  if (light.kind == LIGHT_SPOT) {\n    let cosine = dot(light.direction, towards);\n\n    if (light.innerCos <= light.outerCos) {\n      power = power * select(0.0, 1.0, cosine >= light.outerCos);\n    } else {\n      let t = clamp((cosine - light.outerCos) / (light.innerCos - light.outerCos), 0.0, 1.0);\n\n      power = power * t * t * (3.0 - 2.0 * t);\n    }\n\n    if (power <= 0.0) {\n      return noLight();\n    }\n  }\n\n  sample.direction = spreadDirection(towards, u);\n  sample.distance = distance;\n  sample.value = light.color * (power / light.pdf);\n\n  if (light.kind == LIGHT_SPOT) {\n    sample.value = sample.value * spotLightTint(light, position);\n  }\n\n  return sample;\n}\n\n/**\n * Whether a material stops every shadow ray that meets it, wherever: opaque, no cutout, no transmission, no clipping\n * or wireframe, no shader that might discard, and normal blending. Only then can the first triangle found decide.\n */\nfn blocksAll(m: u32) -> bool {\n  let flags = materials[m].flags;\n  let blending = materials[m].blending;\n\n  return (flags & (MATERIAL_TRANSPARENT | MATERIAL_ALPHA_HASH | MATERIAL_WIREFRAME)) == 0u\n    && materials[m].alphaTest <= 0.0\n    && materials[m].transmission <= 0.0\n    && materials[m].clipCount == 0u\n    && materials[m].program == NO_PROGRAM\n    && materials[m].kind != KIND_SHADOW\n    && (blending == BLEND_NORMAL || blending == BLEND_NONE);\n}\n\n/** How many surfaces a shadow ray may pass through before it gives up and calls the light blocked. */\nconst MAX_SHADOW_SKIPS: u32 = 8u;\n\n/** No material to skip: every blocker counts. */\nconst NO_MATERIAL: u32 = 0xffffffffu;\n\n/**\n * What a shadow ray keeps of a thin transmissive wall it meets: the share Three lets through, tinted by the base colour,\n * less what the interface reflects. It is the expectation of the straight crossing in sampleDielectric, so a light\n * seen through a window is found the same by both estimators. A volume bends the ray it lets through, so it blocks.\n */\nfn thinCrossing(triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> vec3<f32> {\n  let m = materialIndexOf(triangle);\n\n  if (materials[m].transmission <= 0.0) {\n    return vec3<f32>(0.0);\n  }\n\n  let metalness = materials[m].metalness * sampleMap(materials[m].metalnessMap, triangle, bary).b;\n  let transmission = transmissionAt(m, triangle, bary, metalness);\n  let thickness = materials[m].thickness * sampleMap(materials[m].thicknessMap, triangle, bary).g;\n\n  if (transmission <= 0.0 || thickness > 0.0) {\n    return vec3<f32>(0.0);\n  }\n\n  let albedo = materials[m].color.rgb * sampleMap(materials[m].map, triangle, bary).rgb;\n  let reflectance = fresnelDielectric(abs(dot(authoredNormal(triangle, bary), direction)), 1.0 / max(materials[m].ior, 1.0));\n\n  return albedo * (transmission * (1.0 - reflectance));\n}\n\n/** The colour a blended surface filters what is behind it by: its base colour, with the map and vertex colours. */\nfn blendColor(triangle: u32, bary: vec2<f32>) -> vec3<f32> {\n  let m = materialIndexOf(triangle);\n  var color = materials[m].color.rgb * sampleMap(materials[m].map, triangle, bary).rgb;\n\n  if ((materials[m].flags & MATERIAL_VERTEX_COLORS) != 0u) {\n    color = color * triangleColor(triangle, bary).rgb;\n  }\n\n  return color;\n}\n\n/**\n * How much of the light this sample came from reaches the shaded point. A surface that only partly covers its triangle\n * blocks the ray only that often, which is what makes a cutout leaf cast a cutout shadow; a thin transmissive wall\n * lets its own share through, tinted.\n */\nfn lightTransmittance(\n  position: vec3<f32>, chosen: LightSample, rng: ptr<function, PathSampler>, skipMaterial: u32) -> vec3<f32> {\n  if (!chosen.occlude) {\n    return vec3<f32>(1.0);\n  }\n\n  // Most blockers are plainly opaque, and for those any triangle on the way settles it: the search stops at the first\n  // one found instead of looking for the closest. Anything that lets light through goes the long way below.\n  let first = traceAny(position, chosen.direction, chosen.distance);\n\n  if (first == NO_HIT) {\n    return vec3<f32>(1.0);\n  }\n\n  let firstMaterial = materialIndexOf(first);\n\n  if (firstMaterial != skipMaterial && blocksAll(firstMaterial)) {\n    return vec3<f32>(0.0);\n  }\n\n  var origin = position;\n  var remaining = chosen.distance;\n  var through = vec3<f32>(1.0);\n\n  for (var skip = 0u; skip < MAX_SHADOW_SKIPS; skip = skip + 1u) {\n    let blocker = traceScene(origin, chosen.direction, remaining);\n\n    if (blocker.triangle == NO_HIT) {\n      return through;\n    }\n\n    let bary = vec2<f32>(blocker.u, blocker.v);\n    let m = materialIndexOf(blocker.triangle);\n    let blending = materials[m].blending;\n\n    // A shadow catcher catches shadows rather than casting them, and a surface that adds light blocks none.\n    if (m != skipMaterial && materials[m].kind != KIND_SHADOW && blending != BLEND_ADDITIVE) {\n      let coverage = coverageAt(blocker.triangle, bary, chosen.direction);\n\n      if (blending == BLEND_MULTIPLY) {\n        through = through * mix(vec3<f32>(1.0), blendColor(blocker.triangle, bary), coverage);\n      } else if (blending == BLEND_SUBTRACTIVE) {\n        through = through * (vec3<f32>(1.0) - blendColor(blocker.triangle, bary) * coverage);\n      } else if (coverage >= 1.0 || sample2D(rng).x < coverage) {\n        through = through * thinCrossing(blocker.triangle, bary, chosen.direction);\n      }\n\n      if (all(through <= vec3<f32>(0.0))) {\n        return vec3<f32>(0.0);\n      }\n    }\n\n    // The ray carries on from just past the surface it saw through.\n    origin = origin + chosen.direction * (blocker.distance + RAY_EPSILON);\n    remaining = remaining - blocker.distance - RAY_EPSILON;\n\n    if (remaining <= RAY_EPSILON) {\n      return through;\n    }\n  }\n\n  return vec3<f32>(0.0);\n}\n\n/**\n * How shadowed a point is, as Three's ShadowMaterial reads it: for every light that casts a shadow, whether something\n * stands between it and the point, the darkest of them winning as in the CPU renderer. A rectangular light casts no\n * shadow in Three, so it takes no part.\n */\nfn shadowMaskAt(position: vec3<f32>, rng: ptr<function, PathSampler>) -> f32 {\n  if (frame.shadowsEnabled == 0u) {\n    return 0.0;\n  }\n\n  var shadow = 0.0;\n\n  for (var i = frame.areaLightCount; i < frame.lightCount; i = i + 1u) {\n    let light = lights[i];\n\n    if (light.kind == LIGHT_ENVIRONMENT || light.kind == LIGHT_RECT || (light.flags & LIGHT_CASTS_SHADOW) == 0u) {\n      continue;\n    }\n\n    let chosen = sampleLightEntry(light, position, sample2D(rng));\n\n    if (!chosen.valid) {\n      continue;\n    }\n\n    let visible = luminanceOf(lightTransmittance(position, chosen, rng, NO_MATERIAL));\n\n    shadow = max(shadow, 1.0 - clamp(visible, 0.0, 1.0));\n  }\n\n  return shadow;\n}\n";
+export declare const LIGHTS_WGSL = "\nstruct LightSample {\n  // Unit vector from the shaded point towards the light.\n  direction: vec3<f32>,\n  // How far an occlusion ray may travel before it is past the light.\n  distance: f32,\n  // What the light delivers, already divided by the density it was sampled with.\n  value: vec3<f32>,\n  // Solid angle density of this direction, for the power heuristic. Zero when no bounce ray could find this light,\n  // which is every light that occupies no geometry, and then the light strategy keeps the whole contribution.\n  misPdf: f32,\n  valid: bool,\n  occlude: bool,\n  kind: u32,\n};\n\nfn noLight() -> LightSample {\n  var sample: LightSample;\n  sample.valid = false;\n\n  return sample;\n}\n\n/** The light whose cumulative probability range contains u. */\nfn lightByProbability(u: f32) -> Light {\n  var low = 0u;\n  var high = frame.lightCount - 1u;\n\n  loop {\n    if (low >= high) {\n      break;\n    }\n\n    let middle = (low + high) / 2u;\n\n    // The probabilities packed tight in the texture buffer: the same floats as lights[].cdf, a word apart.\n    if (extraFloat(frame.lightCdf + middle) > u) {\n      high = middle;\n    } else {\n      low = middle + 1u;\n    }\n  }\n\n  return lights[low];\n}\n\n/**\n * The area density with which direct sampling would have picked a point on this triangle, or zero if it never would.\n * Only the leading entries are emissive triangles, and they are in triangle order, so one binary search answers it.\n */\nfn lightPdfOfTriangle(triangle: u32) -> f32 {\n  var low = 0u;\n  var high = frame.areaLightCount;\n\n  loop {\n    if (low >= high) {\n      break;\n    }\n\n    let middle = (low + high) / 2u;\n    let candidate = textures[frame.lightTriangles + middle];\n\n    if (candidate == triangle) {\n      return lights[middle].pdf;\n    }\n\n    if (candidate < triangle) {\n      low = middle + 1u;\n    } else {\n      high = middle;\n    }\n  }\n\n  return 0.0;\n}\n\n/** The power heuristic: how much of a contribution the strategy that produced it keeps, against the other one. */\nfn misWeight(pdf: f32, other: f32) -> f32 {\n  let a = pdf * pdf;\n  let b = other * other;\n\n  return select(a / (a + b), 0.0, a + b <= 0.0);\n}\n\n/**\n * Spreads a direction over a cone, which is how a light of some apparent size softens its own shadow. The settings give\n * the angular diameter; a rasterizer would blur the shadow map by the same amount.\n */\nfn spreadDirection(direction: vec3<f32>, u: vec2<f32>) -> vec3<f32> {\n  if (frame.shadowSpread <= 0.0) {\n    return direction;\n  }\n\n  let basis = orthonormalBasis(direction);\n  let radius = sqrt(u.x) * frame.shadowSpread;\n  let angle = 2.0 * PI * u.y;\n\n  return normalize(direction + basis[0] * (radius * cos(angle)) + basis[1] * (radius * sin(angle)));\n}\n\n/** Three's getDistanceAttenuation: the inverse power law, cut off smoothly at the light's range. */\nfn distanceFalloff(light: Light, distance: f32) -> f32 {\n  var falloff = 1.0 / max(pow(distance, light.decay), 0.01);\n\n  if (light.cutoff > 0.0) {\n    let edge = clamp(1.0 - pow(distance / light.cutoff, 4.0), 0.0, 1.0);\n\n    falloff = falloff * edge * edge;\n  }\n\n  return falloff;\n}\n\n/** A point uniformly distributed over a rectangular light, and the axis it emits along. */\nfn rectanglePoint(light: Light, u: vec2<f32>) -> vec3<f32> {\n  return light.position + light.tangent * (u.x * 2.0 - 1.0) + light.bitangent * (u.y * 2.0 - 1.0);\n}\n\n/**\n * Where the light that pick selects arrives from, and how much of it. u places the point on a surface light or spreads a\n * point light's shadow, so the same two dimensions serve every kind.\n */\nfn sampleLight(position: vec3<f32>, pick: f32, u: vec2<f32>) -> LightSample {\n  if (frame.lightCount == 0u) {\n    return noLight();\n  }\n\n  return sampleLightEntry(lightByProbability(pick), position, u);\n}\n\n/** Three's spotLightMap: inside the projection's frustum the texture tints the light; outside it leaves it alone. */\nfn spotLightTint(light: Light, position: vec3<f32>) -> vec3<f32> {\n  if ((light.flags & LIGHT_HAS_MAP) == 0u) {\n    return vec3<f32>(1.0);\n  }\n\n  let at = light.triangle;\n  let map = textures[at];\n  let matrix = mat4x4<f32>(extraVec4(at + 1u), extraVec4(at + 5u), extraVec4(at + 9u), extraVec4(at + 13u));\n  let coordinate = matrix * vec4<f32>(position, 1.0);\n\n  if (coordinate.w <= 0.0) {\n    return vec3<f32>(1.0);\n  }\n\n  let projected = coordinate.xyz / coordinate.w;\n\n  if (any(projected <= vec3<f32>(0.0)) || any(projected >= vec3<f32>(1.0))) {\n    return vec3<f32>(1.0);\n  }\n\n  return sampleTextureRaw(map, projected.xy).rgb;\n}\n\nfn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSample {\n  var sample: LightSample;\n  sample.valid = true;\n  sample.kind = light.kind;\n  // Emissive geometry is always tested: a panel that lit the room through its own wall would not be a path tracer.\n  sample.occlude = light.kind == LIGHT_AREA\n    || ((light.flags & LIGHT_CASTS_SHADOW) != 0u && frame.shadowsEnabled != 0u);\n  sample.misPdf = 0.0;\n\n  if (light.kind == LIGHT_ENVIRONMENT) {\n    let drawn = sampleEnvironmentDirection(u);\n\n    if (drawn.pdf <= 0.0) {\n      return noLight();\n    }\n\n    let density = light.pdf * drawn.pdf;\n\n    sample.direction = drawn.direction;\n    sample.distance = 1e30;\n    sample.value = environmentRadiance(drawn.direction) / density;\n    // A bounce ray that escapes finds the same light, so the two strategies share it.\n    sample.misPdf = density;\n\n    return sample;\n  }\n\n  if (light.kind == LIGHT_DIRECTIONAL) {\n    sample.direction = spreadDirection(light.direction, u);\n    sample.distance = 1e30;\n    // The colour already carries the intensity, which for a directional light is the irradiance it delivers.\n    sample.value = light.color / light.pdf;\n\n    return sample;\n  }\n\n  if (light.kind == LIGHT_AREA || light.kind == LIGHT_RECT) {\n    let area = light.kind == LIGHT_AREA;\n    let bary = triangleBarycentric(u);\n    let point = select(rectanglePoint(light, u), trianglePointAt(light.triangle, bary), area);\n    let axis = select(normalize(cross(light.tangent, light.bitangent)), triangleNormal(light.triangle), area);\n    let offset = point - position;\n    let distanceSquared = dot(offset, offset);\n    let distance = sqrt(distanceSquared);\n\n    if (distance <= RAY_EPSILON) {\n      return noLight();\n    }\n\n    sample.direction = offset / distance;\n    // An emissive triangle radiates from both sides in this milestone; a rectangular light only from the side it faces.\n    let cosine = dot(axis, sample.direction);\n    let cosLight = select(max(cosine, 0.0), abs(cosine), area);\n\n    if (cosLight <= 1e-6) {\n      return noLight();\n    }\n\n    // Stop just short of the light so its own surface is not reported as the blocker.\n    sample.distance = distance * (1.0 - 1e-3);\n    let density = light.pdf * distanceSquared / cosLight;\n    // The emissive map is read at the very point that was sampled, so this agrees with what a bounce ray would find.\n    let emission = select(light.color, emissionAt(light.triangle, bary), area);\n\n    sample.value = emission / density;\n    // Only a triangle of the scene's geometry can also be found by a bounce ray, so only it needs the heuristic.\n    sample.misPdf = select(0.0, density, area);\n\n    return sample;\n  }\n\n  // A point or a spot light: both fall off with distance and are sampled at their centre.\n  let offset = light.position - position;\n  let distance = length(offset);\n\n  if (distance <= RAY_EPSILON) {\n    return noLight();\n  }\n\n  let towards = offset / distance;\n  var power = distanceFalloff(light, distance);\n\n  if (light.kind == LIGHT_SPOT) {\n    let cosine = dot(light.direction, towards);\n\n    if (light.innerCos <= light.outerCos) {\n      power = power * select(0.0, 1.0, cosine >= light.outerCos);\n    } else {\n      let t = clamp((cosine - light.outerCos) / (light.innerCos - light.outerCos), 0.0, 1.0);\n\n      power = power * t * t * (3.0 - 2.0 * t);\n    }\n\n    if (power <= 0.0) {\n      return noLight();\n    }\n  }\n\n  sample.direction = spreadDirection(towards, u);\n  sample.distance = distance;\n  sample.value = light.color * (power / light.pdf);\n\n  if (light.kind == LIGHT_SPOT) {\n    sample.value = sample.value * spotLightTint(light, position);\n  }\n\n  return sample;\n}\n\n/**\n * Whether a material stops every shadow ray that meets it, wherever: opaque, no cutout, no transmission, no clipping\n * or wireframe, no shader that might discard, and normal blending. Only then can the first triangle found decide.\n */\nfn blocksAll(m: u32) -> bool {\n  let flags = materials[m].flags;\n  let blending = materials[m].blending;\n\n  return (flags & (MATERIAL_TRANSPARENT | MATERIAL_ALPHA_HASH | MATERIAL_WIREFRAME)) == 0u\n    && materials[m].alphaTest <= 0.0\n    && materials[m].transmission <= 0.0\n    && materials[m].clipCount == 0u\n    && materials[m].program == NO_PROGRAM\n    && materials[m].kind != KIND_SHADOW\n    && (blending == BLEND_NORMAL || blending == BLEND_NONE);\n}\n\n/** How many surfaces a shadow ray may pass through before it gives up and calls the light blocked. */\nconst MAX_SHADOW_SKIPS: u32 = 8u;\n\n/** No material to skip: every blocker counts. */\nconst NO_MATERIAL: u32 = 0xffffffffu;\n\n/**\n * What a shadow ray keeps of a thin transmissive wall it meets: the share Three lets through, tinted by the base colour,\n * less what the interface reflects. It is the expectation of the straight crossing in sampleDielectric, so a light\n * seen through a window is found the same by both estimators. A volume bends the ray it lets through, so it blocks.\n */\nfn thinCrossing(triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> vec3<f32> {\n  let m = materialIndexOf(triangle);\n\n  if (materials[m].transmission <= 0.0) {\n    return vec3<f32>(0.0);\n  }\n\n  let metalness = materials[m].metalness * sampleMap(materials[m].metalnessMap, triangle, bary).b;\n  let transmission = transmissionAt(m, triangle, bary, metalness);\n  let thickness = materials[m].thickness * sampleMap(materials[m].thicknessMap, triangle, bary).g;\n\n  if (transmission <= 0.0 || thickness > 0.0) {\n    return vec3<f32>(0.0);\n  }\n\n  let albedo = materials[m].color.rgb * sampleMap(materials[m].map, triangle, bary).rgb;\n  let reflectance = fresnelDielectric(abs(dot(authoredNormal(triangle, bary), direction)), 1.0 / max(materials[m].ior, 1.0));\n\n  return albedo * (transmission * (1.0 - reflectance));\n}\n\n/** The colour a blended surface filters what is behind it by: its base colour, with the map and vertex colours. */\nfn blendColor(triangle: u32, bary: vec2<f32>) -> vec3<f32> {\n  let m = materialIndexOf(triangle);\n  var color = materials[m].color.rgb * sampleMap(materials[m].map, triangle, bary).rgb;\n\n  if ((materials[m].flags & MATERIAL_VERTEX_COLORS) != 0u) {\n    color = color * triangleColor(triangle, bary).rgb;\n  }\n\n  return color;\n}\n\n/**\n * How much of the light this sample came from reaches the shaded point. A surface that only partly covers its triangle\n * blocks the ray only that often, which is what makes a cutout leaf cast a cutout shadow; a thin transmissive wall\n * lets its own share through, tinted.\n */\nfn lightTransmittance(\n  position: vec3<f32>, chosen: LightSample, rng: ptr<function, PathSampler>, skipMaterial: u32) -> vec3<f32> {\n  if (!chosen.occlude) {\n    return vec3<f32>(1.0);\n  }\n\n  // Most blockers are plainly opaque, and for those any triangle on the way settles it: the search stops at the first\n  // one found instead of looking for the closest. Anything that lets light through goes the long way below.\n  let first = traceAny(position, chosen.direction, chosen.distance);\n\n  if (first == NO_HIT) {\n    return vec3<f32>(1.0);\n  }\n\n  let firstMaterial = materialIndexOf(first);\n\n  if (firstMaterial != skipMaterial && blocksAll(firstMaterial)) {\n    return vec3<f32>(0.0);\n  }\n\n  var origin = position;\n  var remaining = chosen.distance;\n  var through = vec3<f32>(1.0);\n\n  for (var skip = 0u; skip < MAX_SHADOW_SKIPS; skip = skip + 1u) {\n    let blocker = traceScene(origin, chosen.direction, remaining);\n\n    if (blocker.triangle == NO_HIT) {\n      return through;\n    }\n\n    let bary = vec2<f32>(blocker.u, blocker.v);\n    let m = materialIndexOf(blocker.triangle);\n    let blending = materials[m].blending;\n\n    // A shadow catcher catches shadows rather than casting them, and a surface that adds light blocks none.\n    if (m != skipMaterial && materials[m].kind != KIND_SHADOW && blending != BLEND_ADDITIVE) {\n      let coverage = coverageAt(blocker.triangle, bary, chosen.direction);\n\n      if (blending == BLEND_MULTIPLY) {\n        through = through * mix(vec3<f32>(1.0), blendColor(blocker.triangle, bary), coverage);\n      } else if (blending == BLEND_SUBTRACTIVE) {\n        through = through * (vec3<f32>(1.0) - blendColor(blocker.triangle, bary) * coverage);\n      } else if (coverage >= 1.0 || sample2D(rng).x < coverage) {\n        through = through * thinCrossing(blocker.triangle, bary, chosen.direction);\n      }\n\n      if (all(through <= vec3<f32>(0.0))) {\n        return vec3<f32>(0.0);\n      }\n    }\n\n    // The ray carries on from just past the surface it saw through.\n    origin = origin + chosen.direction * (blocker.distance + RAY_EPSILON);\n    remaining = remaining - blocker.distance - RAY_EPSILON;\n\n    if (remaining <= RAY_EPSILON) {\n      return through;\n    }\n  }\n\n  return vec3<f32>(0.0);\n}\n\n/**\n * How shadowed a point is, as Three's ShadowMaterial reads it: for every light that casts a shadow, whether something\n * stands between it and the point, the darkest of them winning as in the CPU renderer. A rectangular light casts no\n * shadow in Three, so it takes no part.\n */\nfn shadowMaskAt(position: vec3<f32>, rng: ptr<function, PathSampler>) -> f32 {\n  if (frame.shadowsEnabled == 0u) {\n    return 0.0;\n  }\n\n  var shadow = 0.0;\n\n  for (var i = frame.areaLightCount; i < frame.lightCount; i = i + 1u) {\n    let light = lights[i];\n\n    if (light.kind == LIGHT_ENVIRONMENT || light.kind == LIGHT_RECT || (light.flags & LIGHT_CASTS_SHADOW) == 0u) {\n      continue;\n    }\n\n    let chosen = sampleLightEntry(light, position, sample2D(rng));\n\n    if (!chosen.valid) {\n      continue;\n    }\n\n    let visible = luminanceOf(lightTransmittance(position, chosen, rng, NO_MATERIAL));\n\n    shadow = max(shadow, 1.0 - clamp(visible, 0.0, 1.0));\n  }\n\n  return shadow;\n}\n";
 //# sourceMappingURL=lights.wgsl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lights.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/lights.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,6pcAwavB,CAAC"}
+{"version":3,"file":"lights.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/lights.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,2ycAyavB,CAAC"}

package/dist/wgsl/lights.wgsl.js

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

package/dist/wgsl/lights.wgsl.js.map

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