Reduced Lanczos texture reads and stabilized weights near zero

Author: Solessfir

common/graphics/renderer.cpp

@@ -754,7 +754,9 @@ void Renderer::drawTonemapping(Attachment& result, Encoder<CommandBuffer>& cmd,
   auto& pso = (settings.vidResIndex==0) ? shaders.tonemapping : shaders.tonemappingUpscale;
   cmd.setFramebuffer({ {result, Tempest::Discard, Tempest::Preserve} });
   cmd.setBinding(0, wview.sceneGlobals().uboGlobal[SceneGlobals::V_Main]);
-  cmd.setBinding(1, sceneLinear, Sampler::nearest(ClampMode::ClampToEdge)); // Lanczos upscale requires nearest sampling
+  const auto sampler = settings.vidResIndex==0 ? Sampler::nearest(ClampMode::ClampToEdge) :
+                                               Sampler::bilinear(ClampMode::ClampToEdge);
+  cmd.setBinding(1, sceneLinear, sampler);
   cmd.setPushData(p);
   cmd.setPipeline(pso);
   cmd.draw(nullptr, 0, 3);
@@ -805,7 +807,8 @@ void Renderer::drawCMAA2(Tempest::Attachment& result, Tempest::Encoder<Tempest::
   auto& psoTone = (settings.vidResIndex==0) ? shaders.tonemapping : shaders.tonemappingUpscale;
   cmd.setFramebuffer({{result, Tempest::Discard, Tempest::Preserve}});
   cmd.setBinding(0, wview.sceneGlobals().uboGlobal[SceneGlobals::V_Main]);
-  cmd.setBinding(1, sceneLinear, Sampler::nearest());
+  const auto sampler = settings.vidResIndex==0 ? Sampler::nearest() : Sampler::bilinear(ClampMode::ClampToEdge);
+  cmd.setBinding(1, sceneLinear, sampler);
   cmd.setPushData(&p, sizeof(p));
   cmd.setPipeline(psoTone);
   cmd.draw(nullptr, 0, 3);

shader/upscale/lanczos.glsl

@@ -3,15 +3,12 @@
 
 float lanczosWeight(float x, float r) {
   const float PI_SQ = 9.8696044010893586188344910;
-  if(x == 0.0)
+  // Use the analytic limit near zero to avoid unstable GPU sine/division results.
+  if(abs(x) < 0.0001)
     return 1.;
   return (r * sin(M_PI * x) * sin(M_PI * (x / r) )) / (PI_SQ * x*x);
   }
 
-float lanczosWeight(vec2 x, float r) {
-  return lanczosWeight(x.x, r) * lanczosWeight(x.y, r);
-  }
-
 vec3 lanczosUpscale(in sampler2D img, vec2 coord) {
   const int r = 2;
 
@@ -20,20 +17,34 @@ vec3 lanczosUpscale(in sampler2D img, vec2 coord) {
   coord      += -0.5 * resInv;
   vec2 ccoord = floor(coord * res) * resInv;
 
+  // Evaluate each one-dimensional weight once.
+  // Keep the original footprint, including its omitted four corner samples.
+  vec2 weights[5];
+  [[unroll]]
+  for(int i = -r; i <= r; ++i) {
+    vec2 d = ((vec2(i) * resInv + ccoord - coord) * res);
+    weights[i+r] = vec2(lanczosWeight(d.x, float(r)), lanczosWeight(d.y, float(r)));
+    }
+
+  // The weights at offsets zero and one have the same sign.
+  // A bilinear read combines them without replacing the Lanczos kernel.
+  // The caller must use a linear, clamp-to-edge sampler.
+  vec2 centerWeight = weights[2] + weights[3];
+  vec2 centerOffset = clamp(weights[3] / centerWeight, vec2(0), vec2(1));
+  vec2 offsets[4] = vec2[4](vec2(-2), vec2(-1), centerOffset, vec2(2));
+  vec2 merged[4] = vec2[4](weights[0], weights[1], centerWeight, weights[4]);
+
   vec3 total = vec3(0);
   [[unroll]]
-  for(int x = -r; x <= r; x++) {
+  for(int x = 0; x < 4; x++) {
     [[unroll]]
-    for(int y = -r; y <= r; y++) {
-      if(abs(x)==r && abs(y)==r)
+    for(int y = 0; y < 4; y++) {
+      if((x==0 || x==3) && (y==0 || y==3))
         continue;
 
-      vec2  offs   = vec2(x,y);
-      vec2  sco    = offs * resInv + ccoord;
-      vec2  d      = ((sco - coord) * res);
-
+      vec2  sco    = vec2(offsets[x].x, offsets[y].y) * resInv + ccoord;
       vec3  val    = textureLod(img, sco+0.5*resInv, 0.0).rgb;
-      float weight = lanczosWeight(d, float(r));
+      float weight = merged[x].x * merged[y].y;
 
       total     += val * weight;
       }