add ability to share data between render windows

This topic adds a capability to share some data between
render windows. Basically it is implemented shared context
data in OpenGL such as with wglShareLists or the similar
functionality on glX or Cocoa. Right now only the VBO
cache makes use of the shared space but in the future shader
programs, textures, etc could also be shared.

Author: martinken

Rendering/Core/vtkRenderWindow.cxx

@@ -81,12 +81,14 @@ vtkRenderWindow::vtkRenderWindow()
   this->OffScreenRendering = 1;
 #endif
   this->DeviceIndex = 0;
+  this->SharedRenderWindow = nullptr;
 }
 
 //----------------------------------------------------------------------------
 vtkRenderWindow::~vtkRenderWindow()
 {
   this->SetInteractor(nullptr);
+  this->SetSharedRenderWindow(nullptr);
 
   delete [] this->AccumulationBuffer;
   this->AccumulationBuffer = nullptr;
@@ -121,6 +123,26 @@ vtkRenderWindowInteractor *vtkRenderWindow::MakeRenderWindowInteractor()
   return this->Interactor;
 }
 
+void vtkRenderWindow::SetSharedRenderWindow(vtkRenderWindow *val)
+{
+  if (this->SharedRenderWindow == val)
+  {
+    return;
+  }
+
+  if (this->SharedRenderWindow)
+  {
+    // this->ReleaseGraphicsResources();
+    this->SharedRenderWindow->UnRegister(this);
+  }
+  this->SharedRenderWindow = val;
+  if (val)
+  {
+    val->Register(this);
+  }
+  return;
+}
+
 //----------------------------------------------------------------------------
 // Set the interactor that will work with this renderer.
 void vtkRenderWindow::SetInteractor(vtkRenderWindowInteractor *rwi)

Rendering/Core/vtkRenderWindow.h

@@ -566,6 +566,19 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindow : public vtkWindow
    */
   virtual bool InitializeFromCurrentContext() { return false; };
 
+  //@{
+  /**
+   * Set/Get an already existing window that this window should
+   * share data with if possible. This must be set
+   * after the shared render window has been created and initialized
+   * but before this window has been initialized. Not all platforms
+   * support data sharing.
+   */
+  virtual void SetSharedRenderWindow(vtkRenderWindow *);
+  vtkGetObjectMacro(SharedRenderWindow, vtkRenderWindow);
+  virtual bool GetPlatformSupportsRenderWindowSharing() { return false; };
+  //@}
+
   /**
    * Attempt to make this window the current graphics context for the calling
    * thread.
@@ -723,6 +736,8 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindow : public vtkWindow
    */
   double AbortCheckTime;
 
+  vtkRenderWindow *SharedRenderWindow;
+
 private:
   vtkRenderWindow(const vtkRenderWindow&) = delete;
   void operator=(const vtkRenderWindow&) = delete;

Rendering/OpenGL2/Testing/Cxx/CMakeLists.txt

