@tinypoly/gpu-renderer 0.1.1 → 0.2.1

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;
 

package/src/wgsl/pathTrace.wgsl.ts

@@ -42,7 +42,9 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
     return frame.background.rgb;
   }
 
-  // A procedural sky paints the background without the strength it lights with, and its foreground over it.
+  // A procedural sky paints the background with the strength it lights with, and its foreground over it. The CPU
+  // renderer leaves that strength out of what the camera sees, which a renderer exposing for the light cannot: the sky
+  // that lights a wall five times brighter than itself would show as a dark band behind it.
   if (frame.skyProgram != NO_PROGRAM || frame.skyIntensity > 0.0) {
     if (frame.skyBackground == 0u) {
       return vec3<f32>(0.0);
@@ -54,10 +56,10 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
       input.direction = direction;
       input.diffuseColor = vec4<f32>(1.0);
 
-      return runProgram(frame.skyProgram, input).color.rgb;
+      return runProgram(frame.skyProgram, input).color.rgb * frame.skyIntensity;
     }
 
-    return environmentRadiance(direction) / frame.skyIntensity;
+    return environmentRadiance(direction);
   }
 
   return environmentRadiance(direction);
@@ -67,7 +69,7 @@ fn backgroundRadiance(direction: vec3<f32>) -> vec3<f32> {
  * How much of the sky a bounce ray that escaped keeps. Direct sampling aims at the bright parts of an image too, so the
  * two share it; when direct sampling took all of it, as it does from a toon surface, the bounce keeps none.
  */
-fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f32 {
+fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool, scatteredAt: vec3<f32>) -> f32 {
   if (frame.environmentPick <= 0.0) {
     return 1.0;
   }
@@ -80,7 +82,8 @@ fn escapeWeight(direction: vec3<f32>, bsdfPdf: f32, lightsOwnDirect: bool) -> f3
     return 1.0;
   }
 
-  return misWeight(bsdfPdf, frame.environmentPick * environmentPdf(direction));
+  // The sky was aimed at from the vertex the bounce left, through its windows as well when that vertex is inside.
+  return misWeight(bsdfPdf, frame.environmentPick * skyPdf(scatteredAt, direction, portalChance(scatteredAt)));
 }
 
 /** Scales a contribution down to the luminance ceiling, which trades a little bias for the fireflies it removes. */
@@ -548,7 +551,7 @@ fn traceRadiance(
         if (escapeMap != NO_TEXTURE) {
           sky = sky + sampleEquirect(escapeMap, direction).rgb * escapeIntensity;
         } else {
-          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect);
+          sky = sky + environmentRadiance(direction) * escapeWeight(direction, bsdfPdf, lightsOwnDirect, lastPosition);
         }
 
         let contribution = throughput * sky;
@@ -703,8 +706,14 @@ fn traceRadiance(
       depth = length(point - rayOrigin);
     }
 
+    // A window the camera ray goes straight through is not what the camera sees: what lies behind it is, so the
+    // denoiser takes its guides there, and the air its distance. Glass has next to no diffuse colour and one flat
+    // normal, which would leave everything seen through it unfiltered. The window's own guides stand until then, for
+    // the paths that reflect off it instead.
+    let window = surface.transmission > 0.0 && surface.thickness <= 0.0;
+
     if (straight && !guided) {
-      guided = true;
+      guided = !window;
       diffuseAlbedo = diffuseGuide(surface);
       specularAlbedoGuide = select(specularAlbedo(surface, -direction), vec3<f32>(1.0), (surface.flags & MATERIAL_LIT) == 0u);
       guideNormal = surface.normal;
@@ -745,7 +754,7 @@ fn traceRadiance(
         }
       }
 
