reze-engine 0.41.0 → 0.41.2

package/src/shaders/passes/composite.ts

@@ -60,7 +60,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 11>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 15>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -84,7 +84,7 @@ override APPLY_GAMMA: bool = true;
 //            the compiled variant IS the flag.
 // viewU[3] = (camera right, tanHalfFov·aspect); viewU[4] = (camera up, tanHalfFov);
 // viewU[5] = (camera forward, _) — refreshed per frame while skybox/effect active.
-// viewU[6] = (time seconds, _, canvas width, canvas height).
+// viewU[6] = (time seconds, view transform id, canvas width, canvas height).
 // viewU[7] = (grade offset.rgb, contrast);  viewU[8] = (grade power.rgb, saturation);
 // viewU[9] = (grade slope.rgb, grade on/off) — see grade() below.
 // viewU[10] = (camera world position, _) — refreshed with the basis above.
@@ -104,6 +104,9 @@ override APPLY_GAMMA: bool = true;
 //           track the camera radius. Cleared depth (1.0) inverts to the far
 //           plane, so empty sky reads as maximally defocused background.
 @group(0) @binding(9) var<uniform> dofU: array<vec4<f32>, 3>;
+// Blender's AgX, as the 57³ lookup it ships as rather than a reconstruction of
+// it. Sampled in the log-encoded E-Gamut space the cube expects — see agxTransform.
+@group(0) @binding(10) var agxLut: texture_3d<f32>;
 
 // Must match FILMIC_LUT_WIDTH in engine.ts (bakeFilmicLut).
 const FILMIC_LUT_W: f32 = 256.0;
@@ -147,12 +150,82 @@ fn filmic(x: f32) -> f32 {
   return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;
 }
 
+/** The sRGB display encoding — Blender's "Standard" view transform, which is what
+ *  NPR work uses: no film curve at all, so the colours a graph computes are the
+ *  colours that land. Not a 2.2 power law; sRGB has a linear toe. */
+fn srgb_encode(x: f32) -> f32 {
+  let c = max(x, 0.0);
+  return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);
+}
+
+/**
+ * AgX, the chain config.ocio states for "AgX Base Rec.1886" on an sRGB display:
+ *
+ *   scene-linear Rec.709 → 3x3 into FilmLight E-Gamut
+ *   → log2 across 25 stops, [-12.47393, +12.5261] → 0..1
+ *   → the 57³ cube
+ *   → Rec.1886 (pure γ2.4) decoded, then re-encoded as sRGB for the swapchain
+ *
+ * The last step is not pedantry: Rec.1886 is a pure power law and sRGB has a
+ * linear toe, so skipping it lifts the darkest few code values.
+ *
+ * Blender interpolates the cube tetrahedrally and a GPU sampler is trilinear.
+ * The difference is small and confined to saturated gradients; if it ever shows,
+ * tetrahedral is a dozen lines here.
+ */
+fn agxTransform(c: vec3f) -> vec3f {
+  let m = mat3x3<f32>(
+    vec3f(0.55937113, 0.07622071, 0.06552670),
+    vec3f(0.30478326, 0.78797183, 0.16454675),
+    vec3f(0.13584556, 0.13580748, 0.76992653),
+  );
+  let e = m * max(c, vec3f(0.0));
+  // The cube's domain: an unlit pixel would take log2 to -inf, so floor it at
+  // the bottom stop rather than sampling outside the LUT.
+  let t = clamp((log2(max(e, vec3f(1e-10))) + vec3f(12.47393)) / 25.0, vec3f(0.0), vec3f(1.0));
+  // Half-texel inset, so the end stops are the cube's own values and not a blend
+  // with the clamp-to-edge border.
+  let n = 57.0;
+  let uvw = t * ((n - 1.0) / n) + (0.5 / n);
+  let formed = textureSampleLevel(agxLut, bloomSamp, uvw, 0.0).rgb;
+  let linear = pow(max(formed, vec3f(0.0)), vec3f(2.4));
+  return vec3f(srgb_encode(linear.r), srgb_encode(linear.g), srgb_encode(linear.b));
+}
+
+/** Which display transform, chosen per frame at viewU[6].y (0 filmic, 1 standard, 2 agx).
+ *  A uniform branch rather than a pipeline variant: switching is rare, and both
+ *  arms are cheap enough that specialising the pipeline would buy nothing. */
+fn viewTransform(c: vec3f) -> vec3f {
+  let mode = viewU[6].y;
+  if (mode > 1.5) { return agxTransform(c); }
+  if (mode > 0.5) { return vec3f(srgb_encode(c.r), srgb_encode(c.g), srgb_encode(c.b)); }
+  return vec3f(filmic(c.r), filmic(c.g), filmic(c.b));
+}
+
 /** Canvas size in pixels — for user effects (aspect correction). */
 fn bgResolution() -> vec2f { return viewU[6].zw; }
 
 /** The camera's world position. */
 fn bgCameraPos() -> vec3f { return viewU[10].xyz; }
 
+/** How many characters are in the scene, up to four. */
+fn bgSubjectCount() -> i32 { return i32(viewU[10].w); }
+
+/**
+ * Where a character is standing, in world space.
+ *
+ * An effect that wants to RESPOND to the cast — ripples under the feet, a glow
+ * that follows someone, dust kicked up where they are — needs to know where
+ * they are, and the ray and the depth cannot tell it: they describe the pixel,
+ * not the scene. This is the model's root, which for a PMX is between the feet
+ * on the floor, so it is already the contact point a ripple wants.
+ *
+ * Clamped rather than bounds-checked: an effect looping past the count reads the
+ * last subject instead of sampling whatever follows the array, which is a wrong
+ * ripple rather than an undefined one.
+ */
+fn bgSubjectPos(i: i32) -> vec3f { return viewU[11 + clamp(i, 0, 3)].xyz; }
+
 /** Where in the WORLD the scene drew this pixel — the depth handed to
  *  foreground() turned into a place. Without it an effect can only think in
  *  distances from the lens, which is no use to anything that belongs somewhere:
@@ -260,8 +333,7 @@ const COMPOSITE_BODY = /* wgsl */ `
   let sceneStraight = scenePm.rgb / max(sceneAlpha, 1e-6);
 
   let exposed = sceneStraight * exp2(viewU[0].x);
-  let tm = vec3f(filmic(exposed.r), filmic(exposed.g), filmic(exposed.b));
-  var disp = max(tm, vec3f(0.0));
+  var disp = max(viewTransform(exposed), vec3f(0.0));
   // Grade the SCENE only, before the display gamma. Deliberately not applied to
   // the background: it keeps a picked background color exactly as picked, and —
   // load-bearing — leaves green-screen mode's key color unshifted so chroma