Engine: native preset L (rrlite unfolded input, expansion and reconstruction stages)

engine/post_m.comp

@@ -9,6 +9,12 @@
 // worst case of its range, 1.5x). TILE_W/TILE_H select the tile for the engine's own 16x16-pixel block: 10x10
 // covers reconstruction/render >= 3; 11x11 covers render/reconstruction <= 0.45 with jitter in [-0.5, 0.5];
 // 15x15 covers the whole post_3_2 range (render/reconstruction <= 2/3).
+//
+// PRESET_L: preset L's rrlite_post_3_* (unfolded). The same body with two differences (L_NOTES.md): the Gaussians
+// cover the 4x4 render texels from -1 to +2 around floor(position - 0.5), so every tile tier is one texel wider
+// (11, 12, 16), and the history is blended in linear light: each candidate's bicubic sample is expanded and divided by
+// the previous exposure on its own, a candidate off screen (or after a reset) takes the linear colour texel, and the
+// blend is scaled by the current exposure.
 #extension GL_EXT_shader_explicit_arithmetic_types : require
 #extension GL_GOOGLE_include_directive : require
 #include "normalized_store.glsl"
@@ -42,6 +48,14 @@ layout(set = 0, binding = 11, std430) writeonly buffer Packed { uint w[]; } pack
 #ifndef TILE_H
 #define TILE_H 10
 #endif
+#ifndef PRESET_L
+#define PRESET_L 0
+#endif
+#if PRESET_L
+const int TAP_LO = -1, TAP_HI = 2;
+#else
+const int TAP_LO = -1, TAP_HI = 1;
+#endif
 shared f16vec4 tile0[TILE_W * TILE_H], tile1[TILE_W * TILE_H], tile2[TILE_W * TILE_H];
 shared vec3 colSum[128];           // vertical pair first, then the neighbouring column
 const float L10 = 3.3219281;        // log2(10)
@@ -88,6 +102,17 @@ vec3 history(vec2 q)
                    textureLod(histTex, vec2(lo.x, mid.y), 0.0).rgb * a))));
     return s * (1.0 / (e + (d + (c + (b + a)))));
 }
+#if PRESET_L
+vec3 historyLinear(vec2 q, float e2)
+{
+    const vec3 h = history(q);
+#if LDR
+    return h;
+#else
+    return e2 > 0.0 ? expand(h) * (1.0 / e2) : h;
+#endif
+}
+#endif
 void main()
 {
     const ivec2 lid = ivec2(gl_LocalInvocationID.xy), gid = ivec2(gl_GlobalInvocationID.xy);
@@ -154,10 +179,10 @@ void main()
             f16vec4 a0 = f16vec4(0.0), a1 = f16vec4(0.0);
             float16_t a2 = float16_t(0.0);
             float W = 0.0;
-            for (int i = -1; i <= 1; ++i)
+            for (int i = TAP_LO; i <= TAP_HI; ++i)
             {
                 const float16_t dx = d0.x + float16_t(i), sq = dx * dx;
-                for (int j = -1; j <= 1; ++j)
+                for (int j = TAP_LO; j <= TAP_HI; ++j)
                 {
                     const int k = (base.y - origin.y + j) * TILE_W + (base.x - origin.x + i);
                     const f16vec4 t2 = tile2[k];
@@ -186,6 +211,19 @@ void main()
             // the fallback colour is only fetched where the history sample leaves the image or the history was reset:
             // the value is the same either way, so computing it in the branch saves the fetch on ordinary pixels
             const bool out1 = q1.x < 0.0 || q1.y < 0.0 || q1.x > size.x || q1.y > size.y || p.reset != 0u;
+#if PRESET_L
+            // linear light: a sample's expansion (when the previous exposure is positive) or the colour texel
+            const vec3 h1 = out1 ? texelFetch(colorTex, colourTexel(near), 0).rgb : historyLinear(q1, p.expoPrev == 0.0 ? 1.0 : p.expoPrev);
+            vec3 h2 = vec3(0.0);
+            if (b2 > 0.0)
+            {
+                const vec2 q2 = centre + second.xy;
+                if (q2.x < 0.0 || q2.y < 0.0 || q2.x > size.x || q2.y > size.y || p.reset != 0u)
+                    h2 = out1 ? h1 : texelFetch(colorTex, colourTexel(near), 0).rgb;
+                else h2 = historyLinear(q2, p.expoPrev == 0.0 ? 1.0 : p.expoPrev);
+            }
+            const vec3 hist = e1 * fma(vec3(b1), h1, b2 * h2);
+#else
             const vec3 h1 = out1 ? compress(e2 * texelFetch(colorTex, colourTexel(near), 0).rgb) : history(q1);
             vec3 h2 = vec3(0.0);
             if (b2 > 0.0)
@@ -196,6 +234,7 @@ void main()
                 else h2 = history(q2);
             }
             const vec3 hist = e1 * (expand(fma(vec3(b1), h1, b2 * h2)) * (1.0 / e2));
+#endif
             const vec3 lin = expand(cur);
             const float g0 = clamp(p.gain * W * g.x, 0.0, 1.0);
             const float ga = fma(g0, 1.0 - g.y, g.y), gb = fma(g0, 1.0 - g.z, g.z);