Rendering/vtkRenderWindow.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkRenderWindow.h,v $

  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 "vtkWindow.h"

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

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

  static vtkRenderWindow *New();

  virtual void AddRenderer(vtkRenderer *);

  void RemoveRenderer(vtkRenderer *);

  static const char *GetRenderLibrary();

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

  virtual void Render();

  virtual void Start() = 0;
  
  virtual void Frame() = 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);};  
  char *GetStereoTypeAsString();

  virtual void StereoUpdate();

  virtual void StereoMidpoint();

  virtual void StereoRenderComplete();

  virtual void WindowRemap() = 0;
  

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

  virtual int SetPixelData(int, int, int, int, unsigned char *,int) = 0;
  virtual int SetPixelData(int, int, int, int, vtkUnsignedCharArray*,
                           int ) = 0;


  virtual float *GetRGBAPixelData(int ,int ,int ,int ,int ) = 0;
  virtual int GetRGBAPixelData(int, int, int, int, int, vtkFloatArray* ) = 0;
  virtual int SetRGBAPixelData(int ,int ,int ,int ,float *,int,
                               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 ,int ,int ,int ,int ) = 0;
  virtual int GetRGBACharPixelData(int ,int, int, int, int,
                                   vtkUnsignedCharArray*) = 0;
  virtual int SetRGBACharPixelData(int ,int ,int ,int ,unsigned char *, int,
                                   int blend=0) = 0;
  virtual int SetRGBACharPixelData(int, int, int, int,
                                   vtkUnsignedCharArray *,
                                   int, int blend=0) = 0;


  virtual float *GetZbufferData(int, int, int, int ) = 0;
  virtual int GetZbufferData( int, int, int, int, vtkFloatArray*) = 0;
  virtual int SetZbufferData(int, int, int, int, float *) = 0;
  virtual int SetZbufferData( int, int, int, int, vtkFloatArray * ) = 0;


  vtkGetMacro(AAFrames,int);
  vtkSetMacro(AAFrames,int);


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


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


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


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

  virtual void SetForceMakeCurrent() {};

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

  virtual int SupportsOpenGL() { return 0;};

  virtual int IsDirect() { return 0;};

  virtual int GetDepthBufferSize() = 0;

protected:
  vtkRenderWindow();
  ~vtkRenderWindow();

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

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

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

inline char *vtkRenderWindow::GetStereoTypeAsString(void)
{
  switch ( this->StereoType )
    {
    case VTK_STEREO_CRYSTAL_EYES:
      return (char *)"CrystalEyes";
    case VTK_STEREO_RED_BLUE:
      return (char *)"RedBlue";
    case VTK_STEREO_LEFT:
      return (char *)"Left";
    case VTK_STEREO_RIGHT:
      return (char *)"Right";
    case VTK_STEREO_DRESDEN:
      return (char *)"DresdenDisplay";
    default:
      return (char *)"";
    }
}

#endif

Generated on Tue May 23 11:05:25 2006 for VTK by Doxygen 1.3.5