vtkOpenGLRenderWindow.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkOpenGLRenderWindow.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 vtkOpenGLRenderWindow_h
#define vtkOpenGLRenderWindow_h
 
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkRenderWindow.h"
#include <map> // for ivar
 
class vtkIdList;
class vtkOpenGLHardwareSupport;
class vtkOpenGLShaderCache;
class vtkOpenGLVertexArrayObject;
class vtkShaderProgram;
class vtkStdString;
class vtkTexture;
class vtkTextureObject;
class vtkTextureUnitManager;
 
class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLRenderWindow : public vtkRenderWindow
{
public:
  vtkTypeMacro(vtkOpenGLRenderWindow, vtkRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  void Render();
 
 
  static void SetGlobalMaximumNumberOfMultiSamples(int val);
  static int  GetGlobalMaximumNumberOfMultiSamples();
 
  virtual void StereoUpdate();
 
 
  virtual unsigned char *GetPixelData(int x,int y,int x2,int y2,int front);
  virtual int GetPixelData(int x,int y,int x2,int y2, int front,
                           vtkUnsignedCharArray *data);
  virtual int SetPixelData(int x,int y,int x2,int y2,unsigned char *data,
                           int front);
  virtual int SetPixelData(int x,int y,int x2,int y2,
                           vtkUnsignedCharArray *data, int front);
 
 
  virtual float *GetRGBAPixelData(int x,int y,int x2,int y2,int front);
  virtual int GetRGBAPixelData(int x,int y,int x2,int y2, int front,
                               vtkFloatArray* data);
  virtual int SetRGBAPixelData(int x,int y,int x2,int y2, float *data,
                               int front, int blend=0);
  virtual int SetRGBAPixelData(int x,int y,int x2,int y2, vtkFloatArray *data,
                               int front, int blend=0);
  virtual void ReleaseRGBAPixelData(float *data);
  virtual unsigned char *GetRGBACharPixelData(int x,int y,int x2,int y2,
                                              int front);
  virtual int GetRGBACharPixelData(int x,int y,int x2,int y2, int front,
                                   vtkUnsignedCharArray *data);
  virtual int SetRGBACharPixelData(int x, int y, int x2, int y2,
                                   unsigned char *data, int front,
                                   int blend=0);
  virtual int SetRGBACharPixelData(int x,int y,int x2,int y2,
                                   vtkUnsignedCharArray *data, int front,
                                   int blend=0);
 
 
  virtual float *GetZbufferData( int x1, int y1, int x2, int y2 );
  virtual int GetZbufferData( int x1, int y1, int x2, int y2, float* z );
  virtual int GetZbufferData( int x1, int y1, int x2, int y2,
                              vtkFloatArray* z );
  virtual int SetZbufferData( int x1, int y1, int x2, int y2, float *buffer );
  virtual int SetZbufferData( int x1, int y1, int x2, int y2,
                              vtkFloatArray *buffer );
 
 
  void ActivateTexture(vtkTextureObject *);
 
  void DeactivateTexture(vtkTextureObject *);
 
  int GetTextureUnitForTexture(vtkTextureObject *);
 
  int GetDepthBufferSize();
 
  int GetColorBufferSizes(int *rgba);
 
  virtual void OpenGLInit();
 
  // Initialize the state of OpenGL that VTK wants for this window
  virtual void OpenGLInitState();
 
  // Initialize VTK for rendering in a new OpenGL context
  virtual void OpenGLInitContext();
 
 
  static bool GetContextSupportsOpenGL32();
  void SetContextSupportsOpenGL32(bool val);
 
  unsigned int GetBackLeftBuffer();
 
  unsigned int GetBackRightBuffer();
 
  unsigned int GetFrontLeftBuffer();
 
  unsigned int GetFrontRightBuffer();
 
  unsigned int GetBackBuffer();
 
  unsigned int GetFrontBuffer();
 
 
  VTK_LEGACY(virtual void CheckGraphicError());
  VTK_LEGACY(virtual int HasGraphicError());
  VTK_LEGACY(virtual const char *GetLastGraphicErrorString());
 
  virtual unsigned long GetContextCreationTime();
 
 
  vtkGetObjectMacro(ShaderCache,vtkOpenGLShaderCache);
 
  vtkTextureUnitManager *GetTextureUnitManager();
 
  virtual void WaitForCompletion();
 
 
  virtual void DrawPixels(int x1, int y1, int x2, int y2,
              int numComponents, int dataType, void *data);
 
 
  virtual void DrawPixels(
    int dstXmin, int dstYmin, int dstXmax, int dstYmax,
    int srcXmin, int srcYmin, int srcXmax, int srcYmax,
    int srcWidth, int srcHeight, int numComponents, int dataType, void *data);
 
 
  virtual void DrawPixels(
    int srcWidth, int srcHeight, int numComponents, int dataType, void *data);
 
 
  virtual float GetMaximumHardwareLineWidth() {
    return this->MaximumHardwareLineWidth; };
 
protected:
  vtkOpenGLRenderWindow();
  ~vtkOpenGLRenderWindow();
 
  vtkOpenGLShaderCache *ShaderCache;
 
  long OldMonitorSetting;
 
  std::map<const vtkTextureObject *, int> TextureResourceIds;
 
  int GetPixelData(int x, int y, int x2, int y2, int front, unsigned char* data);
  int GetRGBAPixelData(int x, int y, int x2, int y2, int front, float* data);
  int GetRGBACharPixelData(int x, int y, int x2, int y2, int front,
                           unsigned char* data);
 
  int CreateHardwareOffScreenWindow(int width, int height);
 
  void DestroyHardwareOffScreenWindow();
 
  int OffScreenUseFrameBuffer;
 
 
  int NumberOfFrameBuffers;
  unsigned int TextureObjects[4]; // really GLuint
  unsigned int FrameBufferObject; // really GLuint
  unsigned int DepthRenderBufferObject; // really GLuint
 
  virtual void CreateAWindow() = 0;
 
  virtual void DestroyWindow() = 0;
 
  virtual void ReleaseGraphicsResources();
 
  void SetTextureUnitManager(vtkTextureUnitManager *textureUnitManager);
 
 
  void SaveGLState();
 
  void RestoreGLState();
 
  std::map<std::string, int> GLStateIntegers;
 
  unsigned int BackLeftBuffer;
  unsigned int BackRightBuffer;
  unsigned int FrontLeftBuffer;
  unsigned int FrontRightBuffer;
  unsigned int FrontBuffer;
  unsigned int BackBuffer;
 
  #ifndef VTK_LEGACY_REMOVE
 
 
  unsigned int LastGraphicError;
  #endif
 
 
  int OwnContext;
 
  vtkTimeStamp ContextCreationTime;
 
  vtkTextureUnitManager *TextureUnitManager;
 
  vtkTextureObject *DrawPixelsTextureObject;
 
  bool Initialized; // ensure glewinit has been called
 
  float MaximumHardwareLineWidth;
 
private:
  vtkOpenGLRenderWindow(const vtkOpenGLRenderWindow&);  // Not implemented.
  void operator=(const vtkOpenGLRenderWindow&);  // Not implemented.
};
 
#endif