-      if (!hazed && frame.atmosphereColor.w > 0.0) {
+      if (!hazed && !window && frame.atmosphereColor.w > 0.0) {
         hazed = true;
         // From the eye, where the camera ray only starts on the near plane; an orthographic view has no eye.
         hazeDistance = length(point - select(frame.cameraToWorld[3].xyz, rayOrigin, frame.cameraKind == 1u));
@@ -765,7 +774,11 @@ fn traceRadiance(
     }
 
     // Three does not light a basic, points, line or sprite material, so nothing carries on from one.
-    if ((surface.flags & MATERIAL_LIT) == 0u || bounce >= frame.bounces) {
+    // Past the last bounce a path still crosses a window straight on, which scatters nothing, to find the sky behind
+    // it: cut there, the daylight a room gets through its glazing would go missing from every last bounce.
+    let spent = bounce >= frame.bounces;
+
+    if ((surface.flags & MATERIAL_LIT) == 0u || (spent && !window)) {
       break;
     }
 
@@ -788,8 +801,105 @@ fn traceRadiance(
     var nextOrigin = point + direction * RAY_EPSILON;
 
     // Transmission replaces part of the diffuse layer, so that share of the time the surface is a dielectric instead.
-    // Choosing it in proportion to its weight leaves both halves unweighted, and only the opaque half aims at a light.
-    if (surface.transmission > 0.0 && lobe.y < surface.transmission) {
+    // Choosing it in proportion to its weight leaves both halves unweighted. The opaque half aims at a light; on a
+    // window that lets only part of the light through, it does so on every path, weighed by its share, rather than on
+    // the paths that chose it: a sunlit pane seen against a dim room would otherwise be lit on one path in five and
+    // dark on the rest, which is the grain glass shows.
+    let dielectric = surface.transmission > 0.0 && lobe.y < surface.transmission;
+    let windowLight = window && !spent && surface.transmission < 1.0 && surface.subsurface <= 0.0;
+
+    if (!dielectric || windowLight) {
+      var chance = 0.0;
+
+      if (!dielectric) {
+        // Light that enters the material: a random walk inside it from here, in place of the share of the diffuse
+        // layer that scatters inside. Chosen by chance, so neither branch is weighted against the other.
+        // The window's opaque share is a surface like any other, which a spent path stops at.
+        if (spent) {
+          break;
+        }
+
+        if (SUBSURFACE_WALK) {
+          chance = subsurfaceChance(surface, view);
+        }
+
+        if (SUBSURFACE_WALK && lobe.x < chance) {
+          let medium = materials[surface.material].subsurface;
+
+          throughput = throughput
+            * ((1.0 - surface.metalness) * surface.subsurface * coatTransmittance(surface, view) / chance);
+          sigma = vec3<f32>(1.0) / max(medium.rgb, vec3<f32>(1e-6));
+          walkAlbedo = subsurfaceAlbedo(surface.albedo);
+          walkG = materials[surface.material].subsurfaceAnisotropy;
+          walkSteps = 0u;
+
+          // Light that scattered inside is diffuse light, which is the signal it feeds.
+          if (!split) {
+            split = true;
+            splitBase = radiance;
+            splitDiffuse = true;
+          }
+
+          inMedium = true;
+          primary = false;
+          straight = false;
+          bsdfPdf = 0.0;
+          lightsOwnDirect = false;
+          escapeMap = NO_TEXTURE;
+          bounce = bounce + 1u;
+          direction = cosineDirection(-surface.facing, bounceSample);
+          origin = point - surface.facing * RAY_EPSILON;
+          limit = walkDistance(throughput, sigma, pick, &walkOdds);
+          continue;
+        }
+
+        throughput = throughput / (1.0 - chance);
+      }
+
+      let position = point + surface.normal * RAY_EPSILON;
+      var directDiffuse: vec3<f32>;
+      let lit = select(throughput, throughput * (1.0 - surface.transmission), windowLight);
+      let direct = lit * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse,
+        select(0.0, volumeDensity, inVolume));
+      let added = select(direct, clampIndirect(direct), bounce > 0u);
+      let before = radiance;
+
+      radiance = radiance + added;
+
+      if (!dielectric) {
+        let scattered = sampleBsdf(surface, view, (lobe.x - chance) / (1.0 - chance), bounceSample);
+
+        // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.
+        if (!split) {
+          split = true;
+          splitBase = before;
+          splitDirect = added;
+          splitDirectDiffuse = lit * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),
+            bounce > 0u);
+          splitDiffuse = !scattered.valid || scattered.diffuse;
+          waitingForSpecular = scattered.valid && !scattered.diffuse;
+        }
+
+        if (!scattered.valid) {
+          break;
+        }
+
+        throughput = throughput * scattered.weight;
+        bsdfPdf = scattered.pdf;
+        lastPosition = position;
+        lastNormal = treeNormal(surface);
+        lightsOwnDirect = surface.kind == KIND_TOON;
+        escapeMap = surface.envMap;
+        escapeIntensity = surface.envMapIntensity;
+        next = scattered.direction;
+        nextOrigin = position;
+        primary = false;
+        straight = false;
+        bounce = bounce + 1u;
+      }
+    }
+
+    if (dielectric) {
       var ior = surface.ior;
 
       // Three's dispersion: each colour refracts with its own index, spread around the material's. The path picks one
@@ -809,7 +919,8 @@ fn traceRadiance(
 
       let crossing = sampleDielectric(surface, view, ior, lobe.y / surface.transmission, bounceSample);
 
-      if (!crossing.valid) {
+      // A reflection off the glass is a scattering, which a spent path no longer has.
+      if (!crossing.valid || (spent && !crossing.straight)) {
         break;
       }
 
@@ -844,85 +955,6 @@ fn traceRadiance(
       if (!primary) {
         bounce = bounce + 1u;
       }
-    } else {
-      // Light that enters the material: a random walk inside it from here, in place of the share of the diffuse
-      // layer that scatters inside. Chosen by chance, so neither branch is weighted against the other.
-      var chance = 0.0;
-
-      if (SUBSURFACE_WALK) {
-        chance = subsurfaceChance(surface, view);
-      }
-
-      if (SUBSURFACE_WALK && lobe.x < chance) {
-        let medium = materials[surface.material].subsurface;
-
-        throughput = throughput
-          * ((1.0 - surface.metalness) * surface.subsurface * coatTransmittance(surface, view) / chance);
-        sigma = vec3<f32>(1.0) / max(medium.rgb, vec3<f32>(1e-6));
-        walkAlbedo = subsurfaceAlbedo(surface.albedo);
-        walkG = materials[surface.material].subsurfaceAnisotropy;
-        walkSteps = 0u;
-
-        // Light that scattered inside is diffuse light, which is the signal it feeds.
-        if (!split) {
-          split = true;
-          splitBase = radiance;
-          splitDiffuse = true;
-        }
-
-        inMedium = true;
-        primary = false;
-        straight = false;
-        bsdfPdf = 0.0;
-        lightsOwnDirect = false;
-        escapeMap = NO_TEXTURE;
-        bounce = bounce + 1u;
-        direction = cosineDirection(-surface.facing, bounceSample);
-        origin = point - surface.facing * RAY_EPSILON;
-        limit = walkDistance(throughput, sigma, pick, &walkOdds);
-        continue;
-      }
-
-      throughput = throughput / (1.0 - chance);
-
-      let position = point + surface.normal * RAY_EPSILON;
-      var directDiffuse: vec3<f32>;
-      let direct = throughput * directLight(surface, position, view, pick.x, lightSample, rng, &directDiffuse,
-        select(0.0, volumeDensity, inVolume));
-      let added = select(direct, clampIndirect(direct), bounce > 0u);
-      let before = radiance;
-
-      radiance = radiance + added;
-
-      let scattered = sampleBsdf(surface, view, (lobe.x - chance) / (1.0 - chance), bounceSample);
-
-      // The first scatter splits the path: its direct light by lobe, and everything after it by the lobe it chose.
-      if (!split) {
-        split = true;
-        splitBase = before;
-        splitDirect = added;
-        splitDirectDiffuse = throughput * directDiffuse * select(1.0, luminanceOf(added) / max(luminanceOf(direct), 1e-20),
-          bounce > 0u);
-        splitDiffuse = !scattered.valid || scattered.diffuse;
-        waitingForSpecular = scattered.valid && !scattered.diffuse;
-      }
-
-      if (!scattered.valid) {
-        break;
-      }
-
-      throughput = throughput * scattered.weight;
-      bsdfPdf = scattered.pdf;
-      lastPosition = position;
-      lastNormal = treeNormal(surface);
-      lightsOwnDirect = surface.kind == KIND_TOON;
-      escapeMap = surface.envMap;
-      escapeIntensity = surface.envMapIntensity;
-      next = scattered.direction;
-      nextOrigin = position;
-      primary = false;
-      straight = false;
-      bounce = bounce + 1u;
     }
 
     // A path that carries almost nothing is ended by chance rather than by a cut, which keeps the estimate unbiased.

package/src/wgsl/present.wgsl.ts

@@ -15,6 +15,8 @@ struct Present {
   transparent: u32,
   // Whether the colour comes from the denoiser's output rather than straight from the accumulation.
   denoised: u32,
+  // How much of AgX's Punchy look goes over its base curve.
+  contrast: f32,
 };
 
 @group(0) @binding(0) var<uniform> present: Present;
@@ -63,8 +65,16 @@ fn toneMapAgx(color: vec3<f32>) -> vec3<f32> {
     vec3<f32>(-0.0728, -0.0083, 1.1187));
   let logged = inset * (toAgx * color);
   let x = clamp((log2(max(logged, vec3<f32>(1e-10))) + 12.47393) / 16.499999, vec3<f32>(0.0), vec3<f32>(1.0));
-  let curved = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))
+  let base = 15.5 * pow(x, vec3<f32>(6.0)) - 40.14 * pow(x, vec3<f32>(5.0)) + 31.96 * pow(x, vec3<f32>(4.0))
     - 6.868 * pow(x, vec3<f32>(3.0)) + 0.4298 * x * x + 0.1191 * x - 0.00232;
+  // A look in the spirit of Blender's Punchy, a power of 1.35 and more saturation, but pivoted on middle grey: Punchy
+  // raises the power around zero, which takes middle grey from half the display down to a third and darkens the whole
+  // image. Here the highlights rise and the shadows fall while grey, which the automatic exposure aims at, stands.
+  let pivot = 0.49673;
+  let contrasted = pivot * pow(max(base, vec3<f32>(0.0)) / pivot, vec3<f32>(1.35));
+  let luma = dot(contrasted, vec3<f32>(0.2126, 0.7152, 0.0722));
+  let punchy = luma + 1.2 * (contrasted - luma);
+  let curved = mix(base, punchy, clamp(present.contrast, 0.0, 1.0));
 
   return fromAgx * pow(max(outset * curved, vec3<f32>(0.0)), vec3<f32>(2.2));
 }