Merge topic 'oit_msaa'

584e289 Add release note for the new UseOIT flag
2f293a0 Add a test for vtkRenderer::UseOIT
2109b3c Add an option to toggle using OIT for translucent actors

Acked-by: Kitware Robot <[email protected]>
Tested-by: buildbot <[email protected]>
Reviewed-by: Lucas Gandel <[email protected]>
Acked-by: Lucas Givord <[email protected]>
Merge-request: !12001

Author: sankhesh

Documentation/release/dev/OIT_with_MSAA.png

@@ -0,0 +1,17 @@
+## Add UseOIT flag to vtkRenderer
+
+`vtkRenderer` now has a new flag (`UseOIT`) to toggle the use of the new
+`vtkOrderIndependentTranslucentPass` (OIT) for rendering translucent polygonal geometry. This flag
+is enabled by default which means the renderer uses OIT by default.
+
+OIT is a newer approach to translucent rendering that yields better results without any performance
+trade-offs. However, this conflicts with other features of the vtkRenderer, namely MSAA based
+anti-aliasing. If you would like to use MSAA for anti-aliasing in a scene with translucent geometry,
+it is best to disable `UseOIT`.
+
+The following pair of images show the use of this flag.
+
+|MultiSamples: 8, UseOIT: True|MultiSamples: 8, UseOIT: False|
+|:--:|:--:|
+|i.e. MSAA with OIT |i.e. MSAA without OIT |
+|![](./OIT_with_MSAA.png)|![](https://vtk.org/files/ExternalData/SHA512/b5dce5a56db0d685c638e3383536bcbb1cbf0b71040989c7fad040f221f4527f761d7cd22c7e4dd63aaf368cc236e366d37c4832b07f59f50b6928d223f7da9e)|

Documentation/release/dev/useoit_translucent.md

@@ -95,6 +95,7 @@ vtk_add_test_cxx(vtkRenderingCoreCxxTests tests
   TestOffAxisStereo.cxx
   TestOnAndOffScreenConeCxx.cxx
   TestOpacity.cxx
+  TestOpacityMSAA.cxx
   TestOrderedTriangulator.cxx
   TestOSConeCxx.cxx
   TestPickingManager.cxx,NO_VALID

Rendering/Core/Testing/Cxx/CMakeLists.txt

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+
+/**
+ * This test covers rendering of translucent geometry along with anti-aliasing using MSAA
+ */
+
+#include "vtkActor.h"
+#include "vtkCamera.h"
+#include "vtkConeSource.h"
+#include "vtkNew.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkProperty.h"
+#include "vtkRegressionTestImage.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkRenderer.h"
+#include "vtkTesting.h"
+
+int TestOpacityMSAA(int argc, char* argv[])
+{
+  cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
+
+  vtkNew<vtkConeSource> c1;
+  c1->SetResolution(1);
+  c1->SetCenter(-0.5, 0, 0);
+  c1->SetRadius(1.3);
+  vtkNew<vtkPolyDataMapper> m1;
+  m1->SetInputConnection(c1->GetOutputPort());
+  vtkNew<vtkActor> a1;
+  a1->SetMapper(m1);
+
+  vtkNew<vtkConeSource> c2;
+  c2->SetResolution(1);
+  c2->SetCenter(0.5, 0, 0);
+  c2->SetRadius(1.3);
+  c2->SetDirection(-1, 0, 0);
+  vtkNew<vtkPolyDataMapper> m2;
+  m2->SetInputConnection(c2->GetOutputPort());
+  vtkNew<vtkActor> a2;
+  a2->SetMapper(m2);
+  a2->GetProperty()->SetOpacity(0.5);
+
+  vtkNew<vtkRenderWindow> renWin;
+  renWin->SetMultiSamples(8); // enable multisampling
+  renWin->SetSize(301, 300);  // Intentional NPOT size
+
+  vtkNew<vtkRenderer> ren;
+  ren->AddActor(a1);
+  ren->AddActor(a2);
+  renWin->AddRenderer(ren);
+  ren->ResetCamera();
+  ren->GetActiveCamera()->Roll(4);
+  ren->SetUseOIT(false); // disable OIT pass
+
+  vtkNew<vtkRenderWindowInteractor> iren;
+  iren->SetRenderWindow(renWin);
+
+  renWin->Render();
+  int retVal = vtkRegressionTestImage(renWin);
+  if (retVal == vtkRegressionTester::DO_INTERACTOR)
+  {
+    iren->Start();
+  }
+
+  return !retVal;
+}

Rendering/Core/Testing/Cxx/TestOpacityMSAA.cxx

@@ -0,0 +1 @@
+b5dce5a56db0d685c638e3383536bcbb1cbf0b71040989c7fad040f221f4527f761d7cd22c7e4dd63aaf368cc236e366d37c4832b07f59f50b6928d223f7da9e

Rendering/Core/Testing/Data/Baseline/TestOpacityMSAA.png.sha512

@@ -917,6 +917,23 @@ class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkRenderer : public vtkViewport
   vtkSetVector3Macro(EnvironmentRight, double);
   ///@}
 
+  ///@{
+  /**
+   * If UseOIT is on and there are translucent props in the scene, the renderer will use the
+   * OrderIndependentTranslucentPass to render. If UseOIT is disabled, traditional depth sorting is
+   * used for translucency.
+   * By default, UseOIT is on.
+   *
+   * \note OIT is a newer(better) approach for translucent rendering but doesn't support hardware
+   * multi-sampling. Use FXAA in that case.
+   *
+   * \sa SetUseFXAA()
+   */
+  vtkSetMacro(UseOIT, bool);
+  vtkGetMacro(UseOIT, bool);
+  vtkBooleanMacro(UseOIT, bool);
+  ///@}
+
 protected:
   vtkRenderer();
   ~vtkRenderer() override;
@@ -1139,6 +1156,19 @@ class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkRenderer : public vtkViewport
   unsigned int SSAOKernelSize = 32;
   bool SSAOBlur = false;
 
+  /**
+   * If UseOIT is on and there are translucent props in the scene, the renderer will use the
+   * OrderIndependentTranslucentPass to render. If UseOIT is disabled, traditional depth sorting is
+   * used for translucency.
+   * By default, UseOIT is on.
+   *
+   * \note OIT is a newer(better) approach for translucent rendering but doesn't support hardware
+   * multi-sampling. Use FXAA in that case.
+   *
+   * \sa SetUseFXAA()
+   */
+  bool UseOIT = true;
+
   /**
    * Tells if the last call to DeviceRenderTranslucentPolygonalGeometry()
    * actually used depth peeling.

Rendering/Core/vtkRenderer.h

@@ -629,25 +629,28 @@ void vtkOpenGLRenderer::DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferO
 
   if (!this->UseDepthPeeling)
   {
-    // old code
-    // this->UpdateTranslucentPolygonalGeometry();
-
-    // new approach
-    if (!this->TranslucentPass)
+    if (!this->UseOIT)
     {
-      vtkOrderIndependentTranslucentPass* oit = vtkOrderIndependentTranslucentPass::New();
-      this->TranslucentPass = oit;
+      this->UpdateTranslucentPolygonalGeometry();
     }
-    vtkTranslucentPass* tp = vtkTranslucentPass::New();
-    this->TranslucentPass->SetTranslucentPass(tp);
-    tp->Delete();
+    else
+    {
+      if (!this->TranslucentPass)
+      {
+        vtkOrderIndependentTranslucentPass* oit = vtkOrderIndependentTranslucentPass::New();
+        this->TranslucentPass = oit;
+      }
+      vtkTranslucentPass* tp = vtkTranslucentPass::New();
+      this->TranslucentPass->SetTranslucentPass(tp);
+      tp->Delete();
 
-    vtkRenderState s(this);
-    s.SetPropArrayAndCount(this->PropArray, this->PropArrayCount);
-    s.SetFrameBuffer(fbo);
-    this->LastRenderingUsedDepthPeeling = 0;
-    this->TranslucentPass->Render(&s);
-    this->NumberOfPropsRendered += this->TranslucentPass->GetNumberOfRenderedProps();
+      vtkRenderState s(this);
+      s.SetPropArrayAndCount(this->PropArray, this->PropArrayCount);
+      s.SetFrameBuffer(fbo);
+      this->LastRenderingUsedDepthPeeling = 0;
+      this->TranslucentPass->Render(&s);
+      this->NumberOfPropsRendered += this->TranslucentPass->GetNumberOfRenderedProps();
+    }
   }
   else // depth peeling.
   {