TAA Improvement

vtkext/private/module/CMakeLists.txt

@@ -80,7 +80,7 @@ set(classes
   vtkF3DUIObserver
   vtkF3DUIActor
   vtkF3DUserRenderPass
-  vtkF3DTAAResolvePass
+  vtkF3DTAAPass
   )
 
 if (F3D_MODULE_UI)

vtkext/private/module/Testing/TestF3DRenderPass.cxx

@@ -5,7 +5,7 @@
 
 #include "vtkF3DHexagonalBokehBlurPass.h"
 #include "vtkF3DRenderPass.h"
-#include "vtkF3DTAAResolvePass.h"
+#include "vtkF3DTAAPass.h"
 #include "vtkF3DUserRenderPass.h"
 
 #include <iostream>
@@ -15,7 +15,7 @@ int TestF3DRenderPass(int argc, char* argv[])
   vtkNew<vtkF3DRenderPass> pass;
   pass->Print(std::cout);
 
-  vtkNew<vtkF3DTAAResolvePass> taaP;
+  vtkNew<vtkF3DTAAPass> taaP;
   taaP->SetDelegatePass(pass);
   taaP->Print(std::cout);
 

vtkext/private/module/vtkF3DPolyDataMapper.cxx

@@ -213,13 +213,6 @@ void vtkF3DPolyDataMapper::ReplaceShaderValues(
 
   posImpl += "  gl_Position = MCDCMatrix * posMC;\n";
 
-  // TAA
-  type = uniforms->GetUniformTupleType("jitter");
-  if (type)
-  {
-    posImpl += "  gl_Position.xy += jitter * gl_Position.w;\n";
-  }
-
   if (this->PrimitiveInfo[this->LastBoundBO].LastLightComplexity > 0)
   {
     posImpl += "  vertexVCVSOutput = MCVCMatrix * posMC;\n";

vtkext/private/module/vtkF3DRenderer.cxx

@@ -11,7 +11,7 @@
 #include "vtkF3DPolyDataMapper.h"
 #include "vtkF3DRenderPass.h"
 #include "vtkF3DSolidBackgroundPass.h"
-#include "vtkF3DTAAResolvePass.h"
+#include "vtkF3DTAAPass.h"
 #include "vtkF3DUserRenderPass.h"
 
 #include <vtkAxesActor.h>
@@ -525,14 +525,14 @@ void vtkF3DRenderer::ConfigureRenderPasses()
 
   if (this->AntiAliasingModeEnabled == vtkF3DRenderer::AntiAliasingMode::TAA)
   {
-    vtkNew<vtkF3DTAAResolvePass> taaP;
+    vtkNew<vtkF3DTAAPass> taaP;
     taaP->SetDelegatePass(renderingPass);
     renderingPass = taaP;
 
     this->RenderWindow->AddObserver(
-      vtkCommand::WindowResizeEvent, taaP.Get(), &vtkF3DTAAResolvePass::ResetIterations);
+      vtkCommand::WindowResizeEvent, taaP.Get(), &vtkF3DTAAPass::ResetIterations);
     this->RenderWindow->GetInteractor()->GetInteractorStyle()->AddObserver(
-      vtkCommand::InteractionEvent, taaP.Get(), &vtkF3DTAAResolvePass::ResetIterations);
+      vtkCommand::InteractionEvent, taaP.Get(), &vtkF3DTAAPass::ResetIterations);
   }
 
   if (this->FinalShader.has_value())
