@tinypoly/gpu-renderer 0.1.1 → 0.2.0

package/src/sceneUpload.ts

@@ -53,6 +53,10 @@ export interface SceneBuffers {
   lightTree: number;
   lightLeaves: number;
   lightList: number;
+  /** The windows the sky is sampled through: see lights.ts. */
+  portals: number;
+  portalCount: number;
+  portalList: number;
   /** Radiance an ambient or hemisphere light adds, which no shadow ray can reach. */
   ambient: PackedLights["ambient"];
   /** Where the surrounding image and its distributions ended up, for the frame uniform. */
@@ -208,6 +212,9 @@ export function uploadScene(
     lightTree: lights.treeAt,
     lightLeaves: lights.leavesAt,
     lightList: lights.listAt,
+    portals: lights.portalTreeAt,
+    portalCount: lights.portalCount,
+    portalList: lights.portalListAt,
     ambient: lights.ambient,
     environment: {
       texture: environment ? textures.indexOf.get(environment.texture.id) ?? NO_TEXTURE : NO_TEXTURE,

package/src/settings.ts

@@ -20,6 +20,12 @@ export interface GpuRenderSettings extends Omit<RenderSettings, "globalIlluminat
      * gets the samples a large panel far away would have taken.
      */
     lightTree: boolean;
+    /**
+     * Inside a room, aims at the sky through its windows (every thin transmissive material) as well as by its
+     * brightness, as Cycles' portals do, so daylight that enters through glass is found instead of stumbled upon.
+     * A point counts as inside when something is above it; elsewhere the sky is sampled as before.
+     */
+    portals: boolean;
   };
   /**
    * The light a real lens and sensor scatter around anything bright: a soft halo that fades with distance. Energy
@@ -60,11 +66,24 @@ export interface GpuRenderSettings extends Omit<RenderSettings, "globalIlluminat
   };
   /** A camera's exposure triangle and white balance. */
   camera: {
+    /**
+     * The contrast and saturation of AgX's look, `0` to `1`: `0` is its base curve, flat on purpose, and `1` a look
+     * like Blender's Punchy, pivoted on middle grey so the image keeps its brightness. The other tone mappings ignore it.
+     */
+    contrast: number;
     /**
      * Exposes from `iso`, `shutterSpeed` and `depthOfField.aperture` as a camera would, with `exposure` as a
      * compensation on top. The scene's lights then have to be in physical units (lux, candela, nits).
      */
     physicalExposure: boolean;
+    /**
+     * Meters the image as a camera in automatic does and exposes it to middle grey, from the mean of the logarithms of
+     * its luminance, weighed towards the centre: a bright window or sky cannot darken the rest. It takes the place of
+     * `exposure` and of the physical exposure, with `exposureCompensation` on top.
+     */
+    autoExposure: boolean;
+    /** Stops added to the metered exposure: positive brightens, as on a camera's dial. */
+    exposureCompensation: number;
     iso: number;
     /** Seconds. */
     shutterSpeed: number;
@@ -130,11 +149,14 @@ export const DEFAULT_GPU_RENDER_SETTINGS: Readonly<GpuRenderSettings> = Object.f
     // AgX rolls highlights off as film does, where ACES pushes saturated colours to the gamut's edge.
     toneMapping: "agx",
     globalIllumination: { ...DEFAULT_RENDER_SETTINGS.globalIllumination, russianRoulette: true, rouletteStart: 1,
-      lightTree: true },
+      lightTree: true, portals: true },
     bloom: { enabled: true, intensity: 0.04, radius: 0.65 },
     glare: { enabled: true, intensity: 0.06, blades: 6, length: 0.25, rotation: 15 },
-    lens: { chromaticAberration: 0.2, distortion: 0 },
-    camera: { physicalExposure: false, iso: 100, shutterSpeed: 1 / 125, whiteBalance: 6500 },
+    lens: { chromaticAberration: 0.05, distortion: 0 },
+    camera: {
+      contrast: 1, physicalExposure: false, autoExposure: false, exposureCompensation: 0, iso: 100,
+      shutterSpeed: 1 / 125, whiteBalance: 6500,
+    },
     subsurface: { enabled: true, depth: 2 },
     atmosphere: { enabled: true, visibility: 20000, haze: 0.6, color: "" },
     volumes: { enabled: true },
@@ -160,10 +182,16 @@ export function physicalExposure(aperture: number, shutterSpeed: number, iso: nu
   return 1 / (1.2 * 2 ** ev100);
 }
 
-/** The exposure the image is multiplied by: the setting itself, or a camera's on top of it as compensation. */
+/**
+ * The exposure the image is multiplied by: the setting itself, or a camera's on top of it as compensation, or with
+ * the automatic exposure only its compensation, the meter's own exposure being applied on the device.
+ */
 export function effectiveExposure(settings: GpuRenderSettings): number {
   const { camera, depthOfField, exposure } = settings;
 
+  // The meter's exposure is applied on the device, by the lens pass; what is left here is the compensation.
+  if (camera.autoExposure) return 2 ** (Number(camera.exposureCompensation) || 0);
+
   return camera.physicalExposure
     ? exposure * physicalExposure(depthOfField.aperture, camera.shutterSpeed, camera.iso)
     : exposure;

package/src/wgsl/lens.wgsl.ts

@@ -46,7 +46,8 @@ struct Lens {
   // 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,
+  // Whether the camera meters the image and exposes it to middle grey, which the meter pass works out.
+  autoExposure: f32,
 };
 
 const PI: f32 = 3.14159265358979;
@@ -61,6 +62,108 @@ const STREAK_TAPS: i32 = 24;
 @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>>;
+// What the camera's meter read: the exposure that brings the image's average to middle grey, in x.
+@group(0) @binding(7) var<storage, read_write> metered: array<vec4<f32>>;
+
+/** What a light meter calibrates to: an average scene reflects about eighteen percent. */
+const MIDDLE_GREY: f32 = 0.18;
+const METER_GRID: vec2<u32> = vec2<u32>(64u, 36u);
+const METER_THREADS: u32 = 256u;
+
+/**
+ * How far above middle grey the meter lets the bright end of the image land: three stops, where AgX still shows
+ * detail, three and a half under where it reaches white.
+ */
+const HIGHLIGHT_CEILING: f32 = 8.0;
+/** The share of the metered points that counts as the bright end: the light through a window, not a lamp's own pixels. */
+const HIGHLIGHT_SHARE: f32 = 0.03;
+/** Half stops of luminance, from 2^-16 to 2^16, which the bright end is found in. */
+const METER_BINS: u32 = 64u;
+
+var<workgroup> meterSums: array<vec2<f32>, 256>;
+var<workgroup> meterHistogram: array<atomic<u32>, 64>;
+
+/**
+ * The camera's meter: the image's average luminance over a grid of points, taken as the mean of the logarithms so that
+ * a bright window or a patch of sky cannot darken everything else, weighed towards the centre as a camera's
+ * centre-weighted metering is. What no path has reached yet, or is black, does not count. One workgroup reads the
+ * grid and sums it in shared memory.
+ *
+ * Then it guards the highlights, as a camera's matrix metering does: the average alone takes a dim attic with a shaft
+ * of sun in it to middle grey and burns the shaft out, where a photographer keeps the room dim. The brightest few
+ * percent of the points, found in a histogram of half stops, may land no more than {@link HIGHLIGHT_CEILING} times
+ * brighter; an even scene, whose bright end is close to its average, is left as the average says.
+ */
+@compute @workgroup_size(256, 1, 1)
+fn meter(@builtin(local_invocation_index) thread: u32) {
+  var sum = vec2<f32>(0.0);
+  let count = METER_GRID.x * METER_GRID.y;
+
+  if (thread < METER_BINS) {
+    atomicStore(&meterHistogram[thread], 0u);
+  }
+
+  workgroupBarrier();
+
+  for (var k = thread; k < count; k = k + METER_THREADS) {
+    let cell = vec2<f32>(f32(k % METER_GRID.x), f32(k / METER_GRID.x)) + 0.5;
+    let uv = cell / vec2<f32>(METER_GRID);
+    let luminance = dot(imageTexel(i32(uv.x * f32(lens.resolution.x)), i32(uv.y * f32(lens.resolution.y))),
+      vec3<f32>(0.2126, 0.7152, 0.0722));
+    let away = (uv - 0.5) * 2.0;
+    let weight = select(0.0, 1.0 - 0.6 * min(dot(away, away) * 0.5, 1.0), luminance > 0.0);
+
+    sum = sum + vec2<f32>(log(max(luminance, 1e-6)) * weight, weight);
+
+    if (luminance > 0.0) {
+      let bin = u32(clamp((log2(luminance) + 16.0) * 2.0, 0.0, f32(METER_BINS - 1u)));
+
+      atomicAdd(&meterHistogram[bin], 1u);
+    }
+  }
+
+  meterSums[thread] = sum;
+  workgroupBarrier();
+
+  for (var stride = METER_THREADS / 2u; stride > 0u; stride = stride / 2u) {
+    if (thread < stride) {
+      meterSums[thread] = meterSums[thread] + meterSums[thread + stride];
+    }
+
+    workgroupBarrier();
+  }
+
+  if (thread == 0u) {
+    let total = meterSums[0];
+    let average = select(MIDDLE_GREY, exp(total.x / max(total.y, 1e-6)), total.y > 0.0);
+    var exposure = MIDDLE_GREY / average;
+
+    // From the top down, the first half stop by which the bright share is reached; its upper edge is that end.
+    var points = 0u;
+
+    for (var bin = 0u; bin < METER_BINS; bin = bin + 1u) {
+      points = points + atomicLoad(&meterHistogram[bin]);
+    }
+
+    var above = 0u;
+    var bright = 0.0;
+
+    for (var bin = i32(METER_BINS) - 1; bin >= 0 && points > 0u; bin = bin - 1) {
+      above = above + atomicLoad(&meterHistogram[u32(bin)]);
+
+      if (f32(above) >= HIGHLIGHT_SHARE * f32(points)) {
+        bright = exp2(f32(bin + 1) * 0.5 - 16.0);
+        break;
+      }
+    }
+
+    if (bright > 0.0) {
+      exposure = min(exposure, HIGHLIGHT_CEILING * MIDDLE_GREY / bright);
+    }
+
+    metered[0] = vec4<f32>(clamp(exposure, 1e-4, 1e4), average, bright, 0.0);
+  }
+}
 
 /** 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> {
@@ -293,6 +396,10 @@ fn composite(@builtin(global_invocation_id) id: vec3<u32>) {
     color = mix(color, streakBilinear(position * vec2<f32>(lens.streakSize) / size), lens.glare);
   }
 
+  if (lens.autoExposure > 0.0) {
+    color = color * metered[0].x;
+  }
+
   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

@@ -64,8 +64,8 @@ const NO_LIGHT: u32 = 0xffffffffu;
  * 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;
+fn lightNodeImportance(tree: u32, node: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
+  let at = tree + node * TREE_NODE_WORDS;
   let low = extraVec4(at);
   let high = extraVec4(at + 4u);
 
@@ -125,13 +125,13 @@ fn lightNodeImportance(node: u32, position: vec3<f32>, normal: vec3<f32>) -> f32
   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> {
+/** The chance of stepping from a node of a tree (the lights' or the windows') to each of its children, from here. */
+fn lightChildOdds(tree: u32, 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);
+    importance[k] = lightNodeImportance(tree, select(right, left, k == 0u), position, normal);
   }
 
   let total = importance.x + importance.y;
@@ -139,20 +139,23 @@ fn lightChildOdds(left: u32, right: u32, position: vec3<f32>, normal: vec3<f32>)
   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>,
+/**
+ * An entry picked down a tree by importance from this point, with the chance of picking it; NO_LIGHT for none. The
+ * tree is the lights' or the windows', given by where its nodes and its leaves' list start.
+ */
+fn sampleLightTree(tree: u32, list: u32, 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 at = tree + 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 start = list + (first & ~TREE_LEAF) * TREE_ENTRY_WORDS;
       let count = textures[at + 13u];
       var slot = start + (count - 1u) * TREE_ENTRY_WORDS;
 
@@ -170,7 +173,7 @@ fn sampleLightTree(position: vec3<f32>, normal: vec3<f32>, u: f32, pdf: ptr<func
     }
 
     let second = textures[at + 13u];
-    let odds = lightChildOdds(first, second, position, normal);
+    let odds = lightChildOdds(tree, first, second, position, normal);
 
     if (odds.x + odds.y <= 0.0) {
       return NO_LIGHT;
@@ -208,7 +211,7 @@ fn lightTreePdf(index: u32, position: vec3<f32>, normal: vec3<f32>) -> f32 {
 
     let at = frame.lightTree + parent * TREE_NODE_WORDS;
     let first = textures[at + 12u];
-    let odds = lightChildOdds(first, textures[at + 13u], position, normal);
+    let odds = lightChildOdds(frame.lightTree, first, textures[at + 13u], position, normal);
 
     chance = chance * select(odds.y, odds.x, node == first);
     node = parent;
@@ -252,6 +255,119 @@ fn lightPdfOfTriangle(triangle: u32, position: vec3<f32>, normal: vec3<f32>) ->
   return 0.0;
 }
 
+/** Share of the sky's samples aimed through the windows, from a point inside a room. */
+const PORTAL_SHARE: f32 = 0.5;
+
+/**
+ * How often the sky is aimed at through the windows from this point: from inside a room, where something stands above
+ * it, half the time; outside never, where the open sky is better found by its brightness. A function of the point alone,
+ * so the heuristic can ask it again when a bounce ray escapes.
+ */
+fn portalChance(position: vec3<f32>) -> f32 {
+  if (!PORTALS || frame.portalCount == 0u) {
+    return 0.0;
+  }
+
+  return select(0.0, PORTAL_SHARE, traceAny(position, vec3<f32>(0.0, 1.0, 0.0), 1e30) != NO_HIT);
+}
+
+/** Window subtrees a ray's walk through the windows' tree keeps waiting. */
+const PORTAL_STACK: u32 = 32u;
+
+/**
+ * The solid angle density with which aiming through the windows produces this direction: over every window triangle
+ * it crosses, the chance the tree picks that window from here times the area density of a point on it, over the area
+ * it shows from here. The ray walks the tree as it would a hierarchy, by the nodes' boxes, carrying the chance of
+ * reaching each node, so the windows it misses cost a box test and the ones it crosses no walk back up.
+ */
+fn portalPdf(position: vec3<f32>, direction: vec3<f32>) -> f32 {
+  var nodes: array<u32, PORTAL_STACK>;
+  var chances: array<f32, PORTAL_STACK>;
+  var top = 1u;
+  let inverse = 1.0 / direction;
+  var pdf = 0.0;
+
+  nodes[0] = 0u;
+  chances[0] = 1.0;
+
+  loop {
+    if (top == 0u) {
+      break;
+    }
+
+    top = top - 1u;
+
+    let node = nodes[top];
+    let chance = chances[top];
+    let at = frame.portals + node * TREE_NODE_WORDS;
+
+    if (enterBox(extraVec4(at).xyz, extraVec4(at + 4u).xyz, position, inverse, 1e30) >= 1e30) {
+      continue;
+    }
+
+    let first = textures[at + 12u];
+    let second = textures[at + 13u];
+
+    if ((first & TREE_LEAF) != 0u) {
+      let start = frame.portalList + (first & ~TREE_LEAF) * TREE_ENTRY_WORDS;
+
+      for (var j = 0u; j < second; j = j + 1u) {
+        let slot = start + j * TREE_ENTRY_WORDS;
+        let triangle = textures[slot];
+        let t = intersectTriangle(leafOf(triangle), position, direction).x;
+
+        if (t > 0.0) {
+          let cosine = abs(dot(triangleNormal(triangle), direction));
+
+          pdf = pdf + chance * extraFloat(slot + 1u) * extraFloat(slot + 2u) * t * t / max(cosine, 1e-6);
+        }
+      }
+
+      continue;
+    }
+
+    let odds = lightChildOdds(frame.portals, first, second, position, vec3<f32>(0.0));
+
+    for (var k = 0u; k < 2u; k = k + 1u) {
+      if (odds[k] > 0.0 && top < PORTAL_STACK) {
+        nodes[top] = select(second, first, k == 0u);
+        chances[top] = chance * odds[k];
+        top = top + 1u;
+      }
+    }
+  }
+
+  return pdf;
+}
+
+/** A direction through a point on a window the tree picks from here, or none from a point on the window itself. */
+fn samplePortal(position: vec3<f32>, u: vec2<f32>) -> vec3<f32> {
+  var chance = 0.0;
+  var density = 0.0;
+  let triangle = sampleLightTree(frame.portals, frame.portalList, position, vec3<f32>(0.0), u.x, &chance, &density);
+
+  if (triangle == NO_LIGHT) {
+    return vec3<f32>(0.0);
+  }
+
+  // The tree spent the sample walking down; a fresh one places the point, which the pick does not depend on.
+  let point = trianglePointAt(triangle, triangleBarycentric(vec2<f32>(fract(u.x * 4096.0), u.y)));
+  let offset = point - position;
+
+  return select(vec3<f32>(0.0), normalize(offset), dot(offset, offset) > 1e-12);
+}
+
+/** The density of the sky's sampling from this point for this direction: by brightness, through windows, or both. */
+fn skyPdf(position: vec3<f32>, direction: vec3<f32>, share: f32) -> f32 {
+  var pdf = (1.0 - share) * environmentPdf(direction);
+
+  if (share > 0.0) {
+    pdf = pdf + share * portalPdf(position, direction);
+  }
+
+  return pdf;
+}
+
 /** The power heuristic: how much of a contribution the strategy that produced it keeps, against the other one. */
 fn misWeight(pdf: f32, other: f32) -> f32 {
   let a = pdf * pdf;
@@ -307,7 +423,7 @@ fn sampleLight(position: vec3<f32>, normal: vec3<f32>, pick: f32, u: vec2<f32>)
   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);
+    let index = sampleLightTree(frame.lightTree, frame.lightList, position, normal, pick / frame.localLightPick, &chance, &density);
 
     if (index == NO_LIGHT || chance <= 0.0) {
       return noLight();
@@ -356,17 +472,31 @@ fn sampleLightEntry(light: Light, pdf: f32, position: vec3<f32>, u: vec2<f32>) -
   sample.misPdf = 0.0;
 
   if (light.kind == LIGHT_ENVIRONMENT) {
-    let drawn = sampleEnvironmentDirection(u);
+    // From inside a room, part of the time through a window: daylight comes in there or not at all.
+    let share = portalChance(position);
+    var direction = vec3<f32>(0.0);
+
+    if (u.x < share) {
+      direction = samplePortal(position, vec2<f32>(u.x / share, u.y));
+    } else {
+      let drawn = sampleEnvironmentDirection(vec2<f32>(min((u.x - share) / (1.0 - share), 0.99999994), u.y));
+
+      if (drawn.pdf > 0.0) {
+        direction = drawn.direction;
+      }
+    }
+
+    let mixed = skyPdf(position, direction, share);
 
-    if (drawn.pdf <= 0.0) {
+    if (all(direction == vec3<f32>(0.0)) || mixed <= 0.0) {
       return noLight();
     }
 
-    let density = pdf * drawn.pdf;
+    let density = pdf * mixed;
 
-    sample.direction = drawn.direction;
+    sample.direction = direction;
     sample.distance = 1e30;
-    sample.value = environmentRadiance(drawn.direction) / density;
+    sample.value = environmentRadiance(direction) / density;
     // A bounce ray that escapes finds the same light, so the two strategies share it.
     sample.misPdf = density;