@tinypoly/gpu-renderer 0.0.4 → 0.1.0

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;
@@ -51,11 +52,143 @@ fn lightByProbability(u: f32) -> Light {
   return lights[low];
 }
 
+const TREE_NODE_WORDS: u32 = 16u;
+const TREE_LEAF: u32 = 0x80000000u;
+const TREE_ROOT_PARENT: u32 = 0xffffffffu;
+const NO_LIGHT: u32 = 0xffffffffu;
+
 /**
- * The area density with which direct sampling would have picked a point on this triangle, or zero if it never would.
- * Only the leading entries are emissive triangles, and they are in triangle order, so one binary search answers it.
+ * How much the lights under a node of the light tree can deliver to a point: their power over the square of the
+ * distance, times how well their cone of directions and the receiving surface face each other, each widened by the
+ * angle the node's box takes from the point (Conty Estevez and Kulla's importance). A point inside the box rules
+ * nothing out. A zero normal is a receiver that takes light from everywhere, such as a point in a volume.
  */
-fn lightPdfOfTriangle(triangle: u32) -> f32 {
+fn lightNodeImportance(node: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
+  let at = frame.lightTree + node * TREE_NODE_WORDS;
+  let low = extraVec4(at);
+  let high = extraVec4(at + 4u);
+  let cone = extraVec4(at + 8u);
+
+  if (low.w <= 0.0) {
+    return 0.0;
+  }
+
+  let centre = (low.xyz + high.xyz) * 0.5;
+  let radius = length(high.xyz - low.xyz) * 0.5;
+  let offset = position - centre;
+  let distance2 = dot(offset, offset);
+
+  if (distance2 <= radius * radius) {
+    return low.w / max(radius * radius, 1e-12);
+  }
+
+  let distance = sqrt(distance2);
+  let spread = asin(clamp(radius / distance, 0.0, 1.0));
+  var orientation = 1.0;
+
+  // A cone of minus one is the whole sphere: such lights shine towards every point alike.
+  if (high.w > -1.0) {
+    let theta = acos(clamp(dot(cone.xyz, offset / distance), -1.0, 1.0));
+    let past = max(0.0, theta - acos(high.w) - spread);
+
+    orientation = select(0.0, cos(past), past <= acos(clamp(cone.w, -1.0, 1.0)));
+  }
+
+  var facing = 1.0;
+
+  if (any(normal != vec3<f32>(0.0))) {
+    let past = max(0.0, acos(clamp(dot(normal, -offset / distance), -1.0, 1.0)) - spread);
+
+    facing = select(0.0, cos(past), past < 0.5 * PI);
+  }
+
+  return low.w * orientation * facing / distance2;
+}
+
+/** The chance of stepping from a node of the tree to each of its children, from this point. */
+fn lightChildOdds(left: u32, right: u32, position: vec3<f32>, normal: vec3<f32>) -> vec2<f32> {
+  var importance = vec2<f32>(0.0);
+
+  // One loop over the two children, so the importance is written into the kernel once per walk.
+  for (var k = 0u; k < 2u; k = k + 1u) {
+    importance[k] = lightNodeImportance(select(right, left, k == 0u), position, normal);
+  }
+
+  let total = importance.x + importance.y;
+
+  return select(importance / total, vec2<f32>(0.0), total <= 0.0);
+}
+
+/** A light picked down the tree by importance from this point, with the chance of picking it; NO_LIGHT for none. */
+fn sampleLightTree(position: vec3<f32>, normal: vec3<f32>, u: f32, pdf: ptr<function, f32>,
+  density: ptr<function, f32>) -> u32 {
+  var node = 0u;
+  var chance = 1.0;
+  var x = u;
+
+  for (var depth = 0u; depth < 64u; depth = depth + 1u) {
+    let at = frame.lightTree + node * TREE_NODE_WORDS;
+    let first = textures[at + 12u];
+
+    if ((first & TREE_LEAF) != 0u) {
+      *pdf = chance;
+      *density = extraFloat(at + 13u);
+
+      return first & ~TREE_LEAF;
+    }
+
+    let second = textures[at + 13u];
+    let odds = lightChildOdds(first, second, position, normal);
+
+    if (odds.x + odds.y <= 0.0) {
+      return NO_LIGHT;
+    }
+
+    if (x < odds.x) {
+      node = first;
+      chance = chance * odds.x;
+      x = x / odds.x;
+    } else {
+      node = second;
+      chance = chance * odds.y;
+      x = (x - odds.x) / max(odds.y, 1e-20);
+    }
+
+    x = min(x, 0.99999994);
+  }
+
+  return NO_LIGHT;
+}
+
+/** The chance the tree would have picked the local light at this index from this point, walked up from its leaf. */
+fn lightTreePdf(index: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
+  var node = textures[frame.lightLeaves + index];
+  var chance = extraFloat(frame.lightTree + node * TREE_NODE_WORDS + 13u);
+
+  for (var depth = 0u; depth < 64u; depth = depth + 1u) {
+    let parent = textures[frame.lightTree + node * TREE_NODE_WORDS + 14u];
+
+    if (parent == TREE_ROOT_PARENT) {
+      return chance;
+    }
+
+    let at = frame.lightTree + parent * TREE_NODE_WORDS;
+    let first = textures[at + 12u];
+    let odds = lightChildOdds(first, textures[at + 13u], position, normal);
+
+    chance = chance * select(odds.y, odds.x, node == first);
+    node = parent;
+  }
+
+  return 0.0;
+}
+
+/**
+ * The area density with which direct sampling from this point would have picked a point on this triangle, or zero if
+ * it never would. Only the leading entries are emissive triangles, and they are in triangle order, so one binary search
+ * finds the entry; the tree, when there is one, says how likely it was from here.
+ */
+fn lightPdfOfTriangle(triangle: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
   var low = 0u;
   var high = frame.areaLightCount;
 
@@ -65,9 +198,13 @@ fn lightPdfOfTriangle(triangle: u32) -> f32 {
     }
 
     let middle = (low + high) / 2u;
-    let candidate = lights[middle].triangle;
+    let candidate = textures[frame.lightTriangles + middle];
 
     if (candidate == triangle) {
+      if (frame.lightTree != 0u) {
+        return frame.localLightPick * lightTreePdf(middle, position, normal);
+      }
+
       return lights[middle].pdf;
     }
 
@@ -127,12 +264,27 @@ fn rectanglePoint(light: Light, u: vec2<f32>) -> vec3<f32> {
  * Where the light that pick selects arrives from, and how much of it. u places the point on a surface light or spreads a
  * point light's shadow, so the same two dimensions serve every kind.
  */
-fn sampleLight(position: vec3<f32>, pick: f32, u: vec2<f32>) -> LightSample {
+fn sampleLight(position: vec3<f32>, normal: vec3<f32>, pick: f32, u: vec2<f32>) -> LightSample {
   if (frame.lightCount == 0u) {
     return noLight();
   }
 
-  return sampleLightEntry(lightByProbability(pick), position, u);
+  // The lights in the scene go through the tree, by what they can deliver here; what lies outside it by its weight.
+  if (frame.lightTree != 0u && pick < frame.localLightPick) {
+    var chance = 0.0;
+    var density = 1.0;
+    let index = sampleLightTree(position, normal, pick / frame.localLightPick, &chance, &density);
+
+    if (index == NO_LIGHT || chance <= 0.0) {
+      return noLight();
+    }
+
+    return sampleLightEntry(lights[index], frame.localLightPick * chance * density, position, u);
+  }
+
+  let light = lightByProbability(pick);
+
+  return sampleLightEntry(light, light.pdf, position, u);
 }
 
 /** Three's spotLightMap: inside the projection's frustum the texture tints the light; outside it leaves it alone. */
@@ -159,7 +311,8 @@ fn spotLightTint(light: Light, position: vec3<f32>) -> vec3<f32> {
   return sampleTextureRaw(map, projected.xy).rgb;
 }
 
-fn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSample {
+/** pdf is the chance of picking this light, times the area density of a point on it where it has an area. */
+fn sampleLightEntry(light: Light, pdf: f32, position: vec3<f32>, u: vec2<f32>) -> LightSample {
   var sample: LightSample;
   sample.valid = true;
   sample.kind = light.kind;
@@ -175,7 +328,7 @@ fn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSam
       return noLight();
     }
 
-    let density = light.pdf * drawn.pdf;
+    let density = pdf * drawn.pdf;
 
     sample.direction = drawn.direction;
     sample.distance = 1e30;
@@ -190,7 +343,7 @@ fn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSam
     sample.direction = spreadDirection(light.direction, u);
     sample.distance = 1e30;
     // The colour already carries the intensity, which for a directional light is the irradiance it delivers.
-    sample.value = light.color / light.pdf;
+    sample.value = light.color / pdf;
 
     return sample;
   }
@@ -219,7 +372,7 @@ fn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSam
 
     // Stop just short of the light so its own surface is not reported as the blocker.
     sample.distance = distance * (1.0 - 1e-3);
-    let density = light.pdf * distanceSquared / cosLight;
+    let density = pdf * distanceSquared / cosLight;
     // The emissive map is read at the very point that was sampled, so this agrees with what a bounce ray would find.
     let emission = select(light.color, emissionAt(light.triangle, bary), area);
 
@@ -259,7 +412,7 @@ fn sampleLightEntry(light: Light, position: vec3<f32>, u: vec2<f32>) -> LightSam
 
   sample.direction = spreadDirection(towards, u);
   sample.distance = distance;
-  sample.value = light.color * (power / light.pdf);
+  sample.value = light.color * (power / pdf);
 
   if (light.kind == LIGHT_SPOT) {
     sample.value = sample.value * spotLightTint(light, position);
@@ -276,7 +429,7 @@ fn blocksAll(m: u32) -> bool {
   let flags = materials[m].flags;
   let blending = materials[m].blending;
 
-  return (flags & (MATERIAL_TRANSPARENT | MATERIAL_ALPHA_HASH | MATERIAL_WIREFRAME)) == 0u
+  return (flags & (MATERIAL_TRANSPARENT | MATERIAL_ALPHA_HASH | MATERIAL_WIREFRAME | MATERIAL_VOLUME)) == 0u
     && materials[m].alphaTest <= 0.0
     && materials[m].transmission <= 0.0
     && materials[m].clipCount == 0u
@@ -332,45 +485,63 @@ fn blendColor(triangle: u32, bary: vec2<f32>) -> vec3<f32> {
 /**
  * How much of the light this sample came from reaches the shaded point. A surface that only partly covers its triangle
  * blocks the ray only that often, which is what makes a cutout leaf cast a cutout shadow; a thin transmissive wall
- * lets its own share through, tinted.
+ * lets its own share through, tinted. A volume's boundary lets the ray in or out, and the medium inside takes its
+ * share over the distance between; medium is the density at the shaded point itself, zero outside any volume.
  */
-fn lightTransmittance(
-  position: vec3<f32>, chosen: LightSample, rng: ptr<function, PathSampler>, skipMaterial: u32) -> vec3<f32> {
-  if (!chosen.occlude) {
+fn lightTransmittance(position: vec3<f32>, chosen: LightSample, rng: ptr<function, PathSampler>, skipMaterial: u32,
+  medium: f32) -> vec3<f32> {
+  // A light that casts no shadow is blocked by nothing, but a medium on the way still takes its share: then the walk
+  // below only looks for volumes and passes every other surface.
+  if (!chosen.occlude && !VOLUMES) {
     return vec3<f32>(1.0);
   }
 
-  // Most blockers are plainly opaque, and for those any triangle on the way settles it: the search stops at the first
-  // one found instead of looking for the closest. Anything that lets light through goes the long way below.
-  let first = traceAny(position, chosen.direction, chosen.distance);
+  if (chosen.occlude) {
+    // Most blockers are plainly opaque, and for those any triangle on the way settles it: the search stops at the
+    // first one found instead of looking for the closest. Anything that lets light through goes the long way below.
+    let first = traceAny(position, chosen.direction, chosen.distance);
 
-  if (first == NO_HIT) {
-    return vec3<f32>(1.0);
-  }
+    if (first == NO_HIT) {
+      return vec3<f32>(exp(-medium * chosen.distance));
+    }
 
-  let firstMaterial = materialIndexOf(first);
+    let firstMaterial = materialIndexOf(first);
 
-  if (firstMaterial != skipMaterial && blocksAll(firstMaterial)) {
-    return vec3<f32>(0.0);
+    if (firstMaterial != skipMaterial && blocksAll(firstMaterial)) {
+      return vec3<f32>(0.0);
+    }
   }
 
   var origin = position;
   var remaining = chosen.distance;
   var through = vec3<f32>(1.0);
+  // The medium the ray is in, and how far along the ray it entered it.
+  var density = medium;
+  var travelled = 0.0;
+  var enteredAt = 0.0;
 
   for (var skip = 0u; skip < MAX_SHADOW_SKIPS; skip = skip + 1u) {
     let blocker = traceScene(origin, chosen.direction, remaining);
 
     if (blocker.triangle == NO_HIT) {
-      return through;
+      return through * exp(-density * (travelled + remaining - enteredAt));
     }
 
     let bary = vec2<f32>(blocker.u, blocker.v);
     let m = materialIndexOf(blocker.triangle);
     let blending = materials[m].blending;
 
-    // A shadow catcher catches shadows rather than casting them, and a surface that adds light blocks none.
-    if (m != skipMaterial && materials[m].kind != KIND_SHADOW && blending != BLEND_ADDITIVE) {
+    if (VOLUMES && (materials[m].flags & MATERIAL_VOLUME) != 0u) {
+      let at = travelled + blocker.distance;
+
+      if (dot(authoredNormal(blocker.triangle, bary), chosen.direction) < 0.0) {
+        density = select(0.0, materials[m].volume.w, frame.volumesEnabled != 0u);
+        enteredAt = at;
+      } else {
+        through = through * exp(-density * (at - enteredAt));
+        density = 0.0;
+      }
+    } else if (chosen.occlude && m != skipMaterial && materials[m].kind != KIND_SHADOW && blending != BLEND_ADDITIVE) {
       let coverage = coverageAt(blocker.triangle, bary, chosen.direction);
 
       if (blending == BLEND_MULTIPLY) {
@@ -389,13 +560,15 @@ fn lightTransmittance(
     // The ray carries on from just past the surface it saw through.
     origin = origin + chosen.direction * (blocker.distance + RAY_EPSILON);
     remaining = remaining - blocker.distance - RAY_EPSILON;
+    travelled = travelled + blocker.distance + RAY_EPSILON;
 
     if (remaining <= RAY_EPSILON) {
-      return through;
+      return through * exp(-density * (travelled - enteredAt));
     }
   }
 
-  return vec3<f32>(0.0);
+  // Too many surfaces to see through: a shadow ray gives up dark, a ray that only counts the media keeps what it has.
+  return select(vec3<f32>(0.0), through, !chosen.occlude);
 }
 
 /**
@@ -417,13 +590,13 @@ fn shadowMaskAt(position: vec3<f32>, rng: ptr<function, PathSampler>) -> f32 {
       continue;
     }
 
-    let chosen = sampleLightEntry(light, position, sample2D(rng));
+    let chosen = sampleLightEntry(light, light.pdf, position, sample2D(rng));
 
     if (!chosen.valid) {
       continue;
     }
 
-    let visible = luminanceOf(lightTransmittance(position, chosen, rng, NO_MATERIAL));
+    let visible = luminanceOf(lightTransmittance(position, chosen, rng, NO_MATERIAL, 0.0));
 
     shadow = max(shadow, 1.0 - clamp(visible, 0.0, 1.0));
   }

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqlBrC,CAAC"}

package/dist/wgsl/pathTrace.wgsl.d.ts

@@ -10,5 +10,5 @@
  * reflection: culled faces, the background, Three's fog, a light map's baked light and the coverage a transparent
  * background turns into alpha. Transmission keeps a path on that line, as Three's transmission shows what is behind.
  */
-export declare const PATH_TRACE_WGSL = "\n/** Light from an ambient or hemisphere light, which this renderer turns into an equally bright surrounding. */\nfn ambientRadiance(direction: vec3<f32>) -> vec3<f32> {\n  let latitude = clamp(dot(direction, frame.ambientAxis.xyz) * 0.5 + 0.5, 0.0, 1.0);\n\n  return mix(frame.ambientGround.rgb, frame.ambientSky.rgb, latitude) + probeRadiance(direction);\n}\n\n/**\n * A LightProbe's light. Three's coefficients are radiance projected on the SH3 basis, which its shader convolves with\n * the cosine to get irradiance; evaluated directly they are the surrounding that delivers exactly that irradiance.\n */\nfn probeRadiance(d: vec3<f32>) -> vec3<f32> {\n  let radiance = frame.probe0.rgb * 0.282095\n    + frame.probe1.rgb * (0.488603 * d.y)\n    + frame.probe2.rgb * (0.488603 * d.z)\n    + frame.probe3.rgb * (0.488603 * d.x)\n    + frame.probe4.rgb * (1.092548 * d.x * d.y)\n    + frame.probe5.rgb * (1.092548 * d.y * d.z)\n    + frame.probe6.rgb * (0.315392 * (3.0 * d.z * d.z - 1.0))\n    + frame.probe7.rgb * (1.092548 * d.x * d.z)\n    + frame.probe8.rgb * (0.546274 * (d.x * d.x - d.y * d.y));\n\n  return max(radiance, vec3<f32>(0.0));\n}\n\n/** What the camera sees where nothing is in the way, as the background setting says. */\nfn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {\n  if (frame.background.w == 1.0) {\n    return frame.background.rgb;\n  }\n\n  // A procedural sky paints the background without the strength it lights with, and its foreground over it.\n  if (frame.skyProgram != NO_PROGRAM || frame.skyIntensity > 0.0) {\n    if (frame.skyBackground == 0u) {\n      return vec3<f32>(0.0);\n    }\n\n    if (frame.skyProgram != NO_PROGRAM) {\n      var input: ShaderInput;\n      input.data = frame.skyData;\n      input.direction = direction;\n      input.diffuseColor = vec4<f32>(1.0);\n\n      return runProgram(frame.skyProgram, input).color.rgb;\n    }\n\n    return environmentRadiance(direction) / frame.skyIntensity;\n  }\n\n  return environmentRadiance(direction);\n}\n\n/**\n * How much of the sky a bounce ray that escaped keeps. Direct sampling aims at the bright parts of an image too, so the\n * two share it; when direct sampling took all of it, as it does from a toon surface, the bounce keeps none.\n */\nfn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f32 {\n  if (frame.environmentPick <= 0.0) {\n    return 1.0;\n  }\n\n  if (lightsOwnDirect) {\n    return 0.0;\n  }\n\n  if (bsdfPdf <= 0.0) {\n    return 1.0;\n  }\n\n  return misWeight(bsdfPdf, frame.environmentPick * environmentPdf(direction));\n}\n\n/** Scales a contribution down to the luminance ceiling, which trades a little bias for the fireflies it removes. */\nfn clampIndirect(contribution: vec3<f32>) -> vec3<f32> {\n  let luminance = luminanceOf(contribution);\n\n  if (frame.clampIndirect <= 0.0 || luminance <= frame.clampIndirect) {\n    return contribution;\n  }\n\n  return contribution * (frame.clampIndirect / luminance);\n}\n\n/**\n * How much of the emission a bounce ray found the renderer keeps. Direct sampling had its own chance at this triangle,\n * and the heuristic splits the two so neither counts it twice.\n */\nfn emissionWeight(hit: Hit, direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f32 {\n  if (frame.areaLightCount == 0u) {\n    return 1.0;\n  }\n\n  let areaPdf = lightPdfOfTriangle(hit.triangle);\n\n  if (areaPdf <= 0.0) {\n    return 1.0;\n  }\n\n  if (lightsOwnDirect) {\n    return 0.0;\n  }\n\n  if (bsdfPdf <= 0.0) {\n    return 1.0;\n  }\n\n  let cosLight = max(abs(dot(triangleNormal(hit.triangle), direction)), 1e-6);\n\n  return misWeight(bsdfPdf, areaPdf * hit.distance * hit.distance / cosLight);\n}\n\n/** One shadow ray from the surface towards a light, weighted against the chance the bounce would have found it too. */\nfn directLight(\n  surface: Surface,\n  position: vec3<f32>,\n  view: vec3<f32>,\n  pick: f32,\n  u: vec2<f32>,\n  rng: ptr<function, PathSampler>,\n  diffusePart: ptr<function, vec3<f32>>) -> vec3<f32> {\n  *diffusePart = vec3<f32>(0.0);\n\n  let chosen = sampleLight(position, pick, u);\n\n  if (!chosen.valid) {\n    return vec3<f32>(0.0);\n  }\n\n  // A material with its own environment map sees that map in place of the scene's surroundings.\n  if (chosen.kind == LIGHT_ENVIRONMENT && surface.envMap != NO_TEXTURE) {\n    return vec3<f32>(0.0);\n  }\n\n  let reflected = evaluateBsdf(surface, view, chosen.direction);\n\n  if (all(reflected.value <= vec3<f32>(0.0))) {\n    return vec3<f32>(0.0);\n  }\n\n  let toon = surface.kind == KIND_TOON;\n  // Three's shadow map leaves a toon mesh's own far side unshadowed; tracing through the mesh would not.\n  let skip = select(NO_MATERIAL, surface.material, toon && dot(surface.normal, chosen.direction) < 0.1);\n  let through = lightTransmittance(position, chosen, rng, skip);\n\n  if (all(through <= vec3<f32>(0.0))) {\n    return vec3<f32>(0.0);\n  }\n\n  // A light that no bounce ray could have found keeps its whole contribution; an emissive triangle shares it. A toon\n  // surface takes all of its direct light this way, because its bounce is not the lobe that lit it.\n  let weight = select(1.0, misWeight(chosen.misPdf, reflected.pdf), chosen.misPdf > 0.0 && reflected.pdf > 0.0 && !toon);\n\n  let light = chosen.value * through * weight;\n\n  // The share of it the diffuse lobe reflects, which the denoiser filters apart from the specular one.\n  *diffusePart = min(diffuseValue(surface, view, chosen.direction), reflected.value) * light;\n\n  return reflected.value * light;\n}\n\n/** Three's fog factor at a view depth: linear between near and far, or exponential squared. */\nfn fogFactor(depth: f32, kind: f32) -> f32 {\n  if (kind == 2.0) {\n    let density = frame.fogParams.z;\n\n    return clamp(1.0 - exp(-density * density * depth * depth), 0.0, 1.0);\n  }\n\n  return smoothstep(frame.fogParams.x, frame.fogParams.y, depth);\n}\n\n/** The colour the diffuse signal is divided by at this surface; white where the surface shows what it emits. */\nfn diffuseGuide(surface: Surface) -> vec3<f32> {\n  if ((surface.flags & MATERIAL_LIT) == 0u) {\n    return vec3<f32>(1.0);\n  }\n\n  return surface.albedo * (1.0 - surface.metalness) * (1.0 - clamp(surface.transmission, 0.0, 1.0));\n}\n\nstruct PathResult {\n  radiance: vec3<f32>,\n  alpha: f32,\n  // How far along the camera ray the first surface it stopped at is, or 1e30 when it stopped at none.\n  depth: f32,\n  // The denoiser's two signals: what of the radiance came through the first surface's diffuse lobe (and what the camera\n  // sees directly), the rest being specular, and what guides each at that surface.\n  diffuse: vec3<f32>,\n  diffuseAlbedo: vec3<f32>,\n  specularAlbedo: vec3<f32>,\n  normal: vec3<f32>,\n  // Along the camera ray to the first surface, its roughness, and how far the specular continuation went from it.\n  guideDistance: f32,\n  roughness: f32,\n  specularDistance: f32,\n};\n\n/** How many surfaces a path may pass through without scattering (cutouts, culled faces, glass) before it gives up. */\nconst MAX_STEPS: u32 = 64u;\n\nfn traceRadiance(\n  rayOrigin: vec3<f32>, rayDirection: vec3<f32>, rayLength: f32, rng: ptr<function, PathSampler>) -> PathResult {\n  var radiance = vec3<f32>(0.0);\n  var throughput = vec3<f32>(1.0);\n  var origin = rayOrigin;\n  var direction = rayDirection;\n  var limit = rayLength;\n  // Solid angle density of the current direction; zero for the camera ray, which no light sampling competes with.\n  var bsdfPdf = 0.0;\n  // What the volume the ray is travelling through absorbs per unit of distance; zero outside any.\n  var absorption = vec3<f32>(0.0);\n  // Still on the camera's own line of sight, which transmission keeps a path on.\n  var primary = true;\n  // Still the camera ray itself, in a straight line: only this one is culled and clipped by the far plane.\n  var straight = true;\n  var alpha = 0.0;\n  var bounce = 0u;\n  // The vertex the path last scattered at took all of its direct light by sampling lights: a toon surface.\n  var lightsOwnDirect = false;\n  // That vertex's own environment map, which a ray escaping from it sees instead of the scene's.\n  var escapeMap = NO_TEXTURE;\n  var escapeIntensity = 1.0;\n  // Which colour a dispersive path carries, once a dispersive volume has split it; all three before that.\n  var channel = vec3<f32>(1.0);\n  // Three's fog, laid over everything the camera sees through the first surface.\n  var fogged = false;\n  var fogAmount = 0.0;\n  var fogStart = vec3<f32>(0.0);\n  var fogThroughput = vec3<f32>(0.0);\n  // A built-in material's hooks after <opaque_fragment> edit the colour the camera sees of it, which is everything the\n  // path gathers from that surface on.\n  var afterMaterial = NO_MATERIAL;\n  var afterTriangle = 0u;\n  var afterBary = vec2<f32>(0.0);\n  var afterDirection = vec3<f32>(0.0);\n  var afterAlbedo = vec4<f32>(0.0);\n  var afterStart = vec3<f32>(0.0);\n  var afterThroughput = vec3<f32>(0.0);\n  var depth = 1e30;\n  // The denoiser's guides, taken at the first surface the camera ray stops at.\n  var guided = false;\n  var diffuseAlbedo = vec3<f32>(1.0);\n  var specularAlbedoGuide = vec3<f32>(1.0);\n  var guideNormal = vec3<f32>(0.0);\n  var guideDistance = 1e6;\n  var guideRoughness = 1.0;\n  // Where the path first scattered, which decides which of the two signals the rest of it feeds.\n  var split = false;\n  var splitBase = vec3<f32>(0.0);\n  var splitDirect = vec3<f32>(0.0);\n  var splitDirectDiffuse = vec3<f32>(0.0);\n  var splitDiffuse = true;\n  var waitingForSpecular = false;\n  var specularDistance = 1e6;\n\n  for (var step = 0u; step < MAX_STEPS; step = step + 1u) {\n    let hit = traceScene(origin, direction, limit);\n\n    // The specular continuation's first hit: how far the reflection the denoiser filters actually is.\n    if (waitingForSpecular) {\n      specularDistance = select(min(hit.distance, 1e6), 1e6, hit.triangle == NO_HIT);\n      waitingForSpecular = false;\n    }\n\n    if (hit.triangle == NO_HIT) {\n      if (primary) {\n        // A transparent background leaves the pixel empty, which its alpha says.\n        if (frame.background.w != 2.0) {\n          alpha = 1.0;\n          radiance = radiance + throughput * backgroundRadiance(direction);\n        }\n      } else {\n        var sky = ambientRadiance(direction);\n\n        if (escapeMap != NO_TEXTURE) {\n          sky = sky + sampleEquirect(escapeMap, direction).rgb * escapeIntensity;\n        } else {\n          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect);\n        }\n\n        let contribution = throughput * sky;\n\n        radiance = radiance + select(contribution, clampIndirect(contribution), bounce > 1u);\n      }\n\n      break;\n    }\n\n    throughput = throughput * exp(-absorption * hit.distance);\n\n    let bary = vec2<f32>(hit.u, hit.v);\n    let point = origin + direction * hit.distance;\n    let m = materialIndexOf(hit.triangle);\n\n    // Every vertex draws the same dimensions in the same order, whatever the path then does with them.\n    let coverage = sample2D(rng);\n    let pick = sample2D(rng);\n    let lightSample = sample2D(rng);\n    let lobe = sample2D(rng);\n    let bounceSample = sample2D(rng);\n\n    // Three culls the side a material does not draw. Only the camera's rays are culled: a mesh still casts shadows and\n    // holds light in from both sides.\n    // A planar capture drops what lies behind its plane, for the camera's own ray.\n    let clipped = any(frame.clipPlane != vec4<f32>(0.0)) && dot(frame.clipPlane.xyz, point) + frame.clipPlane.w < 0.0;\n\n    if (straight && (clipped || isCulled(m, hit.triangle, direction))) {\n      origin = point + direction * RAY_EPSILON;\n      limit = limit - hit.distance;\n      continue;\n    }\n\n    if (isClipped(m, point)\n      || ((materials[m].flags & MATERIAL_WIREFRAME) != 0u && !onWireframe(hit.triangle, point))) {\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    let surface = resolveSurface(hit.triangle, bary, direction);\n\n    // Blending other than normal: the surface adds its light to, or filters, whatever is behind it, and the path goes on.\n    if (surface.blending == BLEND_ADDITIVE || surface.blending == BLEND_MULTIPLY || surface.blending == BLEND_SUBTRACTIVE) {\n      // Three blends these with the fragment's alpha whether or not the material is transparent.\n      let strength = surface.opacity * clamp(surface.alpha, 0.0, 1.0);\n      let color = select(surface.albedo, surface.emissive, (surface.flags & MATERIAL_LIT) == 0u);\n\n      if (surface.blending == BLEND_ADDITIVE) {\n        var added = surface.emissive;\n\n        if ((surface.flags & MATERIAL_LIT) != 0u) {\n          var unused: vec3<f32>;\n          added = added + directLight(surface, point + surface.normal * RAY_EPSILON, -direction, pick.x, lightSample, rng,\n            &unused);\n        }\n\n        radiance = radiance + throughput * added * strength;\n      } else if (surface.blending == BLEND_MULTIPLY) {\n        throughput = throughput * mix(vec3<f32>(1.0), color, strength);\n      } else {\n        throughput = throughput * (vec3<f32>(1.0) - color * strength);\n      }\n\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    // A surface that only partly covers its triangle lets the ray straight through the rest of the time. The direction\n    // does not change, so the density that found it still stands and the next hit is weighted against the same one.\n    if (surface.opacity < 1.0 && coverage.x >= surface.opacity) {\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    // Three's ShadowMaterial shows its colour only where a light is blocked, and nothing elsewhere.\n    if (surface.kind == KIND_SHADOW) {\n      let shadow = shadowMaskAt(point + surface.facing * RAY_EPSILON, rng);\n\n      if (coverage.y >= shadow * clamp(materials[m].color.w, 0.0, 1.0)) {\n        origin = point + direction * RAY_EPSILON;\n        limit = select(1e30, limit - hit.distance, straight);\n        continue;\n      }\n\n      if (primary) {\n        alpha = 1.0;\n      }\n\n      radiance = radiance + throughput * surface.albedo;\n      break;\n    }\n\n    if (straight && depth >= 1e30) {\n      depth = length(point - rayOrigin);\n    }\n\n    if (straight && !guided) {\n      guided = true;\n      diffuseAlbedo = diffuseGuide(surface);\n      specularAlbedoGuide = select(specularAlbedo(surface, -direction), vec3<f32>(1.0), (surface.flags & MATERIAL_LIT) == 0u);\n      guideNormal = surface.normal;\n      guideDistance = length(point - rayOrigin);\n      guideRoughness = surface.roughness;\n\n      if (surface.kind == KIND_PHONG) {\n        // Phong's exponent as the roughness of the GGX lobe that is about as wide.\n        guideRoughness = pow(2.0 / (surface.shininess + 2.0), 0.25);\n      }\n    }\n\n    if (primary) {\n      alpha = 1.0;\n\n      if (!fogged && afterMaterial == NO_MATERIAL && materials[m].afterProgram != NO_PROGRAM) {\n        afterMaterial = m;\n        afterTriangle = hit.triangle;\n        afterBary = bary;\n        afterDirection = direction;\n        afterAlbedo = vec4<f32>(surface.albedo, surface.alpha);\n        afterStart = radiance;\n        afterThroughput = throughput;\n      }\n\n      if (!fogged) {\n        let everySurface = frame.fogParams.w > 0.0;\n        let kind = frame.fogColor.w;\n\n        if (everySurface || (kind > 0.0 && (surface.flags & MATERIAL_FOG) != 0u)) {\n          let depth = -(frame.worldToCamera * vec4<f32>(point, 1.0)).z;\n\n          fogged = true;\n          fogAmount = fogFactor(depth, select(kind, 1.0, everySurface));\n          fogStart = radiance;\n          fogThroughput = throughput;\n        }\n      }\n\n      radiance = radiance + throughput * surface.lightMap;\n    }\n\n    if (any(surface.emissive > vec3<f32>(0.0))) {\n      let contribution = throughput * surface.emissive * emissionWeight(hit, direction, bsdfPdf, lightsOwnDirect);\n\n      // Seen by the camera or one bounce away this is direct light and stays exact; deeper it may be clamped.\n      radiance = radiance + select(contribution, clampIndirect(contribution), bounce > 1u);\n    }\n\n    // Three does not light a basic, points, line or sprite material, so nothing carries on from one.\n    if ((surface.flags & MATERIAL_LIT) == 0u || bounce >= frame.bounces) {\n      break;\n    }\n\n    // Lambert and Phong blend their own environment map over the lit colour, which here is a share of the path.\n    if (surface.legacyAmount > 0.0) {\n      let amount = surface.legacyAmount;\n\n      if (surface.combine == 1u) {\n        radiance = radiance + throughput * surface.legacyEnv * amount;\n        throughput = throughput * (1.0 - amount);\n      } else if (surface.combine == 2u) {\n        radiance = radiance + throughput * surface.legacyEnv * amount;\n      } else {\n        throughput = throughput * mix(vec3<f32>(1.0), surface.legacyEnv, amount);\n      }\n    }\n\n    let view = -direction;\n    var next = direction;\n    var nextOrigin = point + direction * RAY_EPSILON;\n\n    // Transmission replaces part of the diffuse layer, so that share of the time the surface is a dielectric instead.\n    // Choosing it in proportion to its weight leaves both halves unweighted, and only the opaque half aims at a light.\n    if (surface.transmission > 0.0 && lobe.y < surface.transmission) {\n      var ior = surface.ior;\n\n      // Three's dispersion: each colour refracts with its own index, spread around the material's. The path picks one\n      // colour the first time it enters such a volume and carries only that one from then on.\n      if (surface.dispersion > 0.0 && surface.thickness > 0.0) {\n        if (all(channel == vec3<f32>(1.0))) {\n          let which = min(u32(coverage.y * 3.0), 2u);\n\n          channel = vec3<f32>(select(0.0, 1.0, which == 0u), select(0.0, 1.0, which == 1u), select(0.0, 1.0, which == 2u));\n          throughput = throughput * channel * 3.0;\n        }\n\n        let spread = (ior - 1.0) * 0.025 * surface.dispersion;\n\n        ior = dot(channel, vec3<f32>(ior - spread, ior, ior + spread));\n      }\n\n      let crossing = sampleDielectric(surface, view, ior, lobe.y / surface.transmission, bounceSample);\n\n      if (!crossing.valid) {\n        break;\n      }\n\n      // Bending or reflecting off glass is the specular signal.\n      if (!split && !crossing.straight) {\n        split = true;\n        splitBase = radiance;\n        splitDiffuse = false;\n        waitingForSpecular = true;\n      }\n\n      throughput = throughput * crossing.weight;\n\n      // Straight through a thin wall the direction stands, and with it the density that will weigh the next hit.\n      if (!crossing.straight) {\n        straight = false;\n        next = crossing.direction;\n        nextOrigin = point + surface.normal * select(RAY_EPSILON, -RAY_EPSILON, crossing.crossed);\n        // A direction no light sampling could have produced: whatever the path finds next keeps its whole value.\n        bsdfPdf = 0.0;\n        lightsOwnDirect = false;\n        escapeMap = surface.envMap;\n        escapeIntensity = surface.envMapIntensity;\n\n        if (crossing.crossed) {\n          absorption = select(vec3<f32>(0.0), surface.absorption, surface.front);\n        } else {\n          primary = false;\n        }\n      }\n\n      if (!primary) {\n        bounce = bounce + 1u;\n      }\n    } else {\n      let position = point + surface.normal * RAY_EPSILON;\n      var directDiffuse: vec3<f32>;\n      let direct = throughput * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse);\n      let added = select(direct, clampIndirect(direct), bounce > 0u);\n      let before = radiance;\n\n      radiance = radiance + added;\n\n      let scattered = sampleBsdf(surface, view, lobe.x, bounceSample);\n\n      // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.\n      if (!split) {\n        split = true;\n        splitBase = before;\n        splitDirect = added;\n        splitDirectDiffuse = throughput * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),\n          bounce > 0u);\n        splitDiffuse = !scattered.valid || scattered.diffuse;\n        waitingForSpecular = scattered.valid && !scattered.diffuse;\n      }\n\n      if (!scattered.valid) {\n        break;\n      }\n\n      throughput = throughput * scattered.weight;\n      bsdfPdf = scattered.pdf;\n      lightsOwnDirect = surface.kind == KIND_TOON;\n      escapeMap = surface.envMap;\n      escapeIntensity = surface.envMapIntensity;\n      next = scattered.direction;\n      nextOrigin = position;\n      primary = false;\n      straight = false;\n      bounce = bounce + 1u;\n    }\n\n    // A path that carries almost nothing is ended by chance rather than by a cut, which keeps the estimate unbiased.\n    let survival = max(throughput.r, max(throughput.g, throughput.b));\n\n    if (survival <= 0.0) {\n      break;\n    }\n\n    if (survival < 0.2) {\n      if (pick.y > survival) {\n        break;\n      }\n\n      throughput = throughput / survival;\n    }\n\n    origin = nextOrigin;\n    limit = select(1e30, limit - hit.distance, straight);\n    direction = next;\n  }\n\n  // The diffuse signal: everything before the first scatter, its diffuse direct light, and the rest if the diffuse lobe\n  // carried the path on. A path that never scattered is all diffuse, which is what the camera sees directly.\n  var diffuse = radiance;\n\n  if (split) {\n    let after = radiance - splitBase - splitDirect;\n    diffuse = splitBase + splitDirectDiffuse + select(vec3<f32>(0.0), after, splitDiffuse);\n  }\n\n  if (afterMaterial != NO_MATERIAL && all(afterThroughput > vec3<f32>(0.0))) {\n    var input = shaderInputAt(afterMaterial, afterTriangle, afterBary, afterDirection);\n    input.data = materials[afterMaterial].afterData;\n    input.diffuseColor = afterAlbedo;\n    input.fragColor = vec4<f32>((radiance - afterStart) / afterThroughput, 1.0);\n\n    let edited = runProgram(materials[afterMaterial].afterProgram, input);\n\n    radiance = afterStart + afterThroughput * edited.color.rgb;\n    // A hook rewrites the colour as a whole: there is no split left to keep.\n    diffuse = radiance;\n  }\n\n  // Three lays its fog after the hooks, over what they made of the surface.\n  if (fogged) {\n    let fog = frame.fogColor.rgb * fogThroughput * fogAmount;\n\n    radiance = fogStart + (radiance - fogStart) * (1.0 - fogAmount) + fog;\n    // What came before the fogged surface is diffuse, so the fog's own colour joins that signal.\n    diffuse = fogStart + (diffuse - fogStart) * (1.0 - fogAmount) + fog;\n  }\n\n  var result: PathResult;\n  result.radiance = radiance;\n  result.alpha = alpha;\n  result.depth = depth;\n  result.diffuse = diffuse;\n  result.diffuseAlbedo = diffuseAlbedo;\n  result.specularAlbedo = specularAlbedoGuide;\n  result.normal = guideNormal;\n  result.guideDistance = guideDistance;\n  result.roughness = guideRoughness;\n  result.specularDistance = specularDistance;\n\n  return result;\n}\n\n/** A point on the lens: a disk, or Three-free polygon bokeh shaped as the CPU renderer shapes it. */\nfn lensPoint(u: vec2<f32>) -> vec2<f32> {\n  var radius = sqrt(u.x) * frame.lens.x;\n  let angle = u.y * 2.0 * PI;\n  let blades = frame.lens.z;\n\n  if (blades >= 3.0) {\n    let wedge = 2.0 * PI / blades;\n    radius = radius * cos(PI / blades) / cos((angle - floor(angle / wedge) * wedge) - PI / blades);\n  }\n\n  return vec2<f32>(cos(angle), sin(angle)) * radius;\n}\n\n/**\n * Where a sample's camera ray starts, which way it points and how far it may go, for any camera: the ray is cast through\n * the inverse of the camera's own projection, from the near plane to the far one, which clip it as Three clips a\n * fragment. A lens moves the origin across its aperture and aims at the point in focus.\n */\nfn cameraRay(pixel: vec2<u32>, jitter: vec2<f32>, lens: vec2<f32>) -> array<vec4<f32>, 2> {\n  let uv = (vec2<f32>(pixel) + jitter) / vec2<f32>(frame.resolution);\n  let ndc = vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n  let ray = ndcRay(ndc);\n\n  if (frame.lens.x <= 0.0 || frame.cameraKind == 1u) {\n    return ray;\n  }\n\n  let position = frame.cameraToWorld[3].xyz;\n  let forward = -normalize(frame.cameraToWorld[2].xyz);\n  let focus = position + ray[1].xyz * (frame.lens.y / max(dot(ray[1].xyz, forward), 1e-6));\n  let offset = lensPoint(lens);\n  let origin = position + normalize(frame.cameraToWorld[0].xyz) * offset.x + normalize(frame.cameraToWorld[1].xyz) * offset.y;\n\n  return array<vec4<f32>, 2>(vec4<f32>(origin, 0.0), vec4<f32>(normalize(focus - origin), 1e30));\n}\n\n/** The window depth GL would store for the first surface the camera ray stopped at: one where it stopped at none. */\nfn windowDepth(point: vec3<f32>, distance: f32) -> f32 {\n  if (distance >= 1e30) {\n    return 1.0;\n  }\n\n  let clip = frame.projection * (frame.worldToCamera * vec4<f32>(point, 1.0));\n\n  return clamp(clip.z / clip.w * 0.5 + 0.5, 0.0, 1.0);\n}\n\n/** smoothstep as the CPU renderer writes it, which also holds when the two edges meet. */\nfn edge(low: f32, high: f32, value: f32) -> f32 {\n  let t = select(select(0.0, 1.0, value >= high), clamp((value - low) / (high - low), 0.0, 1.0), high > low);\n\n  return t * t * (3.0 - 2.0 * t);\n}\n\n/** How much of what lies at this point the fog lets through to the camera. */\nfn fogVisibility(point: vec3<f32>) -> f32 {\n  let everySurface = frame.fogParams.w > 0.0;\n  let kind = frame.fogColor.w;\n\n  if (!everySurface && kind <= 0.0) {\n    return 1.0;\n  }\n\n  let depth = -(frame.worldToCamera * vec4<f32>(point, 1.0)).z;\n\n  return 1.0 - fogFactor(depth, select(kind, 1.0, everySurface));\n}\n\n/** The most volumetric lights one view ray marches through. */\nconst MAX_VOLUMETRIC: u32 = 8u;\n\n/**\n * Steps of one march. The CPU renderer marches 64 once per pixel; here every path marches, a few hundred times a\n * pixel, each at its own random offset, so a few steps a path add up to a finer integral than 64 once, at a fraction of\n * the shadow rays.\n */\nconst MARCH_STEPS: u32 = 8u;\n\n/**\n * The CPU renderer's volumetric lights (volumetricLight.js): one march across the union of every light's\n * reach along the view ray, Henyey-Greenstein scattering towards the camera, a shadow ray for a spot light that casts\n * one, and the same compression of the sum before it is added over the image.\n */\nfn volumetricGlow(origin: vec3<f32>, direction: vec3<f32>, distance: f32, jitter: f32) -> vec3<f32> {\n  let count = min(frame.volumetricCount, MAX_VOLUMETRIC);\n  let far = min(distance, 40.0);\n  var tStart = far;\n  var tEnd = 0.0;\n\n  for (var k = 0u; k < count; k = k + 1u) {\n    let at = frame.volumetricData + k * 20u;\n    let position = extraVec4(at).xyz;\n    let spot = extraFloat(at + 3u) > 0.5;\n    let axis = extraVec4(at + 4u).xyz;\n    let radius = extraFloat(at + 7u);\n    let outer = extraFloat(at + 15u);\n    let delta = origin - position;\n    let b = dot(delta, direction);\n    let disc = b * b - dot(delta, delta) + radius * radius;\n\n    if (disc <= 0.0) {\n      continue;\n    }\n\n    let start = max(0.0, -b - sqrt(disc));\n    let end = min(far, -b + sqrt(disc));\n\n    if (end <= start) {\n      continue;\n    }\n\n    var cuts = array<f32, 4>(start, end, end, end);\n    var cutCount = 2u;\n    let cone = cos(outer);\n\n    if (spot) {\n      let ar = dot(axis, direction);\n      let ac = dot(axis, delta);\n      let cos2 = cone * cone;\n      let qa = ar * ar - cos2;\n      let qb = ar * ac - dot(direction, delta) * cos2;\n      let qc = ac * ac - dot(delta, delta) * cos2;\n      let discriminant = qb * qb - qa * qc;\n      var roots = array<f32, 2>(-1.0, -1.0);\n\n      if (abs(qa) < 1e-8) {\n        if (abs(qb) > 1e-8) {\n          roots[0] = -qc / (2.0 * qb);\n        }\n      } else if (discriminant >= 0.0) {\n        roots[0] = (-qb - sqrt(discriminant)) / qa;\n        roots[1] = (-qb + sqrt(discriminant)) / qa;\n      }\n\n      for (var r = 0u; r < 2u; r = r + 1u) {\n        if (roots[r] > start && roots[r] < end) {\n          cuts[cutCount] = roots[r];\n          cutCount = cutCount + 1u;\n        }\n      }\n\n      // Sort the few cuts in place.\n      for (var i = 1u; i < cutCount; i = i + 1u) {\n        var j = i;\n\n        loop {\n          if (j == 0u || cuts[j - 1u] <= cuts[j]) {\n            break;\n          }\n\n          let swap = cuts[j];\n          cuts[j] = cuts[j - 1u];\n          cuts[j - 1u] = swap;\n          j = j - 1u;\n        }\n      }\n    }\n\n    for (var segment = 1u; segment < cutCount; segment = segment + 1u) {\n      let lo = cuts[segment - 1u];\n      let hi = cuts[segment];\n\n      if (spot && dot(normalize(delta + direction * ((lo + hi) * 0.5)), axis) < cone) {\n        continue;\n      }\n\n      tStart = min(tStart, lo);\n      tEnd = max(tEnd, hi);\n    }\n  }\n\n  if (tEnd <= tStart) {\n    return vec3<f32>(0.0);\n  }\n\n  let step = (tEnd - tStart) / f32(MARCH_STEPS);\n  var transmittance: array<f32, 8>;\n\n  for (var k = 0u; k < count; k = k + 1u) {\n    transmittance[k] = exp(-extraFloat(frame.volumetricData + k * 20u + 11u) * tStart);\n  }\n\n  var result = vec3<f32>(0.0);\n\n  for (var i = 0u; i < MARCH_STEPS; i = i + 1u) {\n    let t = tStart + (f32(i) + jitter) * step;\n    let p = origin + direction * t;\n    let fogged = fogVisibility(p);\n\n    if (fogged <= 0.0001) {\n      break;\n    }\n\n    var lit = false;\n\n    for (var k = 0u; k < count; k = k + 1u) {\n      if (transmittance[k] <= 0.003) {\n        continue;\n      }\n\n      lit = true;\n\n      let at = frame.volumetricData + k * 20u;\n      let position = extraVec4(at).xyz;\n      let spot = extraFloat(at + 3u) > 0.5;\n      let axis = extraVec4(at + 4u).xyz;\n      let color = extraVec4(at + 8u).rgb;\n      let density = extraFloat(at + 11u);\n      let angle = extraFloat(at + 12u);\n      let penumbra = extraFloat(at + 13u);\n      let range = extraFloat(at + 14u);\n      let outer = extraFloat(at + 15u);\n      let spread = extraFloat(at + 16u);\n      let anisotropy = extraFloat(at + 17u);\n      let casts = extraFloat(at + 18u) > 0.5;\n      let toLight = position - p;\n      let dist = length(toLight);\n      let toward = toLight / max(dist, 1e-20);\n      var attenuation = exp(-dist / (select(10.0, range, range > 0.0) * 0.3));\n\n      if (range > 0.0) {\n        attenuation = attenuation * (1.0 - edge(range * 0.8, range, dist));\n      }\n\n      if (spot) {\n        let along = -dot(toward, axis);\n        let inner = cos(angle * (1.0 - penumbra));\n        let core = edge(cos(angle), inner, along);\n        let scattered = spread * pow(edge(cos(outer), inner, along), 2.0);\n\n        attenuation = attenuation * select(core, max(core, scattered), spread > 0.0);\n      }\n\n      if (attenuation <= 0.0001) {\n        continue;\n      }\n\n      // Shadowing follows Three's volumetric lights, which only have shadow maps for spots.\n      if (spot && casts && frame.shadowsEnabled != 0u && traceAny(p, toward, dist * (1.0 - 1e-3)) != NO_HIT) {\n        continue;\n      }\n\n      let cosine = dot(toward, direction);\n      let g = anisotropy;\n      let phase = select((1.0 - g * g) / pow(1.0 + g * g - 2.0 * g * cosine, 1.5), 1.0, g == 0.0);\n\n      // The air between the camera and this point, exactly: a long step evaluated at its start would overstate it.\n      result = result + color * (attenuation * density * step * exp(-density * t) * fogged * phase * 1.5);\n    }\n\n    if (!lit) {\n      break;\n    }\n\n    for (var k = 0u; k < count; k = k + 1u) {\n      transmittance[k] = transmittance[k] * exp(-extraFloat(frame.volumetricData + k * 20u + 11u) * step);\n    }\n  }\n\n  return result / (vec3<f32>(1.0) + result);\n}\n\n/**\n * How far a pixel's estimate may still be from its mean: the standard error of its luminance, over the square root of\n * the luminance, which is roughly how visible that error is once the image is encoded for display.\n */\nfn pixelError(pixel: vec2<u32>) -> f32 {\n  let index = pixel.y * frame.resolution.x + pixel.x;\n  let sum = accumulation[index];\n\n  if (sum.w < 2.0) {\n    return 1e30;\n  }\n\n  let squares = accumulation[frame.pixelCount + index];\n  let diffuse = accumulation[4u * frame.pixelCount + index].rgb;\n\n  // Each of the denoiser's signals has its own variance; the pixel has converged when both have.\n  return max(\n    channelError(luminanceOf(diffuse) / sum.w, squares.z / sum.w, sum.w),\n    channelError(luminanceOf(sum.rgb - diffuse) / sum.w, squares.w / sum.w, sum.w));\n}\n\nfn channelError(mean: f32, square: f32, samples: f32) -> f32 {\n  let variance = max(square - mean * mean, 0.0);\n\n  return sqrt(variance / samples) / sqrt(max(mean, 0.0) + 1e-3);\n}\n\n/**\n * Whether a pixel has converged, judged over its neighbourhood: a rare bright path lands in one pixel, and a pixel\n * judged alone would stop where its neighbours had not yet seen one and leave that area too dark.\n */\nfn converged(pixel: vec2<u32>) -> bool {\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let x = clamp(i32(pixel.x) + dx, 0, i32(frame.resolution.x) - 1);\n      let y = clamp(i32(pixel.y) + dy, 0, i32(frame.resolution.y) - 1);\n\n      if (pixelError(vec2<u32>(u32(x), u32(y))) > frame.adaptiveThreshold) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= frame.bandSize.x || id.y >= frame.bandSize.y) {\n    return;\n  }\n\n  let pixel = frame.bandOrigin + id.xy;\n\n  if (pixel.x >= frame.resolution.x || pixel.y >= frame.resolution.y) {\n    return;\n  }\n\n  let index = pixel.y * frame.resolution.x + pixel.x;\n\n  // Adaptive sampling: a pixel whose neighbourhood has converged takes no more samples, which leaves the pass to\n  // the pixels that still need them.\n  if (frame.adaptiveMin > 0u && accumulation[index].w >= f32(frame.adaptiveMin) && converged(pixel)) {\n    return;\n  }\n\n  var radiance = vec3<f32>(0.0);\n  var alpha = 0.0;\n  var depthSum = 0.0;\n  var diffuseSquares = 0.0;\n  var specularSquares = 0.0;\n  var diffuseSum = vec3<f32>(0.0);\n  var diffuseAlbedoSum = vec3<f32>(0.0);\n  var specularAlbedoSum = vec3<f32>(0.0);\n  var normalSum = vec3<f32>(0.0);\n  var distanceSum = 0.0;\n  var roughnessSum = 0.0;\n  var specularDistanceSum = 0.0;\n\n  for (var s = 0u; s < frame.sampleCount; s = s + 1u) {\n    var rng = makeSampler(pixel, frame.sampleIndex + s);\n    let jitter = sample2D(&rng);\n    let lens = sample2D(&rng);\n    let ray = cameraRay(pixel, jitter, lens);\n    let result = traceRadiance(ray[0].xyz, ray[1].xyz, ray[1].w, &rng);\n    var sampleAlpha = result.alpha;\n\n    var sampled = result.radiance;\n    var sampledDiffuse = result.diffuse;\n\n    if (frame.volumetricCount > 0u) {\n      let glow = volumetricGlow(ray[0].xyz, ray[1].xyz, result.depth, sample2D(&rng).x);\n\n      // As the CPU renderer composites it: added over the image, and raising the coverage just enough to hold it.\n      sampled = sampled + glow;\n      sampledDiffuse = sampledDiffuse + glow;\n      sampleAlpha = max(sampleAlpha, max3(glow));\n    }\n\n    let sampledSpecular = sampled - sampledDiffuse;\n\n    radiance = radiance + sampled;\n    diffuseSum = diffuseSum + sampledDiffuse;\n    diffuseSquares = diffuseSquares + luminanceOf(sampledDiffuse) * luminanceOf(sampledDiffuse);\n    specularSquares = specularSquares + luminanceOf(sampledSpecular) * luminanceOf(sampledSpecular);\n    diffuseAlbedoSum = diffuseAlbedoSum + result.diffuseAlbedo;\n    specularAlbedoSum = specularAlbedoSum + result.specularAlbedo;\n    normalSum = normalSum + result.normal;\n    distanceSum = distanceSum + result.guideDistance;\n    roughnessSum = roughnessSum + result.roughness;\n    specularDistanceSum = specularDistanceSum + result.specularDistance;\n\n    alpha = alpha + sampleAlpha;\n    depthSum = depthSum + windowDepth(ray[0].xyz + ray[1].xyz * min(result.depth, 1e20), result.depth);\n  }\n\n  let coverage = accumulation[frame.pixelCount + index];\n  accumulation[index] = accumulation[index] + vec4<f32>(radiance, f32(frame.sampleCount));\n  accumulation[frame.pixelCount + index] = vec4<f32>(\n    coverage.x + alpha, coverage.y + depthSum, coverage.z + diffuseSquares, coverage.w + specularSquares);\n  // The denoiser's signals and guides, summed like the radiance so they average over the pixel's samples.\n  let pc = frame.pixelCount;\n  accumulation[2u * pc + index] = accumulation[2u * pc + index] + vec4<f32>(diffuseAlbedoSum, roughnessSum);\n  accumulation[3u * pc + index] = accumulation[3u * pc + index] + vec4<f32>(normalSum, distanceSum);\n  accumulation[4u * pc + index] = accumulation[4u * pc + index] + vec4<f32>(diffuseSum, specularDistanceSum);\n  accumulation[5u * pc + index] = accumulation[5u * pc + index] + vec4<f32>(specularAlbedoSum, 0.0);\n  // This row still has work: every pixel that traced writes the same value, so the race is harmless.\n  accumulation[6u * pc + pixel.y] = vec4<f32>(1.0);\n}\n";
+export declare const PATH_TRACE_WGSL = "\n/** Light from an ambient or hemisphere light, which this renderer turns into an equally bright surrounding. */\nfn ambientRadiance(direction: vec3<f32>) -> vec3<f32> {\n  let latitude = clamp(dot(direction, frame.ambientAxis.xyz) * 0.5 + 0.5, 0.0, 1.0);\n\n  return mix(frame.ambientGround.rgb, frame.ambientSky.rgb, latitude) + probeRadiance(direction);\n}\n\n/**\n * A LightProbe's light. Three's coefficients are radiance projected on the SH3 basis, which its shader convolves with\n * the cosine to get irradiance; evaluated directly they are the surrounding that delivers exactly that irradiance.\n */\nfn probeRadiance(d: vec3<f32>) -> vec3<f32> {\n  let radiance = frame.probe0.rgb * 0.282095\n    + frame.probe1.rgb * (0.488603 * d.y)\n    + frame.probe2.rgb * (0.488603 * d.z)\n    + frame.probe3.rgb * (0.488603 * d.x)\n    + frame.probe4.rgb * (1.092548 * d.x * d.y)\n    + frame.probe5.rgb * (1.092548 * d.y * d.z)\n    + frame.probe6.rgb * (0.315392 * (3.0 * d.z * d.z - 1.0))\n    + frame.probe7.rgb * (1.092548 * d.x * d.z)\n    + frame.probe8.rgb * (0.546274 * (d.x * d.x - d.y * d.y));\n\n  return max(radiance, vec3<f32>(0.0));\n}\n\n/** What the camera sees where nothing is in the way, as the background setting says. */\nfn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {\n  if (frame.background.w == 1.0) {\n    return frame.background.rgb;\n  }\n\n  // A procedural sky paints the background without the strength it lights with, and its foreground over it.\n  if (frame.skyProgram != NO_PROGRAM || frame.skyIntensity > 0.0) {\n    if (frame.skyBackground == 0u) {\n      return vec3<f32>(0.0);\n    }\n\n    if (frame.skyProgram != NO_PROGRAM) {\n      var input: ShaderInput;\n      input.data = frame.skyData;\n      input.direction = direction;\n      input.diffuseColor = vec4<f32>(1.0);\n\n      return runProgram(frame.skyProgram, input).color.rgb;\n    }\n\n    return environmentRadiance(direction) / frame.skyIntensity;\n  }\n\n  return environmentRadiance(direction);\n}\n\n/**\n * How much of the sky a bounce ray that escaped keeps. Direct sampling aims at the bright parts of an image too, so the\n * two share it; when direct sampling took all of it, as it does from a toon surface, the bounce keeps none.\n */\nfn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f32 {\n  if (frame.environmentPick <= 0.0) {\n    return 1.0;\n  }\n\n  if (lightsOwnDirect) {\n    return 0.0;\n  }\n\n  if (bsdfPdf <= 0.0) {\n    return 1.0;\n  }\n\n  return misWeight(bsdfPdf, frame.environmentPick * environmentPdf(direction));\n}\n\n/** Scales a contribution down to the luminance ceiling, which trades a little bias for the fireflies it removes. */\nfn clampIndirect(contribution: vec3<f32>) -> vec3<f32> {\n  let luminance = luminanceOf(contribution);\n\n  if (frame.clampIndirect <= 0.0 || luminance <= frame.clampIndirect) {\n    return contribution;\n  }\n\n  return contribution * (frame.clampIndirect / luminance);\n}\n\n/**\n * How much of the emission a bounce ray found the renderer keeps. Direct sampling had its own chance at this triangle,\n * and the heuristic splits the two so neither counts it twice.\n */\nfn emissionWeight(hit: Hit, direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool, scatteredAt: vec3<f32>,\n  normal: vec3<f32>) -> f32 {\n  if (frame.areaLightCount == 0u) {\n    return 1.0;\n  }\n\n  // From the vertex the bounce left, which is where direct sampling would have picked it from.\n  let areaPdf = lightPdfOfTriangle(hit.triangle, scatteredAt, normal);\n\n  if (areaPdf <= 0.0) {\n    return 1.0;\n  }\n\n  if (lightsOwnDirect) {\n    return 0.0;\n  }\n\n  if (bsdfPdf <= 0.0) {\n    return 1.0;\n  }\n\n  let cosLight = max(abs(dot(triangleNormal(hit.triangle), direction)), 1e-6);\n\n  return misWeight(bsdfPdf, areaPdf * hit.distance * hit.distance / cosLight);\n}\n\n/**\n * The normal the light tree weighs lights by, or none where light from behind the surface counts too: a point in a\n * volume, a toon ramp read all round, a clearcoat that may face what its base turns from, and transmission.\n */\nfn treeNormal(surface: Surface) -> vec3<f32> {\n  if (surface.kind == KIND_VOLUME || surface.kind == KIND_TOON || surface.clearcoat > 0.0 || surface.transmission > 0.0) {\n    return vec3<f32>(0.0);\n  }\n\n  return surface.normal;\n}\n\n/** One shadow ray from the surface towards a light, weighted against the chance the bounce would have found it too. */\nfn directLight(\n  surface: Surface,\n  position: vec3<f32>,\n  view: vec3<f32>,\n  pick: f32,\n  u: vec2<f32>,\n  rng: ptr<function, PathSampler>,\n  diffusePart: ptr<function, vec3<f32>>,\n  medium: f32) -> vec3<f32> {\n  *diffusePart = vec3<f32>(0.0);\n\n  let chosen = sampleLight(position, treeNormal(surface), pick, u);\n\n  if (!chosen.valid) {\n    return vec3<f32>(0.0);\n  }\n\n  // A material with its own environment map sees that map in place of the scene's surroundings.\n  if (chosen.kind == LIGHT_ENVIRONMENT && surface.envMap != NO_TEXTURE) {\n    return vec3<f32>(0.0);\n  }\n\n  let reflected = evaluateBsdf(surface, view, chosen.direction);\n\n  if (all(reflected.value <= vec3<f32>(0.0))) {\n    return vec3<f32>(0.0);\n  }\n\n  let toon = surface.kind == KIND_TOON;\n  // Three's shadow map leaves a toon mesh's own far side unshadowed; tracing through the mesh would not.\n  let skip = select(NO_MATERIAL, surface.material, toon && dot(surface.normal, chosen.direction) < 0.1);\n  let through = lightTransmittance(position, chosen, rng, skip, medium);\n\n  if (all(through <= vec3<f32>(0.0))) {\n    return vec3<f32>(0.0);\n  }\n\n  // A light that no bounce ray could have found keeps its whole contribution; an emissive triangle shares it. A toon\n  // surface takes all of its direct light this way, because its bounce is not the lobe that lit it.\n  let weight = select(1.0, misWeight(chosen.misPdf, reflected.pdf), chosen.misPdf > 0.0 && reflected.pdf > 0.0 && !toon);\n\n  let light = chosen.value * through * weight;\n\n  // The share of it the diffuse lobe reflects, which the denoiser filters apart from the specular one.\n  *diffusePart = min(diffuseValue(surface, view, chosen.direction), reflected.value) * light;\n\n  return reflected.value * light;\n}\n\n/** Three's fog factor at a view depth: linear between near and far, or exponential squared. */\nfn fogFactor(depth: f32, kind: f32) -> f32 {\n  if (kind == 2.0) {\n    let density = frame.fogParams.z;\n\n    return clamp(1.0 - exp(-density * density * depth * depth), 0.0, 1.0);\n  }\n\n  return smoothstep(frame.fogParams.x, frame.fogParams.y, depth);\n}\n\n/** The colour the diffuse signal is divided by at this surface; white where the surface shows what it emits. */\nfn diffuseGuide(surface: Surface) -> vec3<f32> {\n  if ((surface.flags & MATERIAL_LIT) == 0u) {\n    return vec3<f32>(1.0);\n  }\n\n  return surface.albedo * (1.0 - surface.metalness) * (1.0 - clamp(surface.transmission, 0.0, 1.0));\n}\n\n/**\n * How often a vertex on a material that scatters inside takes the walk into it instead of its surface lobes: by the\n * share of the light each accounts for, as lobeWeights chooses between lobes. Never all of the time, so the specular\n * layer on top stays reachable.\n */\nfn subsurfaceChance(surface: Surface, view: vec3<f32>) -> f32 {\n  if (surface.subsurface <= 0.0 || (surface.flags & MATERIAL_PBR) == 0u) {\n    return 0.0;\n  }\n\n  let diffuse = luminanceOf(surface.albedo * (1.0 - surface.metalness)) * coatTransmittance(surface, view);\n  let inside = diffuse * surface.subsurface;\n  let outside = diffuse * (1.0 - surface.subsurface) + luminanceOf(specularAlbedo(surface, view)) + 0.02;\n\n  return clamp(inside / max(inside + outside, 1e-6), 0.0, 0.95);\n}\n\n/**\n * The single scattering albedo that gives this multiple scattering albedo in a semi-infinite medium: van de Hulst's\n * relation, inverted as Cycles inverts it for its random walk. What the material's colour says it reflects in all\n * is what light keeps at each scattering inside it.\n */\nfn subsurfaceAlbedo(albedo: vec3<f32>) -> vec3<f32> {\n  let a = clamp(albedo, vec3<f32>(0.0), vec3<f32>(0.999));\n  let s = 4.09712 + 4.20863 * a - sqrt(9.59217 + 41.6808 * a + 17.7126 * a * a);\n\n  return vec3<f32>(1.0) - s * s;\n}\n\n/**\n * How far the walk goes before it next scatters, drawn for one colour picked in proportion to what the path still\n * carries of it. choice keeps those odds, which the next step weighs its distance by over all three colours, so each\n * colour keeps its own mean free path and the estimate stays exact (spectral MIS, as Cycles' random walk does it).\n */\nfn walkDistance(throughput: vec3<f32>, sigma: vec3<f32>, u: vec2<f32>, choice: ptr<function, vec3<f32>>) -> f32 {\n  let weights = max(throughput, vec3<f32>(0.0));\n  let total = weights.x + weights.y + weights.z;\n  let odds = select(vec3<f32>(1.0 / 3.0), weights / total, total > 0.0);\n  let chosen = select(select(sigma.z, sigma.y, u.x < odds.x + odds.y), sigma.x, u.x < odds.x);\n\n  *choice = odds;\n\n  return -log(max(1.0 - u.y, 1e-12)) / chosen;\n}\n\n/**\n * Where a walk leaves the material: a white Lambert surface facing out, as Cycles leaves its random walk. The colour\n * was taken inside, scattering by scattering, so nothing tints the light again on the way out.\n */\nfn subsurfaceExit(m: u32, triangle: u32, bary: vec2<f32>, direction: vec3<f32>) -> Surface {\n  var surface: Surface;\n  // Turned to face against the reversed ray: outwards, the side the walk is leaving through.\n  let out = interpolatedNormal(m, triangle, bary, -direction);\n\n  surface.normal = out;\n  surface.facing = out;\n  surface.albedo = vec3<f32>(1.0);\n  surface.flags = MATERIAL_LIT;\n  surface.kind = KIND_LAMBERT;\n  surface.opacity = 1.0;\n  surface.alpha = 1.0;\n  surface.blending = BLEND_NORMAL;\n  surface.material = m;\n  surface.roughness = 1.0;\n  surface.ior = 1.5;\n  surface.specularF90 = 1.0;\n  surface.envMap = NO_TEXTURE;\n  surface.envMapIntensity = 1.0;\n  surface.gradientMap = NO_TEXTURE;\n\n  return surface;\n}\n\n/** A point inside a volume where the light scatters: the medium's phase function in place of a surface's lobes. */\nfn volumePoint(direction: vec3<f32>, albedo: vec3<f32>, anisotropy: f32) -> Surface {\n  var surface: Surface;\n\n  surface.normal = -direction;\n  surface.facing = -direction;\n  surface.albedo = albedo;\n  surface.flags = MATERIAL_LIT;\n  surface.kind = KIND_VOLUME;\n  surface.anisotropy = anisotropy;\n  surface.opacity = 1.0;\n  surface.alpha = 1.0;\n  surface.blending = BLEND_NORMAL;\n  surface.material = NO_MATERIAL;\n  surface.roughness = 1.0;\n  surface.ior = 1.0;\n  surface.specularF90 = 1.0;\n  surface.envMap = NO_TEXTURE;\n  surface.envMapIntensity = 1.0;\n  surface.gradientMap = NO_TEXTURE;\n\n  return surface;\n}\n\n/**\n * The shading normal with the edges near it rounded, as Cycles' bevel node rounds them, by one probe a sample. A\n * point is drawn on a disk of the bevel radius around the shaded point, across an axis picked along the normal half\n * the time and along each tangent a quarter; a short ray along that axis through it finds the surface of the same\n * material there, and that surface's normal turns this one by as much as it differs from the normal here. Over the\n * samples a pixel takes, the normal blends from one face to the next within the radius of every edge, so a box reads\n * as a machined one. A probe that finds nothing, or a normal turned away from the view, leaves the normal as it was.\n */\nfn bevelNormal(m: u32, point: vec3<f32>, surface: Surface, view: vec3<f32>, radius: f32, u: vec2<f32>,\n  v: vec2<f32>) -> vec3<f32> {\n  let basis = orthonormalBasis(surface.facing);\n  var axis = basis[2];\n  var first = basis[0];\n  var second = basis[1];\n\n  if (v.x >= 0.5) {\n    axis = select(basis[1], basis[0], v.x < 0.75);\n    first = select(basis[2], basis[1], v.x < 0.75);\n    second = select(basis[0], basis[2], v.x < 0.75);\n  }\n\n  let reach = radius * sqrt(u.x);\n  let angle = 2.0 * PI * u.y;\n  let across = point + first * (reach * cos(angle)) + second * (reach * sin(angle));\n  // Along the axis one way or the other at random, from the far edge of the radius across it.\n  let way = select(-1.0, 1.0, v.y < 0.5);\n  let hit = traceScene(across - axis * (radius * way), axis * way, 2.0 * radius);\n\n  if (hit.triangle == NO_HIT || materialIndexOf(hit.triangle) != m) {\n    return surface.normal;\n  }\n\n  // The authored normal there, turned the way this side's own is: the facing normal is the authored one, or its reverse.\n  let there = authoredNormal(hit.triangle, vec2<f32>(hit.u, hit.v)) * select(-1.0, 1.0, surface.front);\n  let turned = normalize(surface.normal + there - surface.facing);\n\n  return select(surface.normal, turned, dot(turned, view) > 0.0 && all(turned == turned));\n}\n\nstruct PathResult {\n  radiance: vec3<f32>,\n  alpha: f32,\n  // How far along the camera ray the first surface it stopped at is, or 1e30 when it stopped at none.\n  depth: f32,\n  // The denoiser's two signals: what of the radiance came through the first surface's diffuse lobe (and what the camera\n  // sees directly), the rest being specular, and what guides each at that surface.\n  diffuse: vec3<f32>,\n  diffuseAlbedo: vec3<f32>,\n  specularAlbedo: vec3<f32>,\n  normal: vec3<f32>,\n  // Along the camera ray to the first surface, its roughness, and how far the specular continuation went from it.\n  guideDistance: f32,\n  roughness: f32,\n  specularDistance: f32,\n  // How much of the first surface scatters light inside, which the denoiser relaxes its tests over.\n  subsurface: f32,\n};\n\n/** How many surfaces a path may pass through without scattering (cutouts, culled faces, glass) before it gives up. */\nconst MAX_STEPS: u32 = 64u;\n\n/** Scatterings one walk inside a material may take; the roulette ends most walks well before. */\nconst MAX_WALK: u32 = 128u;\n\nfn traceRadiance(\n  rayOrigin: vec3<f32>, rayDirection: vec3<f32>, rayLength: f32, rng: ptr<function, PathSampler>) -> PathResult {\n  var radiance = vec3<f32>(0.0);\n  var throughput = vec3<f32>(1.0);\n  var origin = rayOrigin;\n  var direction = rayDirection;\n  var limit = rayLength;\n  // Solid angle density of the current direction; zero for the camera ray, which no light sampling competes with.\n  var bsdfPdf = 0.0;\n  // What the volume the ray is travelling through absorbs per unit of distance; zero outside any.\n  var absorption = vec3<f32>(0.0);\n  // Still on the camera's own line of sight, which transmission keeps a path on.\n  var primary = true;\n  // Still the camera ray itself, in a straight line: only this one is culled and clipped by the far plane.\n  var straight = true;\n  var alpha = 0.0;\n  var bounce = 0u;\n  // The vertex the path last scattered at took all of its direct light by sampling lights: a toon surface.\n  var lightsOwnDirect = false;\n  // Where the path last scattered and the normal the light tree weighed lights by there, for the heuristic's other half.\n  var lastPosition = rayOrigin;\n  var lastNormal = vec3<f32>(0.0);\n  // That vertex's own environment map, which a ray escaping from it sees instead of the scene's.\n  var escapeMap = NO_TEXTURE;\n  var escapeIntensity = 1.0;\n  // Which colour a dispersive path carries, once a dispersive volume has split it; all three before that.\n  var channel = vec3<f32>(1.0);\n  // Three's fog, laid over everything the camera sees through the first surface.\n  var fogged = false;\n  var fogAmount = 0.0;\n  var fogStart = vec3<f32>(0.0);\n  var fogThroughput = vec3<f32>(0.0);\n  // The air between the camera and the first surface it sees: aerial perspective.\n  var hazed = false;\n  var hazeDistance = 0.0;\n  var hazeStart = vec3<f32>(0.0);\n  var hazeThroughput = vec3<f32>(0.0);\n  var hazeDirection = vec3<f32>(0.0);\n  // A built-in material's hooks after <opaque_fragment> edit the colour the camera sees of it, which is everything the\n  // path gathers from that surface on.\n  var afterMaterial = NO_MATERIAL;\n  var afterTriangle = 0u;\n  var afterBary = vec2<f32>(0.0);\n  var afterDirection = vec3<f32>(0.0);\n  var afterAlbedo = vec4<f32>(0.0);\n  var afterStart = vec3<f32>(0.0);\n  var afterThroughput = vec3<f32>(0.0);\n  var depth = 1e30;\n  // The denoiser's guides, taken at the first surface the camera ray stops at.\n  var guided = false;\n  var diffuseAlbedo = vec3<f32>(1.0);\n  var specularAlbedoGuide = vec3<f32>(1.0);\n  var guideNormal = vec3<f32>(0.0);\n  var guideDistance = 1e6;\n  var guideRoughness = 1.0;\n  var guideSubsurface = 0.0;\n  // Where the path first scattered, which decides which of the two signals the rest of it feeds.\n  var split = false;\n  var splitBase = vec3<f32>(0.0);\n  var splitDirect = vec3<f32>(0.0);\n  var splitDirectDiffuse = vec3<f32>(0.0);\n  var splitDiffuse = true;\n  var waitingForSpecular = false;\n  var specularDistance = 1e6;\n  // Inside a material that scatters light, between two scatterings: its extinction and single scattering albedo per\n  // colour, its anisotropy, the odds each colour had when the current step's distance was drawn, and the steps so far.\n  var inMedium = false;\n  var sigma = vec3<f32>(0.0);\n  var walkAlbedo = vec3<f32>(0.0);\n  var walkG = 0.0;\n  var walkOdds = vec3<f32>(0.0);\n  var walkSteps = 0u;\n  // Inside a volume: its density per unit of distance, what it keeps at each scattering and its anisotropy. A camera\n  // inside one starts there.\n  var inVolume = false;\n  var volumeDensity = 0.0;\n  var volumeAlbedo = vec3<f32>(0.0);\n  var volumeG = 0.0;\n\n  if (VOLUMES && frame.cameraVolume != NO_MATERIAL && frame.volumesEnabled != 0u) {\n    inVolume = true;\n    volumeDensity = materials[frame.cameraVolume].volume.w;\n    volumeAlbedo = materials[frame.cameraVolume].volume.rgb;\n    volumeG = materials[frame.cameraVolume].volumeAnisotropy;\n  }\n\n  for (var step = 0u; step < MAX_STEPS + MAX_WALK; step = step + 1u) {\n    let hit = traceScene(origin, direction, limit);\n\n    // Every vertex draws the same dimensions in the same order, whatever the path then does with them.\n    let coverage = sample2D(rng);\n    let pick = sample2D(rng);\n    let lightSample = sample2D(rng);\n    let lobe = sample2D(rng);\n    let bounceSample = sample2D(rng);\n    var mediumSample = vec2<f32>(0.0);\n    var bevelSample = vec4<f32>(0.0);\n\n    if (VOLUMES) {\n      mediumSample = sample2D(rng);\n    }\n\n    if (BEVEL) {\n      bevelSample = vec4<f32>(sample2D(rng), sample2D(rng));\n    }\n\n    // The walk left the material here, and the surface below is its way out rather than what the material shows.\n    var exiting = false;\n\n    if (SUBSURFACE_WALK && inMedium) {\n      if (hit.triangle == NO_HIT) {\n        // Nothing within the drawn distance: the light scatters there, keeping each colour's share of the medium.\n        let travelled = exp(-sigma * limit);\n        let density = dot(walkOdds, sigma * travelled);\n\n        throughput = throughput * sigma * walkAlbedo * travelled / max(density, 1e-20);\n        walkSteps = walkSteps + 1u;\n\n        let survival = max3(throughput);\n\n        if (walkSteps >= MAX_WALK || survival <= 0.0) {\n          break;\n        }\n\n        if (survival < 0.2) {\n          if (coverage.x > survival) {\n            break;\n          }\n\n          throughput = throughput / survival;\n        }\n\n        origin = origin + direction * limit;\n        direction = sampleHenyeyGreenstein(direction, walkG, lobe);\n        limit = walkDistance(throughput, sigma, pick, &walkOdds);\n        continue;\n      }\n\n      // The walk reached the surface before scattering again: the chance of travelling that far, per colour.\n      let travelled = exp(-sigma * hit.distance);\n\n      throughput = throughput * travelled / max(dot(walkOdds, travelled), 1e-20);\n      inMedium = false;\n      exiting = true;\n    }\n\n    // Inside a volume, the medium may stop the ray before whatever it hit. The distance is drawn now that the segment's\n    // length is known, which a homogeneous medium allows; one grey density makes the weight of either outcome one.\n    var scatterAt = -1.0;\n\n    if (VOLUMES && inVolume && !exiting) {\n      let free = -log(max(1.0 - mediumSample.x, 1e-12)) / max(volumeDensity, 1e-12);\n\n      if (free < select(hit.distance, limit, hit.triangle == NO_HIT)) {\n        scatterAt = free;\n      }\n    }\n\n    let scattering = scatterAt >= 0.0;\n\n    // The specular continuation's first hit: how far the reflection the denoiser filters actually is.\n    if (waitingForSpecular) {\n      specularDistance = select(min(hit.distance, 1e6), 1e6, hit.triangle == NO_HIT);\n      waitingForSpecular = false;\n    }\n\n    if (hit.triangle == NO_HIT && !scattering) {\n      if (primary) {\n        // A transparent background leaves the pixel empty, which its alpha says.\n        if (frame.background.w != 2.0) {\n          alpha = 1.0;\n          radiance = radiance + throughput * backgroundRadiance(direction);\n        }\n      } else {\n        var sky = ambientRadiance(direction);\n\n        if (escapeMap != NO_TEXTURE) {\n          sky = sky + sampleEquirect(escapeMap, direction).rgb * escapeIntensity;\n        } else {\n          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect);\n        }\n\n        let contribution = throughput * sky;\n\n        radiance = radiance + select(contribution, clampIndirect(contribution), bounce > 1u);\n      }\n\n      break;\n    }\n\n    let travel = select(hit.distance, scatterAt, scattering);\n\n    throughput = throughput * exp(-absorption * travel);\n\n    let bary = vec2<f32>(hit.u, hit.v);\n    let point = origin + direction * travel;\n    var m = 0u;\n\n    if (!scattering) {\n      m = materialIndexOf(hit.triangle);\n    }\n\n    var surface: Surface;\n\n    if (SUBSURFACE_WALK && exiting) {\n      surface = subsurfaceExit(m, hit.triangle, bary, direction);\n      // Seen from outside, along its normal: the side the light leaves through.\n      direction = -surface.normal;\n    } else if (VOLUMES && scattering) {\n      surface = volumePoint(direction, volumeAlbedo, volumeG);\n    } else {\n\n    // A volume's boundary is not a surface: the ray goes in or out, and the medium is what it meets.\n    if (VOLUMES && (materials[m].flags & MATERIAL_VOLUME) != 0u) {\n      if (dot(authoredNormal(hit.triangle, bary), direction) < 0.0) {\n        if (frame.volumesEnabled != 0u) {\n          inVolume = true;\n          volumeDensity = materials[m].volume.w;\n          volumeAlbedo = materials[m].volume.rgb;\n          volumeG = materials[m].volumeAnisotropy;\n        }\n      } else {\n        inVolume = false;\n      }\n\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    // Three culls the side a material does not draw. Only the camera's rays are culled: a mesh still casts shadows and\n    // holds light in from both sides.\n    // A planar capture drops what lies behind its plane, for the camera's own ray.\n    let clipped = any(frame.clipPlane != vec4<f32>(0.0)) && dot(frame.clipPlane.xyz, point) + frame.clipPlane.w < 0.0;\n\n    if (straight && (clipped || isCulled(m, hit.triangle, direction))) {\n      origin = point + direction * RAY_EPSILON;\n      limit = limit - hit.distance;\n      continue;\n    }\n\n    if (isClipped(m, point)\n      || ((materials[m].flags & MATERIAL_WIREFRAME) != 0u && !onWireframe(hit.triangle, point))) {\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    let base = sampleMap(materials[m].map, hit.triangle, bary);\n\n    // A cutout lets the ray through before anything else about the surface is read: the normal map, the other maps and\n    // the lobes would only be thrown away. The draw and the comparison are the ones made below, so nothing changes.\n    if (coverageFirst(m)) {\n      let opacity = coverageOf(m, materialAlphaFrom(m, hit.triangle, bary, base));\n\n      if (opacity < 1.0 && coverage.x >= opacity) {\n        origin = point + direction * RAY_EPSILON;\n        limit = select(1e30, limit - hit.distance, straight);\n        continue;\n      }\n    }\n\n    surface = resolveSurfaceFrom(hit.triangle, bary, direction, base);\n\n    if (BEVEL && frame.bevelEnabled != 0u && materials[m].bevel > 0.0) {\n      surface.normal = bevelNormal(m, point, surface, -direction, materials[m].bevel, bevelSample.xy, bevelSample.zw);\n    }\n    }\n\n    // Blending other than normal: the surface adds its light to, or filters, whatever is behind it, and the path goes on.\n    if (surface.blending == BLEND_ADDITIVE || surface.blending == BLEND_MULTIPLY || surface.blending == BLEND_SUBTRACTIVE) {\n      // Three blends these with the fragment's alpha whether or not the material is transparent.\n      let strength = surface.opacity * clamp(surface.alpha, 0.0, 1.0);\n      let color = select(surface.albedo, surface.emissive, (surface.flags & MATERIAL_LIT) == 0u);\n\n      if (surface.blending == BLEND_ADDITIVE) {\n        var added = surface.emissive;\n\n        if ((surface.flags & MATERIAL_LIT) != 0u) {\n          var unused: vec3<f32>;\n          added = added + directLight(surface, point + surface.normal * RAY_EPSILON, -direction, pick.x, lightSample, rng,\n            &unused, select(0.0, volumeDensity, inVolume));\n        }\n\n        radiance = radiance + throughput * added * strength;\n      } else if (surface.blending == BLEND_MULTIPLY) {\n        throughput = throughput * mix(vec3<f32>(1.0), color, strength);\n      } else {\n        throughput = throughput * (vec3<f32>(1.0) - color * strength);\n      }\n\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    // A surface that only partly covers its triangle lets the ray straight through the rest of the time. The direction\n    // does not change, so the density that found it still stands and the next hit is weighted against the same one.\n    if (surface.opacity < 1.0 && coverage.x >= surface.opacity) {\n      origin = point + direction * RAY_EPSILON;\n      limit = select(1e30, limit - hit.distance, straight);\n      continue;\n    }\n\n    // Three's ShadowMaterial shows its colour only where a light is blocked, and nothing elsewhere.\n    if (surface.kind == KIND_SHADOW) {\n      let shadow = shadowMaskAt(point + surface.facing * RAY_EPSILON, rng);\n\n      if (coverage.y >= shadow * clamp(materials[m].color.w, 0.0, 1.0)) {\n        origin = point + direction * RAY_EPSILON;\n        limit = select(1e30, limit - hit.distance, straight);\n        continue;\n      }\n\n      if (primary) {\n        alpha = 1.0;\n      }\n\n      radiance = radiance + throughput * surface.albedo;\n      break;\n    }\n\n    if (straight && depth >= 1e30) {\n      depth = length(point - rayOrigin);\n    }\n\n    if (straight && !guided) {\n      guided = true;\n      diffuseAlbedo = diffuseGuide(surface);\n      specularAlbedoGuide = select(specularAlbedo(surface, -direction), vec3<f32>(1.0), (surface.flags & MATERIAL_LIT) == 0u);\n      guideNormal = surface.normal;\n      guideDistance = length(point - rayOrigin);\n      guideRoughness = surface.roughness;\n      guideSubsurface = select(0.0, surface.subsurface, SUBSURFACE_WALK);\n\n      if (surface.kind == KIND_PHONG) {\n        // Phong's exponent as the roughness of the GGX lobe that is about as wide.\n        guideRoughness = pow(2.0 / (surface.shininess + 2.0), 0.25);\n      }\n    }\n\n    if (primary) {\n      alpha = 1.0;\n\n      if (!scattering && !fogged && afterMaterial == NO_MATERIAL && materials[m].afterProgram != NO_PROGRAM) {\n        afterMaterial = m;\n        afterTriangle = hit.triangle;\n        afterBary = bary;\n        afterDirection = direction;\n        afterAlbedo = vec4<f32>(surface.albedo, surface.alpha);\n        afterStart = radiance;\n        afterThroughput = throughput;\n      }\n\n      if (!fogged) {\n        let everySurface = frame.fogParams.w > 0.0;\n        let kind = frame.fogColor.w;\n\n        if (everySurface || (kind > 0.0 && (surface.flags & MATERIAL_FOG) != 0u)) {\n          let depth = -(frame.worldToCamera * vec4<f32>(point, 1.0)).z;\n\n          fogged = true;\n          fogAmount = fogFactor(depth, select(kind, 1.0, everySurface));\n          fogStart = radiance;\n          fogThroughput = throughput;\n        }\n      }\n\n      if (!hazed && frame.atmosphereColor.w > 0.0) {\n        hazed = true;\n        // From the eye, where the camera ray only starts on the near plane; an orthographic view has no eye.\n        hazeDistance = length(point - select(frame.cameraToWorld[3].xyz, rayOrigin, frame.cameraKind == 1u));\n        hazeStart = radiance;\n        hazeThroughput = throughput;\n        hazeDirection = direction;\n      }\n\n      radiance = radiance + throughput * surface.lightMap;\n    }\n\n    if (any(surface.emissive > vec3<f32>(0.0))) {\n      let contribution = throughput * surface.emissive * emissionWeight(hit, direction, bsdfPdf, lightsOwnDirect, lastPosition, lastNormal);\n\n      // Seen by the camera or one bounce away this is direct light and stays exact; deeper it may be clamped.\n      radiance = radiance + select(contribution, clampIndirect(contribution), bounce > 1u);\n    }\n\n    // Three does not light a basic, points, line or sprite material, so nothing carries on from one.\n    if ((surface.flags & MATERIAL_LIT) == 0u || bounce >= frame.bounces) {\n      break;\n    }\n\n    // Lambert and Phong blend their own environment map over the lit colour, which here is a share of the path.\n    if (surface.legacyAmount > 0.0) {\n      let amount = surface.legacyAmount;\n\n      if (surface.combine == 1u) {\n        radiance = radiance + throughput * surface.legacyEnv * amount;\n        throughput = throughput * (1.0 - amount);\n      } else if (surface.combine == 2u) {\n        radiance = radiance + throughput * surface.legacyEnv * amount;\n      } else {\n        throughput = throughput * mix(vec3<f32>(1.0), surface.legacyEnv, amount);\n      }\n    }\n\n    let view = -direction;\n    var next = direction;\n    var nextOrigin = point + direction * RAY_EPSILON;\n\n    // Transmission replaces part of the diffuse layer, so that share of the time the surface is a dielectric instead.\n    // Choosing it in proportion to its weight leaves both halves unweighted, and only the opaque half aims at a light.\n    if (surface.transmission > 0.0 && lobe.y < surface.transmission) {\n      var ior = surface.ior;\n\n      // Three's dispersion: each colour refracts with its own index, spread around the material's. The path picks one\n      // colour the first time it enters such a volume and carries only that one from then on.\n      if (surface.dispersion > 0.0 && surface.thickness > 0.0) {\n        if (all(channel == vec3<f32>(1.0))) {\n          let which = min(u32(coverage.y * 3.0), 2u);\n\n          channel = vec3<f32>(select(0.0, 1.0, which == 0u), select(0.0, 1.0, which == 1u), select(0.0, 1.0, which == 2u));\n          throughput = throughput * channel * 3.0;\n        }\n\n        let spread = (ior - 1.0) * 0.025 * surface.dispersion;\n\n        ior = dot(channel, vec3<f32>(ior - spread, ior, ior + spread));\n      }\n\n      let crossing = sampleDielectric(surface, view, ior, lobe.y / surface.transmission, bounceSample);\n\n      if (!crossing.valid) {\n        break;\n      }\n\n      // Bending or reflecting off glass is the specular signal.\n      if (!split && !crossing.straight) {\n        split = true;\n        splitBase = radiance;\n        splitDiffuse = false;\n        waitingForSpecular = true;\n      }\n\n      throughput = throughput * crossing.weight;\n\n      // Straight through a thin wall the direction stands, and with it the density that will weigh the next hit.\n      if (!crossing.straight) {\n        straight = false;\n        next = crossing.direction;\n        nextOrigin = point + surface.normal * select(RAY_EPSILON, -RAY_EPSILON, crossing.crossed);\n        // A direction no light sampling could have produced: whatever the path finds next keeps its whole value.\n        bsdfPdf = 0.0;\n        lightsOwnDirect = false;\n        escapeMap = surface.envMap;\n        escapeIntensity = surface.envMapIntensity;\n\n        if (crossing.crossed) {\n          absorption = select(vec3<f32>(0.0), surface.absorption, surface.front);\n        } else {\n          primary = false;\n        }\n      }\n\n      if (!primary) {\n        bounce = bounce + 1u;\n      }\n    } else {\n      // Light that enters the material: a random walk inside it from here, in place of the share of the diffuse\n      // layer that scatters inside. Chosen by chance, so neither branch is weighted against the other.\n      var chance = 0.0;\n\n      if (SUBSURFACE_WALK) {\n        chance = subsurfaceChance(surface, view);\n      }\n\n      if (SUBSURFACE_WALK && lobe.x < chance) {\n        let medium = materials[surface.material].subsurface;\n\n        throughput = throughput\n          * ((1.0 - surface.metalness) * surface.subsurface * coatTransmittance(surface, view) / chance);\n        sigma = vec3<f32>(1.0) / max(medium.rgb, vec3<f32>(1e-6));\n        walkAlbedo = subsurfaceAlbedo(surface.albedo);\n        walkG = materials[surface.material].subsurfaceAnisotropy;\n        walkSteps = 0u;\n\n        // Light that scattered inside is diffuse light, which is the signal it feeds.\n        if (!split) {\n          split = true;\n          splitBase = radiance;\n          splitDiffuse = true;\n        }\n\n        inMedium = true;\n        primary = false;\n        straight = false;\n        bsdfPdf = 0.0;\n        lightsOwnDirect = false;\n        escapeMap = NO_TEXTURE;\n        bounce = bounce + 1u;\n        direction = cosineDirection(-surface.facing, bounceSample);\n        origin = point - surface.facing * RAY_EPSILON;\n        limit = walkDistance(throughput, sigma, pick, &walkOdds);\n        continue;\n      }\n\n      throughput = throughput / (1.0 - chance);\n\n      let position = point + surface.normal * RAY_EPSILON;\n      var directDiffuse: vec3<f32>;\n      let direct = throughput * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse,\n        select(0.0, volumeDensity, inVolume));\n      let added = select(direct, clampIndirect(direct), bounce > 0u);\n      let before = radiance;\n\n      radiance = radiance + added;\n\n      let scattered = sampleBsdf(surface, view, (lobe.x - chance) / (1.0 - chance), bounceSample);\n\n      // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.\n      if (!split) {\n        split = true;\n        splitBase = before;\n        splitDirect = added;\n        splitDirectDiffuse = throughput * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),\n          bounce > 0u);\n        splitDiffuse = !scattered.valid || scattered.diffuse;\n        waitingForSpecular = scattered.valid && !scattered.diffuse;\n      }\n\n      if (!scattered.valid) {\n        break;\n      }\n\n      throughput = throughput * scattered.weight;\n      bsdfPdf = scattered.pdf;\n      lastPosition = position;\n      lastNormal = treeNormal(surface);\n      lightsOwnDirect = surface.kind == KIND_TOON;\n      escapeMap = surface.envMap;\n      escapeIntensity = surface.envMapIntensity;\n      next = scattered.direction;\n      nextOrigin = position;\n      primary = false;\n      straight = false;\n      bounce = bounce + 1u;\n    }\n\n    // A path that carries almost nothing is ended by chance rather than by a cut, which keeps the estimate unbiased.\n    let survival = max(throughput.r, max(throughput.g, throughput.b));\n\n    if (survival <= 0.0) {\n      break;\n    }\n\n    if (survival < frame.rouletteThreshold && bounce >= frame.rouletteStart) {\n      if (pick.y > survival) {\n        break;\n      }\n\n      throughput = throughput / survival;\n    }\n\n    origin = nextOrigin;\n    limit = select(1e30, limit - hit.distance, straight);\n    direction = next;\n  }\n\n  // The diffuse signal: everything before the first scatter, its diffuse direct light, and the rest if the diffuse lobe\n  // carried the path on. A path that never scattered is all diffuse, which is what the camera sees directly.\n  var diffuse = radiance;\n\n  if (split) {\n    let after = radiance - splitBase - splitDirect;\n    diffuse = splitBase + splitDirectDiffuse + select(vec3<f32>(0.0), after, splitDiffuse);\n  }\n\n  if (afterMaterial != NO_MATERIAL && all(afterThroughput > vec3<f32>(0.0))) {\n    var input = shaderInputAt(afterMaterial, afterTriangle, afterBary, afterDirection);\n    input.data = materials[afterMaterial].afterData;\n    input.diffuseColor = afterAlbedo;\n    input.fragColor = vec4<f32>((radiance - afterStart) / afterThroughput, 1.0);\n\n    let edited = runProgram(materials[afterMaterial].afterProgram, input);\n\n    radiance = afterStart + afterThroughput * edited.color.rgb;\n    // A hook rewrites the colour as a whole: there is no split left to keep.\n    diffuse = radiance;\n  }\n\n  // Three lays its fog after the hooks, over what they made of the surface.\n  if (fogged) {\n    let fog = frame.fogColor.rgb * fogThroughput * fogAmount;\n\n    radiance = fogStart + (radiance - fogStart) * (1.0 - fogAmount) + fog;\n    // What came before the fogged surface is diffuse, so the fog's own colour joins that signal.\n    diffuse = fogStart + (diffuse - fogStart) * (1.0 - fogAmount) + fog;\n  }\n\n  // The air takes its share of what lies behind it and adds the light it scatters towards the camera; the background,\n  // which already is the sky, is left as it is.\n  if (hazed) {\n    let through = exp(-frame.atmosphereExtinction.rgb * hazeDistance);\n    // The sun lights the air by the phase function of what fills it: Rayleigh's for clean air, a forward lobe for haze\n    // (Henyey-Greenstein at 0.76), which is what makes the air glow towards the sun.\n    let turn = dot(hazeDirection, frame.atmosphereSun.xyz);\n    let phase = mix(3.0 / (16.0 * PI) * (1.0 + turn * turn), henyeyGreenstein(turn, 0.76), frame.atmosphereExtinction.w);\n    let air = frame.atmosphereColor.rgb + frame.atmosphereSunColor.rgb * phase;\n    let glow = air * hazeThroughput * (vec3<f32>(1.0) - through);\n\n    radiance = hazeStart + (radiance - hazeStart) * through + glow;\n    diffuse = hazeStart + (diffuse - hazeStart) * through + glow;\n  }\n\n  var result: PathResult;\n  result.radiance = radiance;\n  result.alpha = alpha;\n  result.depth = depth;\n  result.diffuse = diffuse;\n  result.diffuseAlbedo = diffuseAlbedo;\n  result.specularAlbedo = specularAlbedoGuide;\n  result.normal = guideNormal;\n  result.guideDistance = guideDistance;\n  result.roughness = guideRoughness;\n  result.specularDistance = specularDistance;\n  result.subsurface = guideSubsurface;\n\n  return result;\n}\n\n/** A point on the lens: a disk, or Three-free polygon bokeh shaped as the CPU renderer shapes it. */\nfn lensPoint(u: vec2<f32>) -> vec2<f32> {\n  var radius = sqrt(u.x) * frame.lens.x;\n  let angle = u.y * 2.0 * PI;\n  let blades = frame.lens.z;\n\n  if (blades >= 3.0) {\n    let wedge = 2.0 * PI / blades;\n    radius = radius * cos(PI / blades) / cos((angle - floor(angle / wedge) * wedge) - PI / blades);\n  }\n\n  return vec2<f32>(cos(angle), sin(angle)) * radius;\n}\n\n/**\n * Where a sample's camera ray starts, which way it points and how far it may go, for any camera: the ray is cast through\n * the inverse of the camera's own projection, from the near plane to the far one, which clip it as Three clips a\n * fragment. A lens moves the origin across its aperture and aims at the point in focus.\n */\nfn cameraRay(pixel: vec2<u32>, jitter: vec2<f32>, lens: vec2<f32>) -> array<vec4<f32>, 2> {\n  let uv = (vec2<f32>(pixel) + jitter) / vec2<f32>(frame.resolution);\n  var ndc = vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n\n  // A lens's radial distortion: the pixel sees the scene at a radius scaled by the square of its own, which is one at\n  // the corners. Positive reaches further out at the edges (barrel), negative less far (pincushion).\n  if (frame.lensDistortion != 0.0) {\n    let aspect = f32(frame.resolution.x) / f32(frame.resolution.y);\n    let radius2 = (ndc.x * ndc.x * aspect * aspect + ndc.y * ndc.y) / (aspect * aspect + 1.0);\n\n    ndc = ndc * (1.0 + frame.lensDistortion * radius2);\n  }\n\n  let ray = ndcRay(ndc);\n\n  if (frame.lens.x <= 0.0 || frame.cameraKind == 1u) {\n    return ray;\n  }\n\n  let position = frame.cameraToWorld[3].xyz;\n  let forward = -normalize(frame.cameraToWorld[2].xyz);\n  let focus = position + ray[1].xyz * (frame.lens.y / max(dot(ray[1].xyz, forward), 1e-6));\n  let offset = lensPoint(lens);\n  let origin = position + normalize(frame.cameraToWorld[0].xyz) * offset.x + normalize(frame.cameraToWorld[1].xyz) * offset.y;\n\n  return array<vec4<f32>, 2>(vec4<f32>(origin, 0.0), vec4<f32>(normalize(focus - origin), 1e30));\n}\n\n/** The window depth GL would store for the first surface the camera ray stopped at: one where it stopped at none. */\nfn windowDepth(point: vec3<f32>, distance: f32) -> f32 {\n  if (distance >= 1e30) {\n    return 1.0;\n  }\n\n  let clip = frame.projection * (frame.worldToCamera * vec4<f32>(point, 1.0));\n\n  return clamp(clip.z / clip.w * 0.5 + 0.5, 0.0, 1.0);\n}\n\n/** smoothstep as the CPU renderer writes it, which also holds when the two edges meet. */\nfn edge(low: f32, high: f32, value: f32) -> f32 {\n  let t = select(select(0.0, 1.0, value >= high), clamp((value - low) / (high - low), 0.0, 1.0), high > low);\n\n  return t * t * (3.0 - 2.0 * t);\n}\n\n/** How much of what lies at this point the fog lets through to the camera. */\nfn fogVisibility(point: vec3<f32>) -> f32 {\n  let everySurface = frame.fogParams.w > 0.0;\n  let kind = frame.fogColor.w;\n\n  if (!everySurface && kind <= 0.0) {\n    return 1.0;\n  }\n\n  let depth = -(frame.worldToCamera * vec4<f32>(point, 1.0)).z;\n\n  return 1.0 - fogFactor(depth, select(kind, 1.0, everySurface));\n}\n\n/** The most volumetric lights one view ray marches through. */\nconst MAX_VOLUMETRIC: u32 = 8u;\n\n/**\n * Steps of one march. The CPU renderer marches 64 once per pixel; here every path marches, a few hundred times a\n * pixel, each at its own random offset, so a few steps a path add up to a finer integral than 64 once, at a fraction of\n * the shadow rays.\n */\nconst MARCH_STEPS: u32 = 8u;\n\n/**\n * The CPU renderer's volumetric lights (volumetricLight.js): one march across the union of every light's\n * reach along the view ray, Henyey-Greenstein scattering towards the camera, a shadow ray for a spot light that casts\n * one, and the same compression of the sum before it is added over the image.\n */\nfn volumetricGlow(origin: vec3<f32>, direction: vec3<f32>, distance: f32, jitter: f32) -> vec3<f32> {\n  let count = min(frame.volumetricCount, MAX_VOLUMETRIC);\n  let far = min(distance, 40.0);\n  var tStart = far;\n  var tEnd = 0.0;\n\n  for (var k = 0u; k < count; k = k + 1u) {\n    let at = frame.volumetricData + k * 20u;\n    let position = extraVec4(at).xyz;\n    let spot = extraFloat(at + 3u) > 0.5;\n    let axis = extraVec4(at + 4u).xyz;\n    let radius = extraFloat(at + 7u);\n    let outer = extraFloat(at + 15u);\n    let delta = origin - position;\n    let b = dot(delta, direction);\n    let disc = b * b - dot(delta, delta) + radius * radius;\n\n    if (disc <= 0.0) {\n      continue;\n    }\n\n    let start = max(0.0, -b - sqrt(disc));\n    let end = min(far, -b + sqrt(disc));\n\n    if (end <= start) {\n      continue;\n    }\n\n    var cuts = array<f32, 4>(start, end, end, end);\n    var cutCount = 2u;\n    let cone = cos(outer);\n\n    if (spot) {\n      let ar = dot(axis, direction);\n      let ac = dot(axis, delta);\n      let cos2 = cone * cone;\n      let qa = ar * ar - cos2;\n      let qb = ar * ac - dot(direction, delta) * cos2;\n      let qc = ac * ac - dot(delta, delta) * cos2;\n      let discriminant = qb * qb - qa * qc;\n      var roots = array<f32, 2>(-1.0, -1.0);\n\n      if (abs(qa) < 1e-8) {\n        if (abs(qb) > 1e-8) {\n          roots[0] = -qc / (2.0 * qb);\n        }\n      } else if (discriminant >= 0.0) {\n        roots[0] = (-qb - sqrt(discriminant)) / qa;\n        roots[1] = (-qb + sqrt(discriminant)) / qa;\n      }\n\n      for (var r = 0u; r < 2u; r = r + 1u) {\n        if (roots[r] > start && roots[r] < end) {\n          cuts[cutCount] = roots[r];\n          cutCount = cutCount + 1u;\n        }\n      }\n\n      // Sort the few cuts in place.\n      for (var i = 1u; i < cutCount; i = i + 1u) {\n        var j = i;\n\n        loop {\n          if (j == 0u || cuts[j - 1u] <= cuts[j]) {\n            break;\n          }\n\n          let swap = cuts[j];\n          cuts[j] = cuts[j - 1u];\n          cuts[j - 1u] = swap;\n          j = j - 1u;\n        }\n      }\n    }\n\n    for (var segment = 1u; segment < cutCount; segment = segment + 1u) {\n      let lo = cuts[segment - 1u];\n      let hi = cuts[segment];\n\n      if (spot && dot(normalize(delta + direction * ((lo + hi) * 0.5)), axis) < cone) {\n        continue;\n      }\n\n      tStart = min(tStart, lo);\n      tEnd = max(tEnd, hi);\n    }\n  }\n\n  if (tEnd <= tStart) {\n    return vec3<f32>(0.0);\n  }\n\n  let step = (tEnd - tStart) / f32(MARCH_STEPS);\n  var transmittance: array<f32, 8>;\n\n  for (var k = 0u; k < count; k = k + 1u) {\n    transmittance[k] = exp(-extraFloat(frame.volumetricData + k * 20u + 11u) * tStart);\n  }\n\n  var result = vec3<f32>(0.0);\n\n  for (var i = 0u; i < MARCH_STEPS; i = i + 1u) {\n    let t = tStart + (f32(i) + jitter) * step;\n    let p = origin + direction * t;\n    let fogged = fogVisibility(p);\n\n    if (fogged <= 0.0001) {\n      break;\n    }\n\n    var lit = false;\n\n    for (var k = 0u; k < count; k = k + 1u) {\n      if (transmittance[k] <= 0.003) {\n        continue;\n      }\n\n      lit = true;\n\n      let at = frame.volumetricData + k * 20u;\n      let position = extraVec4(at).xyz;\n      let spot = extraFloat(at + 3u) > 0.5;\n      let axis = extraVec4(at + 4u).xyz;\n      let color = extraVec4(at + 8u).rgb;\n      let density = extraFloat(at + 11u);\n      let angle = extraFloat(at + 12u);\n      let penumbra = extraFloat(at + 13u);\n      let range = extraFloat(at + 14u);\n      let outer = extraFloat(at + 15u);\n      let spread = extraFloat(at + 16u);\n      let anisotropy = extraFloat(at + 17u);\n      let casts = extraFloat(at + 18u) > 0.5;\n      let toLight = position - p;\n      let dist = length(toLight);\n      let toward = toLight / max(dist, 1e-20);\n      var attenuation = exp(-dist / (select(10.0, range, range > 0.0) * 0.3));\n\n      if (range > 0.0) {\n        attenuation = attenuation * (1.0 - edge(range * 0.8, range, dist));\n      }\n\n      if (spot) {\n        let along = -dot(toward, axis);\n        let inner = cos(angle * (1.0 - penumbra));\n        let core = edge(cos(angle), inner, along);\n        let scattered = spread * pow(edge(cos(outer), inner, along), 2.0);\n\n        attenuation = attenuation * select(core, max(core, scattered), spread > 0.0);\n      }\n\n      if (attenuation <= 0.0001) {\n        continue;\n      }\n\n      // Shadowing follows Three's volumetric lights, which only have shadow maps for spots.\n      if (spot && casts && frame.shadowsEnabled != 0u && traceAny(p, toward, dist * (1.0 - 1e-3)) != NO_HIT) {\n        continue;\n      }\n\n      let cosine = dot(toward, direction);\n      let g = anisotropy;\n      let phase = select((1.0 - g * g) / pow(1.0 + g * g - 2.0 * g * cosine, 1.5), 1.0, g == 0.0);\n\n      // The air between the camera and this point, exactly: a long step evaluated at its start would overstate it.\n      result = result + color * (attenuation * density * step * exp(-density * t) * fogged * phase * 1.5);\n    }\n\n    if (!lit) {\n      break;\n    }\n\n    for (var k = 0u; k < count; k = k + 1u) {\n      transmittance[k] = transmittance[k] * exp(-extraFloat(frame.volumetricData + k * 20u + 11u) * step);\n    }\n  }\n\n  return result / (vec3<f32>(1.0) + result);\n}\n\n/**\n * How far a pixel's estimate may still be from its mean: the standard error of its luminance, over the square root of\n * the luminance, which is roughly how visible that error is once the image is encoded for display.\n */\nfn pixelError(pixel: vec2<u32>) -> f32 {\n  let index = pixel.y * frame.resolution.x + pixel.x;\n  let sum = accumulation[index];\n\n  if (sum.w < 2.0) {\n    return 1e30;\n  }\n\n  let squares = accumulation[frame.pixelCount + index];\n  let diffuse = accumulation[4u * frame.pixelCount + index].rgb;\n\n  // Each of the denoiser's signals has its own variance; the pixel has converged when both have.\n  return max(\n    channelError(luminanceOf(diffuse) / sum.w, squares.z / sum.w, sum.w),\n    channelError(luminanceOf(sum.rgb - diffuse) / sum.w, squares.w / sum.w, sum.w));\n}\n\nfn channelError(mean: f32, square: f32, samples: f32) -> f32 {\n  let variance = max(square - mean * mean, 0.0);\n\n  return sqrt(variance / samples) / sqrt(max(mean, 0.0) + 1e-3);\n}\n\n/**\n * Whether a pixel has converged, judged over its neighbourhood: a rare bright path lands in one pixel, and a pixel\n * judged alone would stop where its neighbours had not yet seen one and leave that area too dark.\n */\nfn converged(pixel: vec2<u32>) -> bool {\n  for (var dy = -1; dy <= 1; dy = dy + 1) {\n    for (var dx = -1; dx <= 1; dx = dx + 1) {\n      let x = clamp(i32(pixel.x) + dx, 0, i32(frame.resolution.x) - 1);\n      let y = clamp(i32(pixel.y) + dy, 0, i32(frame.resolution.y) - 1);\n\n      if (pixelError(vec2<u32>(u32(x), u32(y))) > frame.adaptiveThreshold) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= frame.bandSize.x || id.y >= frame.bandSize.y) {\n    return;\n  }\n\n  let pixel = frame.bandOrigin + id.xy;\n\n  if (pixel.x >= frame.resolution.x || pixel.y >= frame.resolution.y) {\n    return;\n  }\n\n  let index = pixel.y * frame.resolution.x + pixel.x;\n\n  // Adaptive sampling: a pixel whose neighbourhood has converged takes no more samples, which leaves the pass to\n  // the pixels that still need them.\n  if (frame.adaptiveMin > 0u && accumulation[index].w >= f32(frame.adaptiveMin) && converged(pixel)) {\n    return;\n  }\n\n  var radiance = vec3<f32>(0.0);\n  var alpha = 0.0;\n  var depthSum = 0.0;\n  var diffuseSquares = 0.0;\n  var specularSquares = 0.0;\n  var diffuseSum = vec3<f32>(0.0);\n  var diffuseAlbedoSum = vec3<f32>(0.0);\n  var specularAlbedoSum = vec3<f32>(0.0);\n  var normalSum = vec3<f32>(0.0);\n  var distanceSum = 0.0;\n  var roughnessSum = 0.0;\n  var specularDistanceSum = 0.0;\n  var subsurfaceSum = 0.0;\n\n  for (var s = 0u; s < frame.sampleCount; s = s + 1u) {\n    var rng = makeSampler(pixel, frame.sampleIndex + s);\n    let jitter = sample2D(&rng);\n    let lens = sample2D(&rng);\n    let ray = cameraRay(pixel, jitter, lens);\n    let result = traceRadiance(ray[0].xyz, ray[1].xyz, ray[1].w, &rng);\n    var sampleAlpha = result.alpha;\n\n    var sampled = result.radiance;\n    var sampledDiffuse = result.diffuse;\n\n    if (frame.volumetricCount > 0u) {\n      let glow = volumetricGlow(ray[0].xyz, ray[1].xyz, result.depth, sample2D(&rng).x);\n\n      // As the CPU renderer composites it: added over the image, and raising the coverage just enough to hold it.\n      sampled = sampled + glow;\n      sampledDiffuse = sampledDiffuse + glow;\n      sampleAlpha = max(sampleAlpha, max3(glow));\n    }\n\n    let sampledSpecular = sampled - sampledDiffuse;\n\n    radiance = radiance + sampled;\n    diffuseSum = diffuseSum + sampledDiffuse;\n    diffuseSquares = diffuseSquares + luminanceOf(sampledDiffuse) * luminanceOf(sampledDiffuse);\n    specularSquares = specularSquares + luminanceOf(sampledSpecular) * luminanceOf(sampledSpecular);\n    diffuseAlbedoSum = diffuseAlbedoSum + result.diffuseAlbedo;\n    specularAlbedoSum = specularAlbedoSum + result.specularAlbedo;\n    normalSum = normalSum + result.normal;\n    distanceSum = distanceSum + result.guideDistance;\n    roughnessSum = roughnessSum + result.roughness;\n    specularDistanceSum = specularDistanceSum + result.specularDistance;\n    subsurfaceSum = subsurfaceSum + result.subsurface;\n\n    alpha = alpha + sampleAlpha;\n    depthSum = depthSum + windowDepth(ray[0].xyz + ray[1].xyz * min(result.depth, 1e20), result.depth);\n  }\n\n  let coverage = accumulation[frame.pixelCount + index];\n  accumulation[index] = accumulation[index] + vec4<f32>(radiance, f32(frame.sampleCount));\n  accumulation[frame.pixelCount + index] = vec4<f32>(\n    coverage.x + alpha, coverage.y + depthSum, coverage.z + diffuseSquares, coverage.w + specularSquares);\n  // The denoiser's signals and guides, summed like the radiance so they average over the pixel's samples.\n  let pc = frame.pixelCount;\n  accumulation[2u * pc + index] = accumulation[2u * pc + index] + vec4<f32>(diffuseAlbedoSum, roughnessSum);\n  accumulation[3u * pc + index] = accumulation[3u * pc + index] + vec4<f32>(normalSum, distanceSum);\n  accumulation[4u * pc + index] = accumulation[4u * pc + index] + vec4<f32>(diffuseSum, specularDistanceSum);\n  accumulation[5u * pc + index] = accumulation[5u * pc + index] + vec4<f32>(specularAlbedoSum, subsurfaceSum);\n  // This row still has work: every pixel that traced writes the same value, so the race is harmless.\n  accumulation[6u * pc + pixel.y] = vec4<f32>(1.0);\n}\n";
 //# sourceMappingURL=pathTrace.wgsl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pathTrace.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/pathTrace.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,4xpCA8+B3B,CAAC"}
+{"version":3,"file":"pathTrace.wgsl.d.ts","sourceRoot":"","sources":["../../src/wgsl/pathTrace.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,ktpDA+2C3B,CAAC"}