@@ -2061,8 +2061,6 @@ void vtkF3DRenderer::UpdateActors()
 //----------------------------------------------------------------------------
 void vtkF3DRenderer::Render()
 {
-  this->ConfigureJitter(this->AntiAliasingModeEnabled == vtkF3DRenderer::AntiAliasingMode::TAA);
-
   if (!this->TimerVisible)
   {
     this->Superclass::Render();
@@ -3112,72 +3110,6 @@ void vtkF3DRenderer::ConfigureOpacityTransferFunction(vtkPiecewiseFunction* otf,
   }
 }
 
-//----------------------------------------------------------------------------
-void vtkF3DRenderer::ConfigureJitter(bool enable)
-{
-  // needs https://gitlab.kitware.com/vtk/vtk/-/merge_requests/12534
-#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251017)
-  if (!enable)
-  {
-    ExecFuncOnAllPolyDataUniforms(
-      this->GetActors(), [](vtkUniforms* uniforms) { uniforms->RemoveUniform("jitter"); });
-    return;
-  }
-#endif
-
-  float jitter[2];
-
-  if (enable)
-  {
-    jitter[0] = this->ConfigureHaltonSequence(0);
-    jitter[1] = this->ConfigureHaltonSequence(1);
-
-    vtkRenderWindow* renderWindow = this->GetRenderWindow();
-    int width = renderWindow->GetSize()[0];
-    int height = renderWindow->GetSize()[1];
-
-    jitter[0] = ((jitter[0] - 0.5f) / width) * 2.0f;
-    jitter[1] = ((jitter[1] - 0.5f) / height) * 2.0f;
-  }
-  else
-  {
-    jitter[0] = 0.0f;
-    jitter[1] = 0.0f;
-  }
-
-  ExecFuncOnAllPolyDataUniforms(
-    this->GetActors(), [&](vtkUniforms* uniforms) { uniforms->SetUniform2f("jitter", jitter); });
-}
-
-//----------------------------------------------------------------------------
-float vtkF3DRenderer::ConfigureHaltonSequence(int direction)
-{
-  assert(direction == 0 || direction == 1);
-
-  int base = 2 + direction;
-  int& numerator = this->TaaHaltonNumerator[direction];
-  int& denominator = this->TaaHaltonDenominator[direction];
-
-  int difference = denominator - numerator;
-  if (difference == 1)
-  {
-    numerator = 1;
-    denominator *= base;
-  }
-  else
-  {
-    int quotient = denominator / base;
-    while (difference <= quotient && quotient > 0)
-    {
-      quotient = quotient / base;
-    }
-
-    numerator = (base + 1) * quotient - difference;
-  }
-
-  return static_cast<float>(numerator) / static_cast<float>(denominator);
-}
-
 //----------------------------------------------------------------------------
 void vtkF3DRenderer::ConfigureScalarBarActorForColoring(
   vtkScalarBarActor* scalarBar, std::string arrayName, int component, vtkColorTransferFunction* ctf)

vtkext/private/module/vtkF3DRenderer.h

@@ -590,17 +590,6 @@ class vtkF3DRenderer : public vtkOpenGLRenderer
   static void ConfigureOpacityTransferFunction(vtkPiecewiseFunction* otf, double range[2],
     const std::vector<double>& opacityMap, bool inverseOpacityFlag);
 
-  /**
-   * Configure screen spaced jittering for TAA
-   */
-  void ConfigureJitter(bool enable);
-
-  /**
-   * Configure Halton sequence for TAA. Valid direction values are 0 and 1. Returns a value that is
-   * used for jitter
-   */
-  float ConfigureHaltonSequence(int direction);
-
   /**
    * Convenience method for configuring a scalar bar actor for coloring
    */
@@ -784,9 +773,6 @@ class vtkF3DRenderer : public vtkOpenGLRenderer
 
   std::vector<double> OpacityMap;
 
-  int TaaHaltonNumerator[2] = { 0, 0 };
-  int TaaHaltonDenominator[2] = { 1, 1 };
-
   SplatType PointSpritesType = SplatType::SPHERE;
   double PointSpritesSize = 10;
   bool PointSpritesAbsoluteScale = false;

vtkext/private/module/vtkF3DTAAResolvePass.cxx → vtkext/private/module/vtkF3DTAAPass.cxx

@@ -1,4 +1,4 @@
-#include "vtkF3DTAAResolvePass.h"
+#include "vtkF3DTAAPass.h"
 
 #include <vtkCamera.h>
 #include <vtkObjectFactory.h>
@@ -9,15 +9,16 @@
 #include <vtkOpenGLRenderWindow.h>
 #include <vtkOpenGLShaderCache.h>
 #include <vtkOpenGLState.h>
+#include <vtkPolyDataMapper.h>
 #include <vtkRenderState.h>
 #include <vtkRenderer.h>
 #include <vtkShaderProgram.h>
 #include <vtkTextureObject.h>
 
-vtkStandardNewMacro(vtkF3DTAAResolvePass);
+vtkStandardNewMacro(vtkF3DTAAPass);
 
 //------------------------------------------------------------------------------
-void vtkF3DTAAResolvePass::Render(const vtkRenderState* state)
+void vtkF3DTAAPass::Render(const vtkRenderState* state)
 {
   vtkOpenGLClearErrorMacro();
   this->NumberOfRenderedProps = 0;
@@ -74,10 +75,13 @@ void vtkF3DTAAResolvePass::Render(const vtkRenderState* state)
     this->FrameBufferObject->SetContext(renWin);
   }
 
+  this->ConfigureJitter(size[0], size[1]);
+  this->PreRender(state);
   renWin->GetState()->PushFramebufferBindings();
   this->RenderDelegate(
     state, size[0], size[1], size[0], size[1], this->FrameBufferObject, this->ColorTexture);
   renWin->GetState()->PopFramebufferBindings();
+  this->PostRender(state);
 
   if (!this->QuadHelper)
   {
@@ -128,7 +132,7 @@ void vtkF3DTAAResolvePass::Render(const vtkRenderState* state)
 }
 
 //------------------------------------------------------------------------------
-void vtkF3DTAAResolvePass::ReleaseGraphicsResources(vtkWindow* window)
+void vtkF3DTAAPass::ReleaseGraphicsResources(vtkWindow* window)
 {
   this->Superclass::ReleaseGraphicsResources(window);
 
@@ -145,3 +149,66 @@ void vtkF3DTAAResolvePass::ReleaseGraphicsResources(vtkWindow* window)
     this->HistoryTexture->ReleaseGraphicsResources(window);
   }
 }
