vtkRenderWindow.h

Go to the documentation of this file.

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

  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.

=========================================================================*/
#ifndef vtkRenderWindow_h
#define vtkRenderWindow_h

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

class vtkFloatArray;
class vtkProp;
class vtkCollection;
class vtkRenderTimerLog;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkRendererCollection;
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_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;

  static vtkRenderWindow *New();

  virtual void AddRenderer(vtkRenderer *);

  void RemoveRenderer(vtkRenderer *);

  int HasRenderer(vtkRenderer *);

  static const char *GetRenderLibrary();

  virtual const char *GetRenderingBackend();

  vtkGetNewMacro(RenderTimer, vtkRenderTimerLog)

  
  vtkRendererCollection *GetRenderers() {return this->Renderers;};

  void CaptureGL2PSSpecialProps(vtkCollection *specialProps);


  vtkGetMacro(CapturingGL2PSSpecialProps, int);

  void Render() override;

  virtual void Start() = 0;

  virtual void Finalize() = 0;

  virtual void Frame() = 0;

  virtual void WaitForCompletion()=0;

  virtual void CopyResultFrame();

  virtual vtkRenderWindowInteractor *MakeRenderWindowInteractor();


  virtual void HideCursor() = 0;
  virtual void ShowCursor() = 0;
  virtual void SetCursorPosition(int , int ) {}


  vtkSetMacro(CurrentCursor,int);
  vtkGetMacro(CurrentCursor,int);


  virtual void SetFullScreen(vtkTypeBool) = 0;
  vtkGetMacro(FullScreen,vtkTypeBool);
  vtkBooleanMacro(FullScreen,vtkTypeBool);


  vtkSetMacro(Borders,vtkTypeBool);
  vtkGetMacro(Borders,vtkTypeBool);
  vtkBooleanMacro(Borders,vtkTypeBool);


  vtkGetMacro(StereoCapableWindow,vtkTypeBool);
  vtkBooleanMacro(StereoCapableWindow,vtkTypeBool);
  virtual void SetStereoCapableWindow(vtkTypeBool capable);


  vtkGetMacro(StereoRender,vtkTypeBool);
  void SetStereoRender(vtkTypeBool stereo);
  vtkBooleanMacro(StereoRender,vtkTypeBool);


  vtkSetMacro(AlphaBitPlanes, vtkTypeBool);
  vtkGetMacro(AlphaBitPlanes, vtkTypeBool);
  vtkBooleanMacro(AlphaBitPlanes, vtkTypeBool);


  vtkSetMacro(PointSmoothing,vtkTypeBool);
  vtkGetMacro(PointSmoothing,vtkTypeBool);
  vtkBooleanMacro(PointSmoothing,vtkTypeBool);


  vtkSetMacro(LineSmoothing,vtkTypeBool);
  vtkGetMacro(LineSmoothing,vtkTypeBool);
  vtkBooleanMacro(LineSmoothing,vtkTypeBool);


  vtkSetMacro(PolygonSmoothing,vtkTypeBool);
  vtkGetMacro(PolygonSmoothing,vtkTypeBool);
  vtkBooleanMacro(PolygonSmoothing,vtkTypeBool);


  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);}

  const char *GetStereoTypeAsString();

  virtual void StereoUpdate();

  virtual void StereoMidpoint();

  virtual void StereoRenderComplete();


  vtkSetClampMacro(AnaglyphColorSaturation,float, 0.0f, 1.0f);
  vtkGetMacro(AnaglyphColorSaturation,float);


  vtkSetVector2Macro(AnaglyphColorMask,int);
  vtkGetVectorMacro(AnaglyphColorMask,int,2);

  virtual void WindowRemap() = 0;


  vtkSetMacro(SwapBuffers,vtkTypeBool);
  vtkGetMacro(SwapBuffers,vtkTypeBool);
  vtkBooleanMacro(SwapBuffers,vtkTypeBool);


  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;


  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;


  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;
  }


  vtkGetMacro(NeverRendered,int);


  vtkGetMacro(AbortRender,int);
  vtkSetMacro(AbortRender,int);
  vtkGetMacro(InAbortCheck,int);
  vtkSetMacro(InAbortCheck,int);
  virtual int CheckAbortStatus();

  vtkGetMacro(IsPicking,vtkTypeBool);
  vtkSetMacro(IsPicking,vtkTypeBool);
  vtkBooleanMacro(IsPicking,vtkTypeBool);

  virtual int GetEventPending() = 0;

  virtual int  CheckInRenderStatus() { return this->InRender; }

  virtual void ClearInRenderStatus() { this->InRender = 0; }


  virtual void SetDesiredUpdateRate(double);
  vtkGetMacro(DesiredUpdateRate,double);


  vtkGetMacro(NumberOfLayers, int);
  vtkSetClampMacro(NumberOfLayers, int, 1, VTK_INT_MAX);


  vtkGetObjectMacro(Interactor,vtkRenderWindowInteractor);

  void SetInteractor(vtkRenderWindowInteractor *);

  void UnRegister(vtkObjectBase *o) override;


  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;

  virtual bool InitializeFromCurrentContext() { return false; };


  virtual void SetSharedRenderWindow(vtkRenderWindow *);
  vtkGetObjectMacro(SharedRenderWindow, vtkRenderWindow);
  virtual bool GetPlatformSupportsRenderWindowSharing() { return false; };

  void MakeCurrent() override = 0;

  virtual bool IsCurrent()=0;

  virtual bool IsDrawable(){ return true; }

  virtual void SetForceMakeCurrent() {}

  virtual const char *ReportCapabilities() { return "Not Implemented";};

  virtual int SupportsOpenGL() { return 0;};

  virtual int IsDirect() { return 0;};

  virtual int GetDepthBufferSize() = 0;

  virtual int GetColorBufferSizes(int *rgba) = 0;


  vtkSetMacro(MultiSamples,int);
  vtkGetMacro(MultiSamples,int);


  vtkSetMacro(StencilCapable, vtkTypeBool);
  vtkGetMacro(StencilCapable, vtkTypeBool);
  vtkBooleanMacro(StencilCapable, vtkTypeBool);


  vtkSetMacro(DeviceIndex,int);
  vtkGetMacro(DeviceIndex,int);

  virtual int GetNumberOfDevices()
  {
    return 0;
  }

  virtual int SetUseOffScreenBuffers(bool) { return 0; }
  virtual bool GetUseOffScreenBuffers() { return false; }


  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;
  unsigned char* StereoBuffer; // used for red blue stereo
  float *AccumulationBuffer;   // used for many techniques
  unsigned int AccumulationBufferSize;
  unsigned char *ResultFrame;
  vtkTypeBool   SwapBuffers;
  double DesiredUpdateRate;
  int   AbortRender;
  int   InAbortCheck;
  int   InRender;
  int   NeverRendered;
  int   NumberOfLayers;
  int CurrentCursor;
  vtkTypeBool IsPicking;
  float AnaglyphColorSaturation;
  int AnaglyphColorMask[2];
  int MultiSamples;
  vtkTypeBool StencilCapable;
  int CapturingGL2PSSpecialProps;
  int DeviceIndex;

  bool UseSRGBColorSpace;

  double AbortCheckTime;

  vtkRenderWindow *SharedRenderWindow;

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

#endif