Merge topic 'parallel-rendering-fixes'

ea2b217f vtkSynchronizedRenderers: capture just 1 image.
a6b03489 vtkSynchronizedRenderers: add ability to fix colored background
4ee8db5b Revert "fix blend function to avoid blending background"

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Ken Martin <ken.martin@kitware.com>
Merge-request: !5652

Rendering/Parallel/vtkClientServerSynchronizedRenderers.cxx

@@ -36,8 +36,7 @@ void vtkClientServerSynchronizedRenderers::MasterEndRender()
   // receive image from slave.
   assert(this->ParallelController->IsA("vtkSocketController"));
 
-  vtkRawImage& rawImage = (this->ImageReductionFactor == 1)?
-    this->FullImage : this->ReducedImage;
+  vtkRawImage& rawImage = this->Image;
 
   int header[4];
   this->ParallelController->Receive(header, 4, 1, 0x023430);

Rendering/Parallel/vtkCompositedSynchronizedRenderers.cxx

@@ -40,9 +40,7 @@ vtkCompositedSynchronizedRenderers::~vtkCompositedSynchronizedRenderers()
 //----------------------------------------------------------------------------
 void vtkCompositedSynchronizedRenderers::MasterEndRender()
 {
-  vtkRawImage& rawImage = (this->ImageReductionFactor == 1)?
-    this->FullImage : this->ReducedImage;
-  rawImage = this->CaptureRenderedImage();
+  vtkRawImage& rawImage = this->CaptureRenderedImage();
   vtkFloatArray* depth_buffer = vtkFloatArray::New();
   this->CaptureRenderedDepthBuffer(depth_buffer);
 

Rendering/Parallel/vtkSynchronizedRenderers.cxx

@@ -80,6 +80,11 @@ vtkCxxSetObjectMacro(vtkSynchronizedRenderers, CaptureDelegate,
   vtkSynchronizedRenderers);
 //----------------------------------------------------------------------------
 vtkSynchronizedRenderers::vtkSynchronizedRenderers()
+  : LastBackground{ 0, 0, 0 }
+  , LastBackgroundAlpha(0)
+  , LastTexturedBackground(false)
+  , LastGradientBackground(false)
+  , FixBackground(false)
 {
   this->Observer = vtkSynchronizedRenderers::vtkObserver::New();
   this->Observer->Target = this;
@@ -162,14 +167,26 @@ void vtkSynchronizedRenderers::HandleStartRender()
     return;
   }
 
-  this->ReducedImage.MarkInValid();
-  this->FullImage.MarkInValid();
+  this->Image.MarkInValid();
 
   // disable FXAA when parallel rendering. We'll do the FXAA pass after the
   // compositing stage. This avoid any seam artifacts from creeping in.
   this->UseFXAA = this->Renderer->GetUseFXAA();
   this->Renderer->SetUseFXAA(false);
 
+  if (this->FixBackground)
+  {
+    this->Renderer->GetBackground(this->LastBackground);
+    this->LastBackgroundAlpha = this->Renderer->GetBackgroundAlpha();
+    this->LastTexturedBackground = this->Renderer->GetTexturedBackground();
+    this->LastGradientBackground = this->Renderer->GetGradientBackground();
+
+    this->Renderer->SetBackground(0, 0, 0);
+    this->Renderer->SetBackgroundAlpha(0);
+    this->Renderer->SetTexturedBackground(false);
+    this->Renderer->SetGradientBackground(false);
+  }
+
   if (this->ParallelController->GetLocalProcessId() == this->RootProcessId)
   {
     this->MasterStartRender();
@@ -246,12 +263,21 @@ void vtkSynchronizedRenderers::HandleEndRender()
 
   if (this->WriteBackImages)
   {
-    if (this->ImageReductionFactor > 1 && this->ParallelRendering)
+    if (this->GetImageReductionFactor() > 1 || this->FixBackground)
     {
       this->CaptureRenderedImage();
     }
   }
 
+  if (this->FixBackground)
+  {
+    // restore background values.
+    this->Renderer->SetBackground(this->LastBackground);
+    this->Renderer->SetBackgroundAlpha(this->LastBackgroundAlpha);
+    this->Renderer->SetTexturedBackground(this->LastTexturedBackground);
+    this->Renderer->SetGradientBackground(this->LastGradientBackground);
+  }
+
   // restore viewport before `PushImageToScreen`, but after
   // `CaptureRenderedImage`.
   this->Renderer->SetViewport(this->LastViewport);
@@ -280,10 +306,7 @@ void vtkSynchronizedRenderers::SlaveEndRender()
 vtkSynchronizedRenderers::vtkRawImage&
 vtkSynchronizedRenderers::CaptureRenderedImage()
 {
-  vtkRawImage& rawImage =
-    (this->ImageReductionFactor == 1)?
-    this->FullImage : this->ReducedImage;
-
+  vtkRawImage& rawImage = this->Image;
   if (!rawImage.IsValid())
   {
     if (this->CaptureDelegate)
@@ -302,10 +325,7 @@ vtkSynchronizedRenderers::CaptureRenderedImage()
 //----------------------------------------------------------------------------
 void vtkSynchronizedRenderers::PushImageToScreen()
 {
-  vtkRawImage& rawImage =
-    (this->ImageReductionFactor == 1)?
-    this->FullImage : this->ReducedImage;
-
+  vtkRawImage& rawImage = this->Image;
   if (!rawImage.IsValid())
   {
     return;
@@ -408,6 +428,7 @@ void vtkSynchronizedRenderers::PrintSelf(ostream& os, vtkIndent indent)
   os << indent << "ImageReductionFactor: "
     << this->ImageReductionFactor << endl;
   os << indent << "WriteBackImages: " << this->WriteBackImages << endl;
+  os << indent << "FixBackground: " << this->FixBackground << endl;
   os << indent << "RootProcessId: " << this->RootProcessId << endl;
   os << indent << "ParallelRendering: " << this->ParallelRendering << endl;
   os << indent << "AutomaticEventHandling: "
@@ -732,8 +753,9 @@ bool vtkSynchronizedRenderers::vtkRawImage::PushToFrameBuffer(vtkRenderer *ren)
   // framebuffers have their color premultiplied by alpha.
   vtkOpenGLState::ScopedglBlendFuncSeparate bfsaver(ostate);
   ostate->vtkglEnable(GL_BLEND);
-  ostate->vtkglBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
-    GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+  ostate->vtkglBlendFuncSeparate(GL_ONE,GL_ONE_MINUS_SRC_ALPHA,
+    GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
+
 
   int size[2], low_point[2];
   ren->GetTiledSizeAndOrigin(&size[0], &size[1], &low_point[0], &low_point[1]);

Rendering/Parallel/vtkSynchronizedRenderers.h

@@ -139,6 +139,23 @@ public:
   vtkBooleanMacro(AutomaticEventHandling, bool);
   //@}
 
+  //@{
+  /**
+   * When doing rendering between multiple processes, it is often easier to have
+   * all ranks do the rendering on a black background. This helps avoid issues
+   * where the background gets over blended as the images are composted
+   * together. If  set to true (default is false), before the rendering begins,
+   * vtkSynchronizedRenderers will change the renderer's background color and
+   * other flags to make it render on a black background and then restore then
+   * on end render. If WriteBackImages is true, then the background will indeed
+   * be restored before the write-back happens, thus ensuring the result
+   * displayed to the user is on correct background.
+   */
+  vtkSetMacro(FixBackground, bool);
+  vtkGetMacro(FixBackground, bool);
+  vtkBooleanMacro(FixBackground, bool);
+  //@}
+
   enum
   {
     SYNC_RENDERER_TAG = 15101,
@@ -251,23 +268,19 @@ protected:
 
   /**
    * Can be used in HandleEndRender(), MasterEndRender() or SlaveEndRender()
-   * calls to capture the rendered image. If this->ImageReductionFactor, then
-   * the image will be capture in this->ReducedImage, otherwise it will be
-   * captured in this->FullImage (this->ReducedImage will be pointing to the
-   * same image).
+   * calls to capture the rendered image. The captured image is stored in
+   * `this->Image`.
    */
   virtual vtkRawImage& CaptureRenderedImage();
 
   /**
    * Can be used in HandleEndRender(), MasterEndRender() or SlaveEndRender()
-   * calls to paste back the image from either this->ReducedImage or
-   * this->FullImage info the viewport.
+   * calls to paste back the image from this->Image to the viewport.
    */
   virtual void PushImageToScreen();
 
   vtkSynchronizedRenderers* CaptureDelegate;
-  vtkRawImage ReducedImage;
-  vtkRawImage FullImage;
+  vtkRawImage Image;
 
   bool ParallelRendering;
   int ImageReductionFactor;
@@ -287,6 +300,12 @@ private:
   vtkOpenGLFXAAFilter* FXAAFilter;
 
   double LastViewport[4];
+
+  double LastBackground[3];
+  double LastBackgroundAlpha;
+  bool LastTexturedBackground;
+  bool LastGradientBackground;
+  bool FixBackground;
 };
 
 #endif