+
+//------------------------------------------------------------------------------
+bool vtkF3DTAAPass::PreReplaceShaderValues(std::string& vertexShader,
+  std::string& vtkNotUsed(geometryShader), std::string& vtkNotUsed(fragmentShader),
+  vtkAbstractMapper* mapper, vtkProp* vtkNotUsed(prop))
+{
+  if (vtkPolyDataMapper::SafeDownCast(mapper) != nullptr)
+  {
+    vtkShaderProgram::Substitute(
+      vertexShader, "//VTK::Clip::Dec", "uniform vec2 jitter;\n//VTK::Clip::Dec", false);
+    vtkShaderProgram::Substitute(vertexShader, "//VTK::CustomEnd::Impl",
+      "  gl_Position.xy += jitter;\n//VTK::CustomEnd::Impl", false);
+  }
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool vtkF3DTAAPass::SetShaderParameters(vtkShaderProgram* program,
+  vtkAbstractMapper* vtkNotUsed(mapper), vtkProp* vtkNotUsed(prop),
+  vtkOpenGLVertexArrayObject* vtkNotUsed(VAO))
+{
+  program->SetUniform2f("jitter", this->Jitter);
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void vtkF3DTAAPass::ConfigureJitter(int w, int h)
+{
+  Jitter[0] = this->ConfigureHaltonSequence(0);
+  Jitter[1] = this->ConfigureHaltonSequence(1);
+
+  Jitter[0] = ((Jitter[0] - 0.5f) / w) * 2.0f;
+  Jitter[1] = ((Jitter[1] - 0.5f) / h) * 2.0f;
+}
+
+//------------------------------------------------------------------------------
+float vtkF3DTAAPass::ConfigureHaltonSequence(int direction)
+{
+  assert(direction == 0 || direction == 1);
+
+  int base = 2 + direction;
+  int& numerator = this->TaaHaltonNumerator[direction];
+  int& denominator = this->TaaHaltonDenominator[direction];
+
+  int difference = denominator - numerator;
+  if (difference == 1)
+  {
+    numerator = 1;
+    denominator *= base;
+  }
+  else
+  {
+    int quotient = denominator / base;
+    while (difference <= quotient && quotient > 0)
+    {
+      quotient = quotient / base;
+    }
+
+    numerator = (base + 1) * quotient - difference;
+  }
+
+  return static_cast<float>(numerator) / static_cast<float>(denominator);
+}

vtkext/private/module/vtkF3DTAAResolvePass.h → vtkext/private/module/vtkF3DTAAPass.h

@@ -19,11 +19,11 @@ class vtkOpenGLFramebufferObject;
 class vtkOpenGLQuadHelper;
 class vtkTextureObject;
 
-class vtkF3DTAAResolvePass : public vtkImageProcessingPass
+class vtkF3DTAAPass : public vtkImageProcessingPass
 {
 public:
-  static vtkF3DTAAResolvePass* New();
-  vtkTypeMacro(vtkF3DTAAResolvePass, vtkImageProcessingPass);
+  static vtkF3DTAAPass* New();
+  vtkTypeMacro(vtkF3DTAAPass, vtkImageProcessingPass);
 
   /**
    * Perform rendering according to a render state.
@@ -43,9 +43,32 @@ class vtkF3DTAAResolvePass : public vtkImageProcessingPass
     this->HistoryIteration = 0;
   }
 
+  /**
+   * Modify shader code for jittering
+   */
+  bool PreReplaceShaderValues(std::string& vertexShader, std::string& geometryShader,
+    std::string& fragmentShader, vtkAbstractMapper* mapper, vtkProp* prop) override;
+
+  /**
+   * Modify shader parameters for jittering
+   */
+  bool SetShaderParameters(vtkShaderProgram* program, vtkAbstractMapper* mapper, vtkProp* prop,
+    vtkOpenGLVertexArrayObject* VAO = nullptr) override;
+
 private:
-  vtkF3DTAAResolvePass() = default;
-  ~vtkF3DTAAResolvePass() override = default;
+  vtkF3DTAAPass() = default;
+  ~vtkF3DTAAPass() override = default;
+
+  /**
+   * Configure screen spaced jittering for TAA
+   */
+  void ConfigureJitter(int w, int h);
+
+  /**
+   * Configure Halton sequence for TAA. Valid direction values are 0 and 1. Returns a value that is
+   * used for jitter
+   */
+  float ConfigureHaltonSequence(int direction);
 
   vtkSmartPointer<vtkOpenGLFramebufferObject> FrameBufferObject;
   vtkSmartPointer<vtkTextureObject> ColorTexture;
@@ -54,5 +77,8 @@ class vtkF3DTAAResolvePass : public vtkImageProcessingPass
   std::shared_ptr<vtkOpenGLQuadHelper> QuadHelper;
 
   int HistoryIteration = 0;
+  float Jitter[2] = { 0.0f, 0.0f };
+  int TaaHaltonNumerator[2] = { 0, 0 };
+  int TaaHaltonDenominator[2] = { 1, 1 };
 };
 #endif