@tinypoly/gpu-renderer 0.2.4 → 0.3.0

package/dist/wgsl/bvh.wgsl.js

@@ -4,6 +4,10 @@
  * 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.
+ *
+ * With INSTANCES compiled in, a leaf with a count of -1 is an instance: the ray is taken into its object space and
+ * the traversal goes on in its prototype's hierarchy, with a marker on the stack that brings it back to world space.
+ * The distance along the ray is the same in both spaces, since the direction is transformed and not normalized.
  */
 export const BVH_WGSL = /* wgsl */ `
 /** A corner of the triangle at this position of the hierarchy's leaf order. */
@@ -18,8 +22,37 @@ fn leafOf(triangle: u32) -> u32 {
   return indices[frame.leafOffset + triangle];
 }
 
+/** A corner of a triangle a hit named, in world space. */
 fn triangleVertex(triangle: u32, corner: u32) -> vec3<f32> {
-  return leafVertex(leafOf(triangle), corner);
+  let instance = instanceOf(triangle);
+  let p = leafVertex(leafOf(storedTriangle(triangle, instance)), corner);
+
+  if (instance != NO_INSTANCE) {
+    return instancePoint(instance, p);
+  }
+
+  return p;
+}
+
+/** The stack entry that leaves an instance: the traversal goes back to world space. */
+const RETURN_ENTRY: u32 = 0xffffffffu;
+
+/** A huge finite reciprocal instead of an infinite one: an axis aligned slab would otherwise produce 0 * inf. */
+fn rayInverse(direction: vec3<f32>) -> vec3<f32> {
+  let signs = select(vec3<f32>(-1.0), vec3<f32>(1.0), direction >= vec3<f32>(0.0));
+
+  return signs / max(abs(direction), vec3<f32>(1e-20));
+}
+
+/** The number a hit goes by, from where it sits in the leaf order and the instance it was found in. */
+fn namedTriangle(at: u32, instance: u32) -> u32 {
+  let stored = orderedTriangle(at);
+
+  if (INSTANCES && instance != NO_INSTANCE) {
+    return instanceWord(instance, 26u) + stored - instanceWord(instance, 25u);
+  }
+
+  return stored;
 }
 
 /** Moller-Trumbore. Returns the distance in x and the barycentric coordinates in yz, or a negative distance. */
@@ -127,7 +160,7 @@ fn waitingLeaf(entry: u32) -> vec2<i32> {
  * 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 {
+fn traceScene(worldOrigin: vec3<f32>, worldDirection: vec3<f32>, maxDistance: f32) -> Hit {
   var hit: Hit;
   hit.distance = maxDistance;
   hit.triangle = NO_HIT;
@@ -138,12 +171,15 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
     return 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));
+  var origin = worldOrigin;
+  var direction = worldDirection;
+  var inverse = rayInverse(direction);
+  // The instance the traversal is inside, and the one the closest hit so far was found in.
+  var instance = NO_INSTANCE;
+  var hitInstance = NO_INSTANCE;
 
-  var stack: array<u32, 32>;
-  var enters: array<f32, 32>;
+  var stack: array<u32, BVH_STACK>;
+  var enters: array<f32, BVH_STACK>;
   var depth = 0u;
   var current = 0u;
   // A leaf to test before anything else: its link, and its triangle count, zero when there is none.
@@ -151,10 +187,32 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
 
   loop {
     if (leaf.y > 0) {
+      let before = hit.distance;
+
       intersectLeaf(leaf.x, leaf.y, origin, direction, &hit);
+
+      if (INSTANCES && hit.distance < before) {
+        hitInstance = instance;
+      }
+
       leaf.y = 0;
     }
 
+    if (INSTANCES && leaf.y < 0) {
+      leaf.y = 0;
+
+      if (depth < BVH_STACK) {
+        instance = u32(-1 - leaf.x);
+        stack[depth] = RETURN_ENTRY;
+        enters[depth] = -1.0;
+        depth = depth + 1u;
+        origin = instanceToObject(instance, worldOrigin, 1.0);
+        direction = instanceToObject(instance, worldDirection, 0.0);
+        inverse = rayInverse(direction);
+        current = instanceWord(instance, 24u);
+      }
+    }
+
     if (current == NO_NODE) {
       if (depth == 0u) {
         break;
@@ -169,6 +227,14 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
 
       let entry = stack[depth];
 
+      if (INSTANCES && entry == RETURN_ENTRY) {
+        instance = NO_INSTANCE;
+        origin = worldOrigin;
+        direction = worldDirection;
+        inverse = rayInverse(direction);
+        continue;
+      }
+
       if ((entry & LEAF_ENTRY) != 0u) {
         leaf = waitingLeaf(entry);
         continue;
@@ -198,7 +264,7 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
     }
 
     // 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) {
+    if (farEnter < 1e30 && depth < BVH_STACK) {
       stack[depth] = select(u32(farLink), leafEntry(parent, leftFirst), farLink < 0);
       enters[depth] = farEnter;
       depth = depth + 1u;
@@ -206,7 +272,7 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> Hit
   }
 
   if (hit.triangle != NO_HIT) {
-    hit.triangle = orderedTriangle(hit.triangle);
+    hit.triangle = namedTriangle(hit.triangle, hitInstance);
   }
 
   return hit;
@@ -217,15 +283,17 @@ fn traceScene(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> 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 {
+fn traceAny(worldOrigin: vec3<f32>, worldDirection: vec3<f32>, maxDistance: f32) -> u32 {
   if (frame.triangleCount == 0u) {
     return NO_HIT;
   }
 
-  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));
+  var origin = worldOrigin;
+  var direction = worldDirection;
+  var inverse = rayInverse(direction);
+  var instance = NO_INSTANCE;
 
-  var stack: array<u32, 32>;
+  var stack: array<u32, BVH_STACK>;
   var depth = 0u;
   var current = 0u;
   var leaf = vec2<i32>(0, 0);
@@ -235,12 +303,26 @@ fn traceAny(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
       let found = anyInLeaf(leaf.x, leaf.y, origin, direction, maxDistance);
 
       if (found != NO_HIT) {
-        return orderedTriangle(found);
+        return namedTriangle(found, instance);
       }
 
       leaf.y = 0;
     }
 
+    if (INSTANCES && leaf.y < 0) {
+      leaf.y = 0;
+
+      if (depth < BVH_STACK) {
+        instance = u32(-1 - leaf.x);
+        stack[depth] = RETURN_ENTRY;
+        depth = depth + 1u;
+        origin = instanceToObject(instance, worldOrigin, 1.0);
+        direction = instanceToObject(instance, worldDirection, 0.0);
+        inverse = rayInverse(direction);
+        current = instanceWord(instance, 24u);
+      }
+    }
+
     if (current == NO_NODE) {
       if (depth == 0u) {
         break;
@@ -250,6 +332,14 @@ fn traceAny(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
 
       let entry = stack[depth];
 
+      if (INSTANCES && entry == RETURN_ENTRY) {
+        instance = NO_INSTANCE;
+        origin = worldOrigin;
+        direction = worldDirection;
+        inverse = rayInverse(direction);
+        continue;
+      }
+
       if ((entry & LEAF_ENTRY) != 0u) {
         leaf = waitingLeaf(entry);
         continue;
@@ -277,7 +367,7 @@ fn traceAny(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> u32 {
       }
     }
 
-    if (rightHit && leftHit && depth < 32u) {
+    if (rightHit && leftHit && depth < BVH_STACK) {
       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;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwRlC,CAAC"}
+{"version":3,"file":"bvh.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/bvh.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8WlC,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":"AAIA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QA4MvB,CAAC"}
+{"version":3,"file":"common.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/common.wgsl.ts"],"names":[],"mappings":"AAIA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QA6RvB,CAAC"}

package/dist/wgsl/common.wgsl.js

@@ -136,13 +136,16 @@ 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.
+// Nine coordinates per stored triangle, in the hierarchy's leaf order: see leafOf in bvh.wgsl.ts. A prototype's are
+// in object space.
 @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.
+// Per vertex: the UV sets from frame.uvOffset and vertex colours from frame.colorOffset; then shader varyings, per
+// corner, 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 (the triangle at each
-// position of the leaf order), then from frame.leafOffset on the other way (the position of each triangle).
+// One material index per triangle a hit can name, then the hierarchy's triangle order from frame.orderOffset on (the
+// stored triangle at each position of the leaf order), then from frame.leafOffset on the other way (the position of
+// each stored triangle), the instance of every instanced triangle from frame.instanceOffset, the three vertices of each
+// stored triangle from frame.cornerOffset and every vertex's folded normal from frame.normalOffset.
 @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>;
@@ -162,24 +165,102 @@ fn orderedTriangle(at: u32) -> u32 {
   return indices[frame.orderOffset + at];
 }
 
-/** One word of a UV set: three vertices of four components, two per set. */
-fn attributeUv(triangle: u32, corner: u32, channel: u32) -> vec2<f32> {
-  let at = frame.uvOffset + triangle * 12u + corner * 4u + channel * 2u;
+/** What a triangle of the scene's own belongs to: no instance. */
+const NO_INSTANCE: u32 = 0xffffffffu;
+
+/** The instance a triangle a hit named belongs to, or NO_INSTANCE for one of the scene's own. */
+fn instanceOf(triangle: u32) -> u32 {
+  if (!INSTANCES || triangle < frame.sceneTriangles) {
+    return NO_INSTANCE;
+  }
+
+  return indices[frame.instanceOffset + triangle - frame.sceneTriangles];
+}
+
+/** One word of an instance's record: see INSTANCE_WORDS in instancing.ts. */
+fn instanceWord(instance: u32, word: u32) -> u32 {
+  return textures[frame.instanceData + instance * 28u + word];
+}
+
+/** A row of an instance's transforms: 0 to 2 take object space to world, 3 to 5 back. */
+fn instanceRow(instance: u32, row: u32) -> vec4<f32> {
+  let at = frame.instanceData + instance * 28u + row * 4u;
+
+  return vec4<f32>(bitcast<f32>(textures[at]), bitcast<f32>(textures[at + 1u]), bitcast<f32>(textures[at + 2u]),
+    bitcast<f32>(textures[at + 3u]));
+}
+
+/** Where a named triangle is stored: itself, or for an instance's, the prototype's triangle it repeats. */
+fn storedTriangle(triangle: u32, instance: u32) -> u32 {
+  if (instance == NO_INSTANCE) {
+    return triangle;
+  }
+
+  return instanceWord(instance, 25u) + triangle - instanceWord(instance, 26u);
+}
+
+/** A point of an instance's prototype, in world space. */
+fn instancePoint(instance: u32, p: vec3<f32>) -> vec3<f32> {
+  let q = vec4<f32>(p, 1.0);
+
+  return vec3<f32>(dot(instanceRow(instance, 0u), q), dot(instanceRow(instance, 1u), q), dot(instanceRow(instance, 2u), q));
+}
+
+/** A world space point (w 1) or direction (w 0), in an instance's object space. */
+fn instanceToObject(instance: u32, v: vec3<f32>, w: f32) -> vec3<f32> {
+  let q = vec4<f32>(v, w);
+
+  return vec3<f32>(dot(instanceRow(instance, 3u), q), dot(instanceRow(instance, 4u), q), dot(instanceRow(instance, 5u), q));
+}
+
+/** An object space normal in world space, by the inverse transpose; not normalized. */
+fn instanceNormal(instance: u32, n: vec3<f32>) -> vec3<f32> {
+  return n.x * instanceRow(instance, 3u).xyz + n.y * instanceRow(instance, 4u).xyz + n.z * instanceRow(instance, 5u).xyz;
+}
+
+/** The three vertices of a triangle a hit named. */
+fn triangleCorners(triangle: u32) -> vec3<u32> {
+  let at = frame.cornerOffset + storedTriangle(triangle, instanceOf(triangle)) * 3u;
+
+  return vec3<u32>(indices[at], indices[at + 1u], indices[at + 2u]);
+}
+
+/** One UV set of a vertex: four components, two per set. */
+fn vertexUv(vertex: u32, channel: u32) -> vec2<f32> {
+  let at = frame.uvOffset + vertex * 4u + channel * 2u;
 
   return vec2<f32>(attributes[at], attributes[at + 1u]);
 }
 
-/** A corner's vertex colour, or white when the scene has none. */
-fn attributeColor(triangle: u32, corner: u32) -> vec4<f32> {
+/** A vertex's colour, or white when the scene has none. */
+fn vertexColor(vertex: u32) -> vec4<f32> {
   if (frame.hasColors == 0u) {
     return vec4<f32>(1.0);
   }
 
-  let at = frame.colorOffset + triangle * 12u + corner * 4u;
+  let at = frame.colorOffset + vertex * 4u;
 
   return vec4<f32>(attributes[at], attributes[at + 1u], attributes[at + 2u], attributes[at + 3u]);
 }
 
+/** A normal folded onto an octahedron in two signed 16 bit halves, as sceneUpload.ts folds it; zero for NO_NORMAL. */
+fn vertexNormal(vertex: u32) -> vec3<f32> {
+  let code = indices[frame.normalOffset + vertex];
+
+  if (code == 0x80008000u) {
+    return vec3<f32>(0.0);
+  }
+
+  let e = unpack2x16snorm(code);
+  var n = vec3<f32>(e.x, e.y, 1.0 - abs(e.x) - abs(e.y));
+  let t = max(-n.z, 0.0);
+
+  n.x = n.x + select(t, -t, n.x >= 0.0);
+  n.y = n.y + select(t, -t, n.y >= 0.0);
+
+  return normalize(n);
+}
+
 fn extraFloat(at: u32) -> f32 {
   return bitcast<f32>(textures[at]);
 }

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;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4JzC,CAAC"}

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

@@ -13,5 +13,5 @@
  * 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  // Whether the camera meters the image and exposes it to middle grey, which the meter pass works out.\n  autoExposure: f32,\n  // The share of a dark scene's darkness the meter keeps.\n  darkAdaptation: 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// What the camera's meter read: the exposure that brings the image's average to middle grey, in x.\n@group(0) @binding(7) var<storage, read_write> metered: array<vec4<f32>>;\n\n/** What a light meter calibrates to: an average scene reflects about eighteen percent. */\nconst MIDDLE_GREY: f32 = 0.18;\nconst METER_GRID: vec2<u32> = vec2<u32>(64u, 36u);\nconst METER_THREADS: u32 = 256u;\n\n/**\n * How far above middle grey the meter lets the bright end of the image land: three stops, where AgX still shows\n * detail, three and a half under where it reaches white.\n */\nconst HIGHLIGHT_CEILING: f32 = 8.0;\n/** The share of the metered points that counts as the bright end: the light through a window, not a lamp's own pixels. */\nconst HIGHLIGHT_SHARE: f32 = 0.03;\n/**\n * The average below which a scene counts as dark: about three stops under middle grey, a room lit by a window on a\n * grey day. Above it the meter exposes fully; below it, only for the stops the dark adaptation lets go.\n */\nconst DIM_AVERAGE: f32 = 0.02;\n/** Half stops of luminance, from 2^-16 to 2^16, which the bright end is found in. */\nconst METER_BINS: u32 = 64u;\n\nvar<workgroup> meterSums: array<vec2<f32>, 256>;\nvar<workgroup> meterHistogram: array<atomic<u32>, 64>;\n\n/**\n * The camera's meter: the image's average luminance over a grid of points, taken as the mean of the logarithms so that\n * a bright window or a patch of sky cannot darken everything else, weighed towards the centre as a camera's\n * centre-weighted metering is. What no path has reached yet, or is black, does not count. One workgroup reads the\n * grid and sums it in shared memory.\n *\n * Then it guards the highlights, as a camera's matrix metering does: the average alone takes a dim attic with a shaft\n * of sun in it to middle grey and burns the shaft out, where a photographer keeps the room dim. The brightest few\n * percent of the points, found in a histogram of half stops, may land no more than {@link HIGHLIGHT_CEILING} times\n * brighter; an even scene, whose bright end is close to its average, is left as the average says.\n */\n@compute @workgroup_size(256, 1, 1)\nfn meter(@builtin(local_invocation_index) thread: u32) {\n  var sum = vec2<f32>(0.0);\n  let count = METER_GRID.x * METER_GRID.y;\n\n  if (thread < METER_BINS) {\n    atomicStore(&meterHistogram[thread], 0u);\n  }\n\n  workgroupBarrier();\n\n  for (var k = thread; k < count; k = k + METER_THREADS) {\n    let cell = vec2<f32>(f32(k % METER_GRID.x), f32(k / METER_GRID.x)) + 0.5;\n    let uv = cell / vec2<f32>(METER_GRID);\n    let luminance = dot(imageTexel(i32(uv.x * f32(lens.resolution.x)), i32(uv.y * f32(lens.resolution.y))),\n      vec3<f32>(0.2126, 0.7152, 0.0722));\n    let away = (uv - 0.5) * 2.0;\n    let weight = select(0.0, 1.0 - 0.6 * min(dot(away, away) * 0.5, 1.0), luminance > 0.0);\n\n    sum = sum + vec2<f32>(log(max(luminance, 1e-6)) * weight, weight);\n\n    if (luminance > 0.0) {\n      let bin = u32(clamp((log2(luminance) + 16.0) * 2.0, 0.0, f32(METER_BINS - 1u)));\n\n      atomicAdd(&meterHistogram[bin], 1u);\n    }\n  }\n\n  meterSums[thread] = sum;\n  workgroupBarrier();\n\n  for (var stride = METER_THREADS / 2u; stride > 0u; stride = stride / 2u) {\n    if (thread < stride) {\n      meterSums[thread] = meterSums[thread] + meterSums[thread + stride];\n    }\n\n    workgroupBarrier();\n  }\n\n  if (thread == 0u) {\n    let total = meterSums[0];\n    let average = select(MIDDLE_GREY, exp(total.x / max(total.y, 1e-6)), total.y > 0.0);\n    var exposure = MIDDLE_GREY / average;\n\n    // A dark scene keeps a share of its missing stops: a night stays a night instead of turning into dusk.\n    if (average < DIM_AVERAGE) {\n      exposure = exposure * pow(average / DIM_AVERAGE, lens.darkAdaptation);\n    }\n\n    // From the top down, the first half stop by which the bright share is reached; its upper edge is that end.\n    var points = 0u;\n\n    for (var bin = 0u; bin < METER_BINS; bin = bin + 1u) {\n      points = points + atomicLoad(&meterHistogram[bin]);\n    }\n\n    var above = 0u;\n    var bright = 0.0;\n\n    for (var bin = i32(METER_BINS) - 1; bin >= 0 && points > 0u; bin = bin - 1) {\n      above = above + atomicLoad(&meterHistogram[u32(bin)]);\n\n      if (f32(above) >= HIGHLIGHT_SHARE * f32(points)) {\n        bright = exp2(f32(bin + 1) * 0.5 - 16.0);\n        break;\n      }\n    }\n\n    if (bright > 0.0) {\n      exposure = min(exposure, HIGHLIGHT_CEILING * MIDDLE_GREY / bright);\n    }\n\n    metered[0] = vec4<f32>(clamp(exposure, 1e-4, 1e4), average, bright, 0.0);\n  }\n}\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 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    // The largest folded level is already a tent over the levels below it, so one bilinear read of it is smooth.\n    let halo = upBilinear(lens.haloOffset, lens.haloSize, 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  if (lens.autoExposure > 0.0) {\n    color = color * metered[0].x;\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";
+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  // Whether the camera meters the image and exposes it to middle grey, which the meter pass works out.\n  autoExposure: f32,\n  // The share of a dark scene's darkness the meter keeps.\n  darkAdaptation: f32,\n  // The exposure applied after the lens, the meter's aside, which the rays are limited against.\n  exposure: 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/**\n * The brightest a tap of the rays counts as, in multiples of the exposed white. A lamp is thousands of times white,\n * which would carry its rays across the frame at full length; past this they stay as short as a camera shows them.\n */\nconst GLARE_CEILING: f32 = 4.0;\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// What the camera's meter read: the exposure that brings the image's average to middle grey, in x.\n@group(0) @binding(7) var<storage, read_write> metered: array<vec4<f32>>;\n\n/** What a light meter calibrates to: an average scene reflects about eighteen percent. */\nconst MIDDLE_GREY: f32 = 0.18;\nconst METER_GRID: vec2<u32> = vec2<u32>(64u, 36u);\nconst METER_THREADS: u32 = 256u;\n\n/**\n * How far above middle grey the meter lets the bright end of the image land: three stops, where AgX still shows\n * detail, three and a half under where it reaches white.\n */\nconst HIGHLIGHT_CEILING: f32 = 8.0;\n/** The share of the metered points that counts as the bright end: the light through a window, not a lamp's own pixels. */\nconst HIGHLIGHT_SHARE: f32 = 0.03;\n/**\n * The average below which a scene counts as dark: about three stops under middle grey, a room lit by a window on a\n * grey day. Above it the meter exposes fully; below it, only for the stops the dark adaptation lets go.\n */\nconst DIM_AVERAGE: f32 = 0.02;\n/** Half stops of luminance, from 2^-16 to 2^16, which the bright end is found in. */\nconst METER_BINS: u32 = 64u;\n\nvar<workgroup> meterSums: array<vec2<f32>, 256>;\nvar<workgroup> meterHistogram: array<atomic<u32>, 64>;\n\n/**\n * The camera's meter: the image's average luminance over a grid of points, taken as the mean of the logarithms so that\n * a bright window or a patch of sky cannot darken everything else, weighed towards the centre as a camera's\n * centre-weighted metering is. What no path has reached yet, or is black, does not count. One workgroup reads the\n * grid and sums it in shared memory.\n *\n * Then it guards the highlights, as a camera's matrix metering does: the average alone takes a dim attic with a shaft\n * of sun in it to middle grey and burns the shaft out, where a photographer keeps the room dim. The brightest few\n * percent of the points, found in a histogram of half stops, may land no more than {@link HIGHLIGHT_CEILING} times\n * brighter; an even scene, whose bright end is close to its average, is left as the average says.\n */\n@compute @workgroup_size(256, 1, 1)\nfn meter(@builtin(local_invocation_index) thread: u32) {\n  var sum = vec2<f32>(0.0);\n  let count = METER_GRID.x * METER_GRID.y;\n\n  if (thread < METER_BINS) {\n    atomicStore(&meterHistogram[thread], 0u);\n  }\n\n  workgroupBarrier();\n\n  for (var k = thread; k < count; k = k + METER_THREADS) {\n    let cell = vec2<f32>(f32(k % METER_GRID.x), f32(k / METER_GRID.x)) + 0.5;\n    let uv = cell / vec2<f32>(METER_GRID);\n    let luminance = dot(imageTexel(i32(uv.x * f32(lens.resolution.x)), i32(uv.y * f32(lens.resolution.y))),\n      vec3<f32>(0.2126, 0.7152, 0.0722));\n    let away = (uv - 0.5) * 2.0;\n    let weight = select(0.0, 1.0 - 0.6 * min(dot(away, away) * 0.5, 1.0), luminance > 0.0);\n\n    sum = sum + vec2<f32>(log(max(luminance, 1e-6)) * weight, weight);\n\n    if (luminance > 0.0) {\n      let bin = u32(clamp((log2(luminance) + 16.0) * 2.0, 0.0, f32(METER_BINS - 1u)));\n\n      atomicAdd(&meterHistogram[bin], 1u);\n    }\n  }\n\n  meterSums[thread] = sum;\n  workgroupBarrier();\n\n  for (var stride = METER_THREADS / 2u; stride > 0u; stride = stride / 2u) {\n    if (thread < stride) {\n      meterSums[thread] = meterSums[thread] + meterSums[thread + stride];\n    }\n\n    workgroupBarrier();\n  }\n\n  if (thread == 0u) {\n    let total = meterSums[0];\n    let average = select(MIDDLE_GREY, exp(total.x / max(total.y, 1e-6)), total.y > 0.0);\n    var exposure = MIDDLE_GREY / average;\n\n    // A dark scene keeps a share of its missing stops: a night stays a night instead of turning into dusk.\n    if (average < DIM_AVERAGE) {\n      exposure = exposure * pow(average / DIM_AVERAGE, lens.darkAdaptation);\n    }\n\n    // From the top down, the first half stop by which the bright share is reached; its upper edge is that end.\n    var points = 0u;\n\n    for (var bin = 0u; bin < METER_BINS; bin = bin + 1u) {\n      points = points + atomicLoad(&meterHistogram[bin]);\n    }\n\n    var above = 0u;\n    var bright = 0.0;\n\n    for (var bin = i32(METER_BINS) - 1; bin >= 0 && points > 0u; bin = bin - 1) {\n      above = above + atomicLoad(&meterHistogram[u32(bin)]);\n\n      if (f32(above) >= HIGHLIGHT_SHARE * f32(points)) {\n        bright = exp2(f32(bin + 1) * 0.5 - 16.0);\n        break;\n      }\n    }\n\n    if (bright > 0.0) {\n      exposure = min(exposure, HIGHLIGHT_CEILING * MIDDLE_GREY / bright);\n    }\n\n    metered[0] = vec4<f32>(clamp(exposure, 1e-4, 1e4), average, bright, 0.0);\n  }\n}\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  // The exposure the image will have: the setting's, and the meter's when it meters.\n  let exposure = lens.exposure * select(1.0, metered[0].x, lens.autoExposure > 0.0);\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(-6.0 * t);\n\n      let light = downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength));\n\n      sum = sum + light * (weight / max(1.0, luminance(light) * exposure / GLARE_CEILING));\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 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    // The largest folded level is already a tent over the levels below it, so one bilinear read of it is smooth.\n    let halo = upBilinear(lens.haloOffset, lens.haloSize, 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  if (lens.autoExposure > 0.0) {\n    color = color * metered[0].x;\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

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

package/dist/wgsl/lens.wgsl.js

@@ -50,6 +50,8 @@ struct Lens {
   autoExposure: f32,
   // The share of a dark scene's darkness the meter keeps.
   darkAdaptation: f32,
+  // The exposure applied after the lens, the meter's aside, which the rays are limited against.
+  exposure: f32,
 };
 
 const PI: f32 = 3.14159265358979;
@@ -57,6 +59,12 @@ const PI: f32 = 3.14159265358979;
 /** Taps along each of the aperture's rays. */
 const STREAK_TAPS: i32 = 24;
 
+/**
+ * The brightest a tap of the rays counts as, in multiples of the exposed white. A lamp is thousands of times white,
+ * which would carry its rays across the frame at full length; past this they stay as short as a camera shows them.
+ */
+const GLARE_CEILING: f32 = 4.0;
+
 @group(0) @binding(0) var<uniform> lens: Lens;
 @group(0) @binding(1) var<storage, read> accumulation: array<vec4<f32>>;
 @group(0) @binding(2) var<storage, read> denoised: array<vec4<f32>>;
@@ -342,6 +350,8 @@ fn streaks(@builtin(global_invocation_id) id: vec3<u32>) {
   }
 
   let centre = vec2<f32>(id.xy) + 0.5;
+  // The exposure the image will have: the setting's, and the meter's when it meters.
+  let exposure = lens.exposure * select(1.0, metered[0].x, lens.autoExposure > 0.0);
   var sum = vec3<f32>(0.0);
   var total = 0.0;
 
@@ -351,9 +361,11 @@ fn streaks(@builtin(global_invocation_id) id: vec3<u32>) {
 
     for (var j = 1; j <= STREAK_TAPS; j = j + 1) {
       let t = f32(j) / f32(STREAK_TAPS);
-      let weight = exp(-4.0 * t);
+      let weight = exp(-6.0 * t);
+
+      let light = downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength));
 
-      sum = sum + downBilinear(lens.sourceOffset, lens.sourceSize, centre - along * (t * lens.glareLength)) * weight;
+      sum = sum + light * (weight / max(1.0, luminance(light) * exposure / GLARE_CEILING));
       total = total + weight;
     }
   }

package/dist/wgsl/lens.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"lens.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/lens.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmZnC,CAAC"}
+{"version":3,"file":"lens.wgsl.js","sourceRoot":"","sources":["../../src/wgsl/lens.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ZnC,CAAC"}