/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkRenderWindow.h

  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.

=========================================================================*/
/**
 * @class   vtkRenderWindow
 * @brief   create a window for renderers to draw into
 *
 * vtkRenderWindow is an abstract object to specify the behavior of a
 * rendering window. A rendering window is a window in a graphical user
 * interface where renderers draw their images. Methods are provided to
 * synchronize the rendering process, set window size, and control double
 * buffering.  The window also allows rendering in stereo.  The interlaced
 * render stereo type is for output to a VRex stereo projector.  All of the
 * odd horizontal lines are from the left eye, and the even lines are from
 * the right eye.  The user has to make the render window aligned with the
 * VRex projector, or the eye will be swapped.
 *
 * @warning
 * In VTK versions 4 and later, the vtkWindowToImageFilter class is
 * part of the canonical way to output an image of a window to a file
 * (replacing the obsolete SaveImageAsPPM method for vtkRenderWindows
 * that existed in 3.2 and earlier).  Connect one of these filters to
 * the output of the window, and filter's output to a writer such as
 * vtkPNGWriter.
 *
 * @sa
 * vtkRenderer vtkRenderWindowInteractor vtkWindowToImageFilter
 */

#ifndef vtkRenderWindow_h
#define vtkRenderWindow_h

#include "vtkNew.h"                 // For vtkNew
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // For vtkSmartPointer
#include "vtkWindow.h"

class vtkFloatArray;
class vtkProp;
class vtkCollection;
class vtkRenderTimerLog;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkRendererCollection;
class vtkStereoCompositor;
class vtkUnsignedCharArray;

// lets define the different types of stereo
#define VTK_STEREO_CRYSTAL_EYES 1
#define VTK_STEREO_RED_BLUE 2
#define VTK_STEREO_INTERLACED 3
#define VTK_STEREO_LEFT 4
#define VTK_STEREO_RIGHT 5
#define VTK_STEREO_DRESDEN 6
#define VTK_STEREO_ANAGLYPH 7
#define VTK_STEREO_CHECKERBOARD 8
#define VTK_STEREO_SPLITVIEWPORT_HORIZONTAL 9
#define VTK_STEREO_FAKE 10
#define VTK_STEREO_EMULATE 11

#define VTK_CURSOR_DEFAULT 0
#define VTK_CURSOR_ARROW 1
#define VTK_CURSOR_SIZENE 2
#define VTK_CURSOR_SIZENW 3
#define VTK_CURSOR_SIZESW 4
#define VTK_CURSOR_SIZESE 5
#define VTK_CURSOR_SIZENS 6
#define VTK_CURSOR_SIZEWE 7
#define VTK_CURSOR_SIZEALL 8
#define VTK_CURSOR_HAND 9
#define VTK_CURSOR_CROSSHAIR 10

