@tinypoly/gpu-renderer 0.0.5 → 0.1.0

package/dist/wgsl/lens.wgsl.js

@@ -0,0 +1,315 @@
+/**
+ * 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 folded halo at full resolution: a tent over its largest level, which is half the image's size. */
+fn tentHalo(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;
+
+      sum = sum + upBilinear(lens.haloOffset, lens.haloSize, position + vec2<f32>(f32(dx), f32(dy)) * 0.5) * weight;
+    }
+  }
+
+  return sum;
+}
+
+/** 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) {
+    let halo = tentHalo(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);
+}
+`;
+//# sourceMappingURL=lens.wgsl.js.map

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

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

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

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

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

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