@@ -34,6 +34,7 @@ vtk_add_test_cxx(vtkRenderingOpenGL2CxxTests tests
   TestSetZBuffer.cxx
   TestShadowMapBakerPass.cxx
   TestShadowMapPass.cxx
+  TestSharedRenderWindow.cxx
   TestSimpleMotionBlur.cxx
   TestSobelGradientMagnitudePass.cxx
   TestSphereMap.cxx

Rendering/OpenGL2/Testing/Cxx/TestSharedRenderWindow.cxx

@@ -0,0 +1,93 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+
+#include "vtkCamera.h"
+#include "vtkRenderer.h"
+#include "vtkOpenGLRenderWindow.h"
+#include "vtkActor.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkNew.h"
+#include "vtkProperty.h"
+#include "vtkSphereSource.h"
+#include "vtkRegressionTestImage.h"
+#include "vtkTestUtilities.h"
+#include "vtkLight.h"
+
+#include "vtkRenderWindowInteractor.h"
+
+#include "vtkOpenGLRenderWindow.h"
+
+//----------------------------------------------------------------------------
+int TestSharedRenderWindow(int argc, char *argv[])
+{
+  vtkNew<vtkRenderer> renderer;
+  renderer->SetBackground(0.0, 0.0, 0.0);
+  vtkNew<vtkRenderWindow> renderWindow;
+  renderWindow->SetSize(300, 300);
+  renderWindow->AddRenderer(renderer);
+  vtkNew<vtkRenderWindowInteractor>  iren;
+  iren->SetRenderWindow(renderWindow);
+
+  vtkNew<vtkSphereSource> sphere;
+  sphere->SetThetaResolution(16);
+  sphere->SetPhiResolution(16);
+  sphere->SetEndTheta(270.0);
+
+  vtkNew<vtkPolyDataMapper> mapper;
+  mapper->SetInputConnection(sphere->GetOutputPort());
+  vtkNew<vtkActor> actor;
+  renderer->AddActor(actor);
+  actor->SetMapper(mapper);
+  actor->GetProperty()->SetDiffuseColor(0.4, 1.0, 1.0);
+
+  renderWindow->SetMultiSamples(0);
+  renderer->ResetCamera();
+  renderer->GetActiveCamera()->Elevation(-45);
+  renderer->GetActiveCamera()->OrthogonalizeViewUp();
+  renderer->GetActiveCamera()->Zoom(1.5);
+  renderer->ResetCameraClippingRange();
+  renderWindow->Render();
+
+  vtkNew<vtkRenderer> renderer2;
+  renderer2->SetBackground(0.0, 0.0, 1.0);
+  vtkNew<vtkRenderWindow> renderWindow2;
+  renderWindow2->SetSize(300, 300);
+  renderWindow2->AddRenderer(renderer2);
+  vtkNew<vtkRenderWindowInteractor>  iren2;
+  iren2->SetRenderWindow(renderWindow2);
+  renderWindow2->SetSharedRenderWindow(renderWindow);
+
+  vtkNew<vtkPolyDataMapper> mapper2;
+  mapper2->SetInputConnection(sphere->GetOutputPort());
+  vtkNew<vtkActor> actor2;
+  renderer2->AddActor(actor2);
+  actor2->SetMapper(mapper2);
+  actor2->GetProperty()->SetDiffuseColor(1.0, 1.0, 0.4);
+
+  renderWindow2->SetMultiSamples(0);
+  renderer2->ResetCamera();
+  renderer2->GetActiveCamera()->Elevation(-45);
+  renderer2->GetActiveCamera()->OrthogonalizeViewUp();
+  renderer2->GetActiveCamera()->Zoom(1.5);
+  renderer2->ResetCameraClippingRange();
+  renderWindow2->Render();
+
+  int retVal = vtkRegressionTestImage( renderWindow2 );
+  if ( retVal == vtkRegressionTester::DO_INTERACTOR)
+    {
+    iren->Start();
+    }
+
+  return !retVal;
+}

Rendering/OpenGL2/Testing/Data/Baseline/TestSharedRenderWindow.png.md5

@@ -0,0 +1 @@
+9084d37af6fb7ccbc23e0ad58e2935fb

Rendering/OpenGL2/vtkCocoaRenderWindow.h

@@ -178,6 +178,11 @@ class VTKRENDERINGOPENGL2_EXPORT vtkCocoaRenderWindow : public vtkOpenGLRenderWi
    */
   bool InitializeFromCurrentContext() override;
 
+  /**
+   * Does this platform support render window data sharing.
+   */
+  bool GetPlatformSupportsRenderWindowSharing() override { return true; };
+
   /**
    * Prescribe that the window be created in a stereo-capable mode. This
    * method must be called before the window is realized. This method

Rendering/OpenGL2/vtkCocoaRenderWindow.mm

@@ -21,6 +21,7 @@
 
 #import "vtkOpenGL.h"
 #import "vtkCocoaRenderWindow.h"
+#import "vtkOpenGLVertexBufferObjectCache.h"
 #import "vtkRenderWindowInteractor.h"
 #import "vtkCommand.h"
 #import "vtkIdList.h"
@@ -1019,11 +1020,26 @@ - (void)viewFrameDidChange:(NSNotification *)aNotification
     }
   }
 
+  // do we have a shared render window?
+  NSOpenGLContext *sharedContext = nil;
+  if (this->SharedRenderWindow)
+  {
+    vtkCocoaRenderWindow *renWin =
+      vtkCocoaRenderWindow::SafeDownCast(this->SharedRenderWindow);
+    if (renWin && renWin->GetContextId())
+    {
+      sharedContext = (NSOpenGLContext*)renWin->GetContextId();
+      this->VBOCache->Delete();
+      this->VBOCache = renWin->VBOCache;
+      this->VBOCache->Register(this);
+    }
+  }
+
   NSOpenGLContext *context = nil;
   if (pixelFormat)
   {
     context = [[NSOpenGLContext alloc] initWithFormat:pixelFormat
-                                         shareContext:nil];
+                                         shareContext:sharedContext];
 
     // This syncs the OpenGL context to the VBL to prevent tearing
     GLint one = 1;

Rendering/OpenGL2/vtkWin32OpenGLRenderWindow.cxx

@@ -22,6 +22,7 @@ PURPOSE.  See the above copyright notice for more information.
 #include "vtkOpenGLRenderWindow.h"
 #include "vtkOpenGLError.h"
 #include "vtkOpenGLShaderCache.h"
+#include "vtkOpenGLVertexBufferObjectCache.h"
 #include "vtkRendererCollection.h"
 #include "vtkStringOutputWindow.h"
 #include "vtkWin32RenderWindowInteractor.h"
@@ -1081,6 +1082,22 @@ void vtkWin32OpenGLRenderWindow::Initialize (void)
       this->CreateOffScreenWindow(width,height);
     }
   }
+
+  if (this->SharedRenderWindow)
+  {
+    vtkWin32OpenGLRenderWindow *renWin =
+      vtkWin32OpenGLRenderWindow::SafeDownCast(this->SharedRenderWindow);
+    if (renWin && renWin->Initialized)
+    {
+      bool result = wglShareLists( renWin->ContextId, this->ContextId) == TRUE;
+      if (result)
+      {
+        this->VBOCache->Delete();
+        this->VBOCache = renWin->VBOCache;
+        this->VBOCache->Register(this);
+      }
+    }
+  }
 }
 
 void vtkWin32OpenGLRenderWindow::Finalize (void)

Rendering/OpenGL2/vtkWin32OpenGLRenderWindow.h

@@ -162,6 +162,11 @@ class VTKRENDERINGOPENGL2_EXPORT vtkWin32OpenGLRenderWindow : public vtkOpenGLRe
    */
   bool InitializeFromCurrentContext() override;
 
+  /**
+   * Does this platform support render window data sharing.
+   */
+  bool GetPlatformSupportsRenderWindowSharing() override { return true; };
+
   //@{
   /**
    * Set the window's parent id to a pre-existing window.

Rendering/OpenGL2/vtkXOpenGLRenderWindow.cxx

@@ -51,6 +51,7 @@ typedef ptrdiff_t GLsizeiptr;
 #include "vtkNew.h"
 #include "vtkObjectFactory.h"
 #include "vtkOpenGLShaderCache.h"
+#include "vtkOpenGLVertexBufferObjectCache.h"
 #include "vtkRendererCollection.h"
 #include "vtkRenderTimerLog.h"
 #include "vtkRenderWindowInteractor.h"
@@ -570,25 +571,59 @@ void vtkXOpenGLRenderWindow::CreateAWindow()
 
     if (glXCreateContextAttribsARB)
     {
+      // do we have a shared render window?
+      GLXContext sharedContext = nullptr;
+      vtkXOpenGLRenderWindow *renWin = nullptr;
+      if (this->SharedRenderWindow)
+      {
+        renWin =
+          vtkXOpenGLRenderWindow::SafeDownCast(this->SharedRenderWindow);
+        if (renWin && renWin->Internal->ContextId)
+        {
+          sharedContext = renWin->Internal->ContextId;
+        }
+      }
+
       XErrorHandler previousHandler = XSetErrorHandler(vtkXOGLContextCreationErrorHandler);
       this->Internal->ContextId = nullptr;
+
       // we believe that these later versions are all compatible with
       // OpenGL 3.2 so get a more recent context if we can.
       int attemptedVersions[] = {4,5, 4,4, 4,3, 4,2, 4,1, 4,0, 3,3, 3,2};
-      for (int i = 0; i < 8 && !this->Internal->ContextId; i++)
+
+      // try shared context first, the fallback to not shared
+      bool done = false;
+      while (!done)
       {
-        context_attribs[1] = attemptedVersions[i*2];
-        context_attribs[3] = attemptedVersions[i*2+1];
-        this->Internal->ContextId =
-          glXCreateContextAttribsARB( this->DisplayId,
-            this->Internal->FBConfig, nullptr,
-            GL_TRUE, context_attribs );
-        // Sync to ensure any errors generated are processed.
-        XSync( this->DisplayId, False );
+        for (int i = 0; i < 8 && !this->Internal->ContextId; i++)
+        {
+          context_attribs[1] = attemptedVersions[i*2];
+          context_attribs[3] = attemptedVersions[i*2+1];
+          this->Internal->ContextId =
+            glXCreateContextAttribsARB( this->DisplayId,
+              this->Internal->FBConfig, sharedContext,
+              GL_TRUE, context_attribs );
+          // Sync to ensure any errors generated are processed.
+          XSync( this->DisplayId, False );
+        }
+        if ( !this->Internal->ContextId  && sharedContext)
+        {
+          sharedContext = nullptr;
+        }
+        else
+        {
+          done = true;
+        }
       }
       XSetErrorHandler(previousHandler);
       if ( this->Internal->ContextId )
       {
+        if (sharedContext)
+        {
+          this->VBOCache->Delete();
+          this->VBOCache = renWin->VBOCache;
+          this->VBOCache->Register(this);
+        }
         this->SetContextSupportsOpenGL32(true);
       }
     }
@@ -952,7 +987,6 @@ void vtkXOpenGLRenderWindow::Start(void)
   this->MakeCurrent();
 }
 
-
 // Specify the size of the rendering window.
 void vtkXOpenGLRenderWindow::SetSize(int width,int height)
 {