class VTKRENDERINGCORE_EXPORT vtkRenderWindow : public vtkWindow
{
public:
  vtkTypeMacro(vtkRenderWindow, vtkWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  /**
   * Construct an instance of  vtkRenderWindow with its screen size
   * set to 300x300, borders turned on, positioned at (0,0), double
   * buffering turned on.
   */
  static vtkRenderWindow* New();

  /**
   * Add a renderer to the list of renderers.
   */
  virtual void AddRenderer(vtkRenderer*);

  /**
   * Remove a renderer from the list of renderers.
   */
  void RemoveRenderer(vtkRenderer*);

  /**
   * Query if a renderer is in the list of renderers.
   */
  int HasRenderer(vtkRenderer*);

  /**
   * What rendering library has the user requested
   */
  static const char* GetRenderLibrary();

  /**
   * What rendering backend has the user requested
   */
  virtual const char* GetRenderingBackend();

  /**
   * Get the render timer log for this window.
   */
  vtkGetNewMacro(RenderTimer, vtkRenderTimerLog);

  /**
   * Return the collection of renderers in the render window.
   */
  vtkRendererCollection* GetRenderers() { return this->Renderers; }

  /**
   * The GL2PS exporter must handle certain props in a special way (e.g. text).
   * This method performs a render and captures all "GL2PS-special" props in
   * the specified collection. The collection will contain a
   * vtkPropCollection for each vtkRenderer in this->GetRenderers(), each
   * containing the special props rendered by the corresponding renderer.
   */
  void CaptureGL2PSSpecialProps(vtkCollection* specialProps);

  //@{
  /**
   * Returns true if the render process is capturing text actors.
   */
  vtkGetMacro(CapturingGL2PSSpecialProps, int);
  //@}

  /**
   * Ask each renderer owned by this RenderWindow to render its image and
   * synchronize this process.
   */
  void Render() override;

  /**
   * Start the rendering process for a frame
   */
  virtual void Start() = 0;

  /**
   * Finalize the rendering process.
   */
  virtual void Finalize() = 0;

  /**
   * A termination method performed at the end of the rendering process
   * to do things like swapping buffers (if necessary) or similar actions.
   */
  virtual void Frame() = 0;

  /**
   * Block the thread until the actual rendering is finished().
   * Useful for measurement only.
   */
  virtual void WaitForCompletion() = 0;

  /**
   * Performed at the end of the rendering process to generate image.
   * This is typically done right before swapping buffers.
   */
  virtual void CopyResultFrame();

  /**
   * Create an interactor to control renderers in this window. We need
   * to know what type of interactor to create, because we might be in
   * X Windows or MS Windows.
   */
  virtual vtkRenderWindowInteractor* MakeRenderWindowInteractor();

  //@{
  /**
   * Hide or Show the mouse cursor, it is nice to be able to hide the
   * default cursor if you want VTK to display a 3D cursor instead.
   * Set cursor position in window (note that (0,0) is the lower left
   * corner).
   */
  virtual void HideCursor() = 0;
  virtual void ShowCursor() = 0;
  virtual void SetCursorPosition(int, int) {}
  //@}

  //@{
  /**
   * Change the shape of the cursor.
   */
  vtkSetMacro(CurrentCursor, int);
  vtkGetMacro(CurrentCursor, int);
  //@}

  //@{
  /**
   * Turn on/off rendering full screen window size.
   */
  virtual void SetFullScreen(vtkTypeBool) = 0;
  vtkGetMacro(FullScreen, vtkTypeBool);
  vtkBooleanMacro(FullScreen, vtkTypeBool);
  //@}

  //@{
  /**
   * Turn on/off window manager borders. Typically, you shouldn't turn the
   * borders off, because that bypasses the window manager and can cause
   * undesirable behavior.
   */
  vtkSetMacro(Borders, vtkTypeBool);
  vtkGetMacro(Borders, vtkTypeBool);
  vtkBooleanMacro(Borders, vtkTypeBool);
  //@}

  //@{
  /**
   * Prescribe that the window be created in a stereo-capable mode. This
   * method must be called before the window is realized. Default is off.
   */
  vtkGetMacro(StereoCapableWindow, vtkTypeBool);
  vtkBooleanMacro(StereoCapableWindow, vtkTypeBool);
  virtual void SetStereoCapableWindow(vtkTypeBool capable);
  //@}

  //@{
  /**
   * Turn on/off stereo rendering.
   */
  vtkGetMacro(StereoRender, vtkTypeBool);
  void SetStereoRender(vtkTypeBool stereo);
  vtkBooleanMacro(StereoRender, vtkTypeBool);
  //@}

  //@{
  /**
   * Turn on/off the use of alpha bitplanes.
   */
  vtkSetMacro(AlphaBitPlanes, vtkTypeBool);
  vtkGetMacro(AlphaBitPlanes, vtkTypeBool);
  vtkBooleanMacro(AlphaBitPlanes, vtkTypeBool);
  //@}

  //@{
  /**
   * Turn on/off point smoothing. Default is off.
   * This must be applied before the first Render.
   */
  vtkSetMacro(PointSmoothing, vtkTypeBool);
  vtkGetMacro(PointSmoothing, vtkTypeBool);
  vtkBooleanMacro(PointSmoothing, vtkTypeBool);
  //@}

  //@{
  /**
   * Turn on/off line smoothing. Default is off.
   * This must be applied before the first Render.
   */
  vtkSetMacro(LineSmoothing, vtkTypeBool);
  vtkGetMacro(LineSmoothing, vtkTypeBool);
  vtkBooleanMacro(LineSmoothing, vtkTypeBool);
  //@}

  //@{
  /**
   * Turn on/off polygon smoothing. Default is off.
   * This must be applied before the first Render.
   */
  vtkSetMacro(PolygonSmoothing, vtkTypeBool);
  vtkGetMacro(PolygonSmoothing, vtkTypeBool);
  vtkBooleanMacro(PolygonSmoothing, vtkTypeBool);
  //@}

  //@{
  /**
   * Set/Get what type of stereo rendering to use.  CrystalEyes
   * mode uses frame-sequential capabilities available in OpenGL
   * to drive LCD shutter glasses and stereo projectors.  RedBlue
   * mode is a simple type of stereo for use with red-blue glasses.
   * Anaglyph mode is a superset of RedBlue mode, but the color
   * output channels can be configured using the AnaglyphColorMask
   * and the color of the original image can be (somewhat) maintained
   * using AnaglyphColorSaturation;  the default colors for Anaglyph
   * mode is red-cyan.  Interlaced stereo mode produces a composite
   * image where horizontal lines alternate between left and right
   * views.  StereoLeft and StereoRight modes choose one or the other
   * stereo view.  Dresden mode is yet another stereoscopic
   * interleaving. Fake simply causes the window to render twice without
   * actually swapping the camera from left eye to right eye. This is useful in
   * certain applications that want to emulate the rendering passes without
   * actually rendering in stereo mode. Emulate is similar to Fake, except that
   * it does render left and right eye. There is no compositing of the resulting
   * images from the two eyes at the end of each render in this mode, hence the
   * result onscreen will be the right eye.
   */
  vtkGetMacro(StereoType, int);
  void SetStereoType(int);
  void SetStereoTypeToCrystalEyes() { this->SetStereoType(VTK_STEREO_CRYSTAL_EYES); }
  void SetStereoTypeToRedBlue() { this->SetStereoType(VTK_STEREO_RED_BLUE); }
  void SetStereoTypeToInterlaced() { this->SetStereoType(VTK_STEREO_INTERLACED); }
  void SetStereoTypeToLeft() { this->SetStereoType(VTK_STEREO_LEFT); }
  void SetStereoTypeToRight() { this->SetStereoType(VTK_STEREO_RIGHT); }
  void SetStereoTypeToDresden() { this->SetStereoType(VTK_STEREO_DRESDEN); }
  void SetStereoTypeToAnaglyph() { this->SetStereoType(VTK_STEREO_ANAGLYPH); }
  void SetStereoTypeToCheckerboard() { this->SetStereoType(VTK_STEREO_CHECKERBOARD); }
  void SetStereoTypeToSplitViewportHorizontal()
  {
    this->SetStereoType(VTK_STEREO_SPLITVIEWPORT_HORIZONTAL);
  }
  void SetStereoTypeToFake() { this->SetStereoType(VTK_STEREO_FAKE); }
  void SetStereoTypeToEmulate() { this->SetStereoType(VTK_STEREO_EMULATE); }
  //@}

  //@{
  /**
   * Returns the stereo type as a string.
   */
  const char* GetStereoTypeAsString();
  static const char* GetStereoTypeAsString(int type);
  //@}

  /**
   * Update the system, if needed, due to stereo rendering. For some stereo
   * methods, subclasses might need to switch some hardware settings here.
   */
  virtual void StereoUpdate();

  /**
   * Intermediate method performs operations required between the rendering
   * of the left and right eye.
   */
  virtual void StereoMidpoint();

  /**
   * Handles work required once both views have been rendered when using
   * stereo rendering.
   */
  virtual void StereoRenderComplete();

  //@{
  /**
   * Set/get the anaglyph color saturation factor.  This number ranges from
   * 0.0 to 1.0:  0.0 means that no color from the original object is
   * maintained, 1.0 means all of the color is maintained.  The default
   * value is 0.65.  Too much saturation can produce uncomfortable 3D
   * viewing because anaglyphs also use color to encode 3D.
   */
  vtkSetClampMacro(AnaglyphColorSaturation, float, 0.0f, 1.0f);
  vtkGetMacro(AnaglyphColorSaturation, float);
  //@}

  //@{
  /**
   * Set/get the anaglyph color mask values.  These two numbers are bits
   * mask that control which color channels of the original stereo
   * images are used to produce the final anaglyph image.  The first
   * value is the color mask for the left view, the second the mask
   * for the right view.  If a bit in the mask is on for a particular
   * color for a view, that color is passed on to the final view; if
   * it is not set, that channel for that view is ignored.
   * The bits are arranged as r, g, and b, so r = 4, g = 2, and b = 1.
   * By default, the first value (the left view) is set to 4, and the
   * second value is set to 3.  That means that the red output channel
   * comes from the left view, and the green and blue values come from
   * the right view.
   */
  vtkSetVector2Macro(AnaglyphColorMask, int);
  vtkGetVectorMacro(AnaglyphColorMask, int, 2);
  //@}

  /**
   * Remap the rendering window. This probably only works on UNIX right now.
   * It is useful for changing properties that can't normally be changed
   * once the window is up.
   */
  virtual void WindowRemap() = 0;

  //@{
  /**
   * Turn on/off buffer swapping between images.
   */
  vtkSetMacro(SwapBuffers, vtkTypeBool);
  vtkGetMacro(SwapBuffers, vtkTypeBool);
  vtkBooleanMacro(SwapBuffers, vtkTypeBool);
  //@}

  //@{
  /**
   * Set/Get the pixel data of an image, transmitted as RGBRGBRGB. The
   * front argument indicates if the front buffer should be used or the back
   * buffer. It is the caller's responsibility to delete the resulting
   * array. It is very important to realize that the memory in this array
   * is organized from the bottom of the window to the top. The origin
   * of the screen is in the lower left corner. The y axis increases as
   * you go up the screen. So the storage of pixels is from left to right
   * and from bottom to top.
   * (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on
   * the diagonal.
   */
  virtual int SetPixelData(
    int x, int y, int x2, int y2, unsigned char* data, int front, int right = 0) = 0;
  virtual int SetPixelData(
    int x, int y, int x2, int y2, vtkUnsignedCharArray* data, int front, int right = 0) = 0;
  //@}

  //@{
  /**
   * Same as Get/SetPixelData except that the image also contains an alpha
   * component. The image is transmitted as RGBARGBARGBA... each of which is a
   * float value. The "blend" parameter controls whether the SetRGBAPixelData
   * method blends the data with the previous contents of the frame buffer
   * or completely replaces the frame buffer data.
   */
  virtual float* GetRGBAPixelData(int x, int y, int x2, int y2, int front, int right = 0) = 0;
  virtual int GetRGBAPixelData(
    int x, int y, int x2, int y2, int front, vtkFloatArray* data, int right = 0) = 0;
  virtual int SetRGBAPixelData(
    int x, int y, int x2, int y2, float*, int front, int blend = 0, int right = 0) = 0;
  virtual int SetRGBAPixelData(
    int, int, int, int, vtkFloatArray*, int, int blend = 0, int right = 0) = 0;
  virtual void ReleaseRGBAPixelData(float* data) = 0;
  virtual unsigned char* GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, int right = 0) = 0;
  virtual int GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, vtkUnsignedCharArray* data, int right = 0) = 0;
  virtual int SetRGBACharPixelData(
    int x, int y, int x2, int y2, unsigned char* data, int front, int blend = 0, int right = 0) = 0;
  virtual int SetRGBACharPixelData(int x, int y, int x2, int y2, vtkUnsignedCharArray* data,
    int front, int blend = 0, int right = 0) = 0;
  //@}

  //@{
  /**
   * Set/Get the zbuffer data from the frame buffer.
   * (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on
   * the diagonal.
   */
  virtual float* GetZbufferData(int x, int y, int x2, int y2) = 0;
  virtual int GetZbufferData(int x, int y, int x2, int y2, float* z) = 0;
  virtual int GetZbufferData(int x, int y, int x2, int y2, vtkFloatArray* z) = 0;
  virtual int SetZbufferData(int x, int y, int x2, int y2, float* z) = 0;
  virtual int SetZbufferData(int x, int y, int x2, int y2, vtkFloatArray* z) = 0;
  float GetZbufferDataAtPoint(int x, int y)
  {
    float value;
    this->GetZbufferData(x, y, x, y, &value);
    return value;
  }
  //@}

  //@{
  /**
   * This flag is set if the window hasn't rendered since it was created
   */
  vtkGetMacro(NeverRendered, int);
  //@}

  //@{
  /**
   * This is a flag that can be set to interrupt a rendering that is in
   * progress.
   */
  vtkGetMacro(AbortRender, int);
  vtkSetMacro(AbortRender, int);
  vtkGetMacro(InAbortCheck, int);
  vtkSetMacro(InAbortCheck, int);
  virtual int CheckAbortStatus();
  //@}

  //@{
  /**
   * @deprecated in VTK 8.3
   */
  VTK_LEGACY(vtkTypeBool GetIsPicking());
  VTK_LEGACY(void SetIsPicking(vtkTypeBool));
  VTK_LEGACY(void IsPickingOn());
  VTK_LEGACY(void IsPickingOff());
  //@}

  /**
   * Check to see if a mouse button has been pressed.  All other events
   * are ignored by this method.  Ideally, you want to abort the render
   * on any event which causes the DesiredUpdateRate to switch from
   * a high-quality rate to a more interactive rate.
   */
  virtual int GetEventPending() = 0;

  /**
   * Are we rendering at the moment
   */
  virtual int CheckInRenderStatus() { return this->InRender; }

  /**
   * Clear status (after an exception was thrown for example)
   */
  virtual void ClearInRenderStatus() { this->InRender = 0; }

  //@{
  /**
   * Set/Get the desired update rate. This is used with
   * the vtkLODActor class. When using level of detail actors you
   * need to specify what update rate you require. The LODActors then
   * will pick the correct resolution to meet your desired update rate
   * in frames per second. A value of zero indicates that they can use
   * all the time they want to.
   */
  virtual void SetDesiredUpdateRate(double);
  vtkGetMacro(DesiredUpdateRate, double);
  //@}

  //@{
  /**
   * Get the number of layers for renderers.  Each renderer should have
   * its layer set individually.  Some algorithms iterate through all layers,
   * so it is not wise to set the number of layers to be exorbitantly large
   * (say bigger than 100).
   */
  vtkGetMacro(NumberOfLayers, int);
  vtkSetClampMacro(NumberOfLayers, int, 1, VTK_INT_MAX);
  //@}

  //@{
  /**
   * Get the interactor associated with this render window
   */
  vtkGetObjectMacro(Interactor, vtkRenderWindowInteractor);
  //@}

  /**
   * Set the interactor to the render window
   */
  void SetInteractor(vtkRenderWindowInteractor*);

  /**
   * This Method detects loops of RenderWindow<->Interactor,
   * so objects are freed properly.
   */
  void UnRegister(vtkObjectBase* o) override;

  //@{
  /**
   * Dummy stubs for vtkWindow API.
   */
  void SetDisplayId(void*) override = 0;
  void SetWindowId(void*) override = 0;
  virtual void SetNextWindowId(void*) = 0;
  void SetParentId(void*) override = 0;
  void* GetGenericDisplayId() override = 0;
  void* GetGenericWindowId() override = 0;
  void* GetGenericParentId() override = 0;
  void* GetGenericContext() override = 0;
  void* GetGenericDrawable() override = 0;
  void SetWindowInfo(const char*) override = 0;
  virtual void SetNextWindowInfo(const char*) = 0;
  void SetParentInfo(const char*) override = 0;
  //@}

  /**
   * Initialize the render window from the information associated
   * with the currently activated OpenGL context.
   */
  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.
   */
  void MakeCurrent() override = 0;

  /**
   * Tells if this window is the current graphics context for the calling
   * thread.
   */
  virtual bool IsCurrent() = 0;

  /**
   * Test if the window has a valid drawable. This is
   * currently only an issue on Mac OS X Cocoa where rendering
   * to an invalid drawable results in all OpenGL calls to fail
   * with "invalid framebuffer operation".
   */
  virtual bool IsDrawable() { return true; }

  /**
   * If called, allow MakeCurrent() to skip cache-check when called.
   * MakeCurrent() reverts to original behavior of cache-checking
   * on the next render.
   */
  virtual void SetForceMakeCurrent() {}

  /**
   * Get report of capabilities for the render window
   */
  virtual const char* ReportCapabilities() { return "Not Implemented"; }

  /**
   * Does this render window support OpenGL? 0-false, 1-true
   */
  virtual int SupportsOpenGL() { return 0; }

  /**
   * Is this render window using hardware acceleration? 0-false, 1-true
   */
  virtual int IsDirect() { return 0; }

  /**
   * This method should be defined by the subclass. How many bits of
   * precision are there in the zbuffer?
   */
  virtual int GetDepthBufferSize() = 0;

  /**
   * Get the size of the color buffer.
   * Returns 0 if not able to determine otherwise sets R G B and A into buffer.
   */
  virtual int GetColorBufferSizes(int* rgba) = 0;

  //@{
  /**
   * Set / Get the number of multisamples to use for hardware antialiasing.
   */
  vtkSetMacro(MultiSamples, int);
  vtkGetMacro(MultiSamples, int);
  //@}

  //@{
  /**
   * Set / Get the availability of the stencil buffer.
   */
  vtkSetMacro(StencilCapable, vtkTypeBool);
  vtkGetMacro(StencilCapable, vtkTypeBool);
  vtkBooleanMacro(StencilCapable, vtkTypeBool);
  //@}

  //@{
  /**
   * If there are several graphics card installed on a system,
   * this index can be used to specify which card you want to render to.
   * the default is 0. This may not work on all derived render window and
   * it may need to be set before the first render.
   */
  vtkSetMacro(DeviceIndex, int);
  vtkGetMacro(DeviceIndex, int);
  //@}
  /**
   * Returns the number of devices (graphics cards) on a system.
   * This may not work on all derived render windows.
   */
  virtual int GetNumberOfDevices() { return 0; }

  //@{
  /**
   * Set/Get if we want this window to use the sRGB color space.
   * Some hardware/drivers do not fully support this.
   */
  vtkGetMacro(UseSRGBColorSpace, bool);
  vtkSetMacro(UseSRGBColorSpace, bool);
  vtkBooleanMacro(UseSRGBColorSpace, bool);
  //@}

