dox/Rendering/Core/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"

class vtkFloatArray;
class vtkPainterDeviceAdapter;
class vtkProp;
class vtkCollection;
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_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

#ifndef VTK_LEGACY_REMOVE
// This macro should not be used, see vtkOpenGLError.h for
// GL error handling functions and macros.
#if defined NDEBUG
# define vtkGraphicErrorMacro(renderWindow,message)   \
  renderWindow->CheckGraphicError();
#else
# define vtkGraphicErrorMacro(renderWindow,message)   \
  renderWindow->CheckGraphicError();                  \
  if ( renderWindow->GetReportGraphicErrors()         \
    && renderWindow->HasGraphicError() )              \
    {                                                 \
    vtkErrorMacro(                                    \
      << message << " "                               \
      << renderWindow->GetLastGraphicErrorString());  \
    }
# endif
#endif

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

  static vtkRenderWindow *New();

  virtual void AddRenderer(vtkRenderer *);

  void RemoveRenderer(vtkRenderer *);

  int HasRenderer(vtkRenderer *);

  static const char *GetRenderLibrary();

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

  void CaptureGL2PSSpecialProps(vtkCollection *specialProps);


  vtkGetMacro(CapturingGL2PSSpecialProps, int);

  virtual void Render();

  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(int) = 0;
  vtkGetMacro(FullScreen,int);
  vtkBooleanMacro(FullScreen,int);


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


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


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


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


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


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


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


  vtkGetMacro(StereoType,int);
  vtkSetMacro(StereoType,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);}

  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,int);
  vtkGetMacro(SwapBuffers,int);
  vtkBooleanMacro(SwapBuffers,int);


  virtual int SetPixelData(int x, int y, int x2, int y2, unsigned char *data,
                           int front) = 0;
  virtual int SetPixelData(int x, int y, int x2, int y2,
                           vtkUnsignedCharArray *data, int front) = 0;


  virtual float *GetRGBAPixelData(int x, int y, int x2, int y2, int front) = 0;
  virtual int GetRGBAPixelData(int x, int y, int x2, int y2, int front,
                               vtkFloatArray *data) = 0;
  virtual int SetRGBAPixelData(int x, int y, int x2, int y2, float *,
                               int front, int blend=0) = 0;
  virtual int SetRGBAPixelData(int, int, int, int, vtkFloatArray*,
                               int, int blend=0) = 0;
  virtual void ReleaseRGBAPixelData(float *data)=0;
  virtual unsigned char *GetRGBACharPixelData(int x, int y, int x2, int y2,
                                              int front) = 0;
  virtual int GetRGBACharPixelData(int x, int y, int x2, int y2, int front,
                                   vtkUnsignedCharArray *data) = 0;
  virtual int SetRGBACharPixelData(int x,int y, int x2, int y2,
                                   unsigned char *data, int front,
                                   int blend=0) = 0;
  virtual int SetRGBACharPixelData(int x, int y, int x2, int y2,
                                   vtkUnsignedCharArray *data, int front,
                                   int blend=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(AAFrames,int);
  vtkSetMacro(AAFrames,int);


  vtkGetMacro(FDFrames,int);
  virtual void SetFDFrames (int fdFrames);


  vtkGetMacro(UseConstantFDOffsets,int);
  vtkSetMacro(UseConstantFDOffsets,int);


  vtkGetMacro(SubFrames,int);
  virtual void SetSubFrames(int subFrames);


  vtkGetMacro(NeverRendered,int);


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

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

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

  virtual void UnRegister(vtkObjectBase *o);


  virtual void SetDisplayId(void *) = 0;
  virtual void SetWindowId(void *)  = 0;
  virtual void SetNextWindowId(void *) = 0;
  virtual void SetParentId(void *)  = 0;
  virtual void *GetGenericDisplayId() = 0;
  virtual void *GetGenericWindowId() = 0;
  virtual void *GetGenericParentId() = 0;
  virtual void *GetGenericContext() = 0;
  virtual void *GetGenericDrawable() = 0;
  virtual void SetWindowInfo(char *) = 0;
  virtual void SetNextWindowInfo(char *) = 0;
  virtual void SetParentInfo(char *) = 0;

  virtual bool InitializeFromCurrentContext() { return false; };

  virtual void MakeCurrent() = 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;


  vtkGetObjectMacro(PainterDeviceAdapter, vtkPainterDeviceAdapter);


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


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


  VTK_LEGACY(void SetReportGraphicErrors(int val));
  VTK_LEGACY(void SetReportGraphicErrorsOn());
  VTK_LEGACY(void SetReportGraphicErrorsOff());
  VTK_LEGACY(int GetReportGraphicErrors());

#ifndef VTK_LEGACY_REMOVE


  virtual void CheckGraphicError() = 0;
  virtual int HasGraphicError() = 0;
  virtual const char *GetLastGraphicErrorString() = 0;
#endif


protected:
  vtkRenderWindow();
  ~vtkRenderWindow();

  virtual void DoStereoRender();
  virtual void DoFDRender();
  virtual void DoAARender();

  vtkPainterDeviceAdapter* PainterDeviceAdapter;
  vtkRendererCollection *Renderers;
  int Borders;
  int FullScreen;
  int OldScreen[5];
  int PointSmoothing;
  int LineSmoothing;
  int PolygonSmoothing;
  int StereoRender;
  int StereoType;
  int StereoStatus; // used for keeping track of what's going on
  int StereoCapableWindow;
  int AlphaBitPlanes;
  vtkRenderWindowInteractor *Interactor;
  unsigned char* StereoBuffer; // used for red blue stereo
  float *AccumulationBuffer;   // used for many techniques
  unsigned int AccumulationBufferSize;
  int AAFrames;
  int FDFrames;
  int UseConstantFDOffsets; // to use the same offsets at each rendering
  double *ConstantFDOffsets[2];
  int SubFrames;               // number of sub frames
  int CurrentSubFrame;         // what one are we on
  unsigned char *ResultFrame;  // used for any non immediate rendering
  int   SwapBuffers;
  double DesiredUpdateRate;
  int   AbortRender;
  int   InAbortCheck;
  int   InRender;
  int   NeverRendered;
  int   NumberOfLayers;
  int CurrentCursor;
  int IsPicking;
  float AnaglyphColorSaturation;
  int AnaglyphColorMask[2];
  int MultiSamples;
  int StencilCapable;
  int CapturingGL2PSSpecialProps;

#ifndef VTK_LEGACY_REMOVE


  int ReportGraphicErrors;
#endif


  double AbortCheckTime;

private:
  vtkRenderWindow(const vtkRenderWindow&);  // Not implemented.
  void operator=(const vtkRenderWindow&);  // Not implemented.
};

#endif