@tinypoly/gpu-renderer 0.0.5 → 0.1.1

package/src/wgsl/lens.wgsl.ts

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

package/src/wgsl/lights.wgsl.ts

@@ -52,11 +52,177 @@ 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 TREE_ENTRY_WORDS: u32 = 4u;
+const NO_LIGHT: u32 = 0xffffffffu;
+
+/**
+ * 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 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);
+
+  if (low.w <= 0.0) {
+    return 0.0;
+  }
+
+  let centre = (low.xyz + high.xyz) * 0.5;
+  let radius2 = dot(high.xyz - low.xyz, high.xyz - low.xyz) * 0.25;
+  let offset = position - centre;
+  let distance2 = dot(offset, offset);
+
+  if (distance2 <= radius2) {
+    return low.w / max(radius2, 1e-12);
+  }
+
+  let away = offset * inverseSqrt(distance2);
+  // The angle the box takes from the point, as its sine and cosine: the angles below are widened by it without a
+  // single inverse trigonometric function, by the sum and difference formulas.
+  let sinU2 = radius2 / distance2;
+  let cosU = sqrt(1.0 - sinU2);
+  let sinU = sqrt(sinU2);
+  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 cone = extraVec4(at + 8u);
+    let cosO = high.w;
+    let sinO = sqrt(max(0.0, 1.0 - cosO * cosO));
+    // The cone widened by the box: cos and sin of theta_o + theta_u, the whole sphere once that passes pi.
+    let cosWide = cosO * cosU - sinO * sinU;
+    let sinWide = sinO * cosU + cosO * sinU;
+    let cosTheta = dot(cone.xyz, away);
+
+    // cos(max(0, theta - theta_o - theta_u)), which is one while the point lies within the widened cone.
+    if (sinWide >= 0.0 && cosTheta < cosWide) {
+      let sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));
+      let cosPast = cosTheta * cosWide + sinTheta * sinWide;
+
+      orientation = select(0.0, cosPast, cosPast >= cone.w);
+    }
+  }
+
+  var facing = 1.0;
+
+  if (any(normal != vec3<f32>(0.0))) {
+    let cosN = -dot(normal, away);
+
+    // cos(max(0, theta_n - theta_u)), and nothing once that reaches a right angle.
+    if (cosN < cosU) {
+      let sinN = sqrt(max(0.0, 1.0 - cosN * cosN));
+
+      facing = max(0.0, cosN * cosU + sinN * sinU);
+    }
+  }
+
+  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];
+
+    // A leaf lists its lights, too close together to tell apart from here: one is picked by its share of the power.
+    if ((first & TREE_LEAF) != 0u) {
+      let start = frame.lightList + (first & ~TREE_LEAF) * TREE_ENTRY_WORDS;
+      let count = textures[at + 13u];
+      var slot = start + (count - 1u) * TREE_ENTRY_WORDS;
+
+      for (var j = 0u; j + 1u < count; j = j + 1u) {
+        if (x < extraFloat(start + j * TREE_ENTRY_WORDS + 3u)) {
+          slot = start + j * TREE_ENTRY_WORDS;
+          break;
+        }
+      }
+
+      *pdf = chance * extraFloat(slot + 1u);
+      *density = extraFloat(slot + 2u);
+
+      return textures[slot];
+    }
+
+    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 * 2u];
+  let slot = frame.lightList + textures[frame.lightLeaves + index * 2u + 1u] * TREE_ENTRY_WORDS;
+  // Its share within its leaf, and the area density of a point on it.
+  var chance = extraFloat(slot + 1u) * extraFloat(slot + 2u);
+
+  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 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.
+ * 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) -> f32 {
+fn lightPdfOfTriangle(triangle: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
   var low = 0u;
   var high = frame.areaLightCount;
 
@@ -69,6 +235,10 @@ fn lightPdfOfTriangle(triangle: u32) -> f32 {
     let candidate = textures[frame.lightTriangles + middle];
 
     if (candidate == triangle) {
+      if (frame.lightTree != 0u) {
+        return frame.localLightPick * lightTreePdf(middle, position, normal);
+      }
+
       return lights[middle].pdf;
     }
 
@@ -128,12 +298,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. */
@@ -160,7 +345,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;
@@ -176,7 +362,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;
@@ -191,7 +377,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;
   }
@@ -220,7 +406,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);
 
@@ -260,7 +446,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);
@@ -277,7 +463,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
@@ -333,45 +519,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) {
@@ -390,13 +594,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);
 }
 
 /**
@@ -418,13 +624,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));
   }