v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


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


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

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


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;


  double AbortCheckTime;


private:

  vtkRenderWindow(const vtkRenderWindow&);  // Not implemented.

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

};


#endif