protected:
  vtkRenderWindow();
  ~vtkRenderWindow() override;

  virtual void DoStereoRender();

  vtkRendererCollection* Renderers;
  vtkNew<vtkRenderTimerLog> RenderTimer;
  vtkTypeBool Borders;
  vtkTypeBool FullScreen;
  int OldScreen[5];
  vtkTypeBool PointSmoothing;
  vtkTypeBool LineSmoothing;
  vtkTypeBool PolygonSmoothing;
  vtkTypeBool StereoRender;
  int StereoType;
  vtkTypeBool StereoCapableWindow;
  vtkTypeBool AlphaBitPlanes;
  vtkRenderWindowInteractor* Interactor;
  vtkSmartPointer<vtkUnsignedCharArray> StereoBuffer; // used for red blue stereo
  vtkSmartPointer<vtkUnsignedCharArray> ResultFrame;
  vtkTypeBool SwapBuffers;
  double DesiredUpdateRate;
  int AbortRender;
  int InAbortCheck;
  int InRender;
  int NeverRendered;
  int NumberOfLayers;
  int CurrentCursor;
  float AnaglyphColorSaturation;
  int AnaglyphColorMask[2];
  int MultiSamples;
  vtkTypeBool StencilCapable;
  int CapturingGL2PSSpecialProps;
  int DeviceIndex;

  bool UseSRGBColorSpace;

  /**
   * The universal time since the last abort check occurred.
   */
  double AbortCheckTime;

  vtkRenderWindow* SharedRenderWindow;

private:
  vtkRenderWindow(const vtkRenderWindow&) = delete;
  void operator=(const vtkRenderWindow&) = delete;

  vtkNew<vtkStereoCompositor> StereoCompositor;
};

#endif
