vtkOpenGLRenderWindow.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkOpenGLRenderWindow_h
#define vtkOpenGLRenderWindow_h
 
#include "vtkRect.h" // for vtkRecti
#include "vtkRenderWindow.h"
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkType.h"                   // for ivar
#include "vtkWrappingHints.h"          // For VTK_MARSHALAUTO
#include <map>                         // for ivar
#include <set>                         // for ivar
#include <string>                      // for ivar
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIdList;
class vtkOpenGLBufferObject;
class vtkOpenGLFramebufferObject;
class vtkOpenGLHardwareSupport;
class vtkOpenGLQuadHelper;
class vtkOpenGLShaderCache;
class vtkOpenGLVertexBufferObjectCache;
class vtkOpenGLVertexArrayObject;
class vtkShaderProgram;
class vtkTexture;
class vtkTextureObject;
class vtkTextureUnitManager;
class vtkGenericOpenGLResourceFreeCallback;
class vtkOpenGLState;
 
class VTKRENDERINGOPENGL2_EXPORT VTK_MARSHALAUTO vtkOpenGLRenderWindow : public vtkRenderWindow
{
public:
  vtkTypeMacro(vtkOpenGLRenderWindow, vtkRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;
#if !(defined(__APPLE__) || defined(__ANDROID__) || defined(__EMSCRIPTEN__))
  static vtkOpenGLRenderWindow* New();
#endif
 
  void Start() override;
 
  void Frame() override;
 
  const char* GetRenderingBackend() override;
 
 
  static void SetGlobalMaximumNumberOfMultiSamples(int val);
  static int GetGlobalMaximumNumberOfMultiSamples();
 
 
  unsigned char* GetPixelData(int x, int y, int x2, int y2, int front, int right) override;
  int GetPixelData(
    int x, int y, int x2, int y2, int front, vtkUnsignedCharArray* data, int right) override;
  int SetPixelData(
    int x, int y, int x2, int y2, unsigned char* data, int front, int right) override;
  int SetPixelData(
    int x, int y, int x2, int y2, vtkUnsignedCharArray* data, int front, int right) override;
 
 
  float* GetRGBAPixelData(int x, int y, int x2, int y2, int front, int right = 0) override;
  int GetRGBAPixelData(
    int x, int y, int x2, int y2, int front, vtkFloatArray* data, int right = 0) override;
  int SetRGBAPixelData(
    int x, int y, int x2, int y2, float* data, int front, int blend = 0, int right = 0) override;
  int SetRGBAPixelData(int x, int y, int x2, int y2, vtkFloatArray* data, int front, int blend = 0,
    int right = 0) override;
  void ReleaseRGBAPixelData(float* data) override;
  unsigned char* GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, int right = 0) override;
  int GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, vtkUnsignedCharArray* data, int right = 0) override;
  int SetRGBACharPixelData(int x, int y, int x2, int y2, unsigned char* data, int front,
    int blend = 0, int right = 0) override;
  int SetRGBACharPixelData(int x, int y, int x2, int y2, vtkUnsignedCharArray* data, int front,
    int blend = 0, int right = 0) override;
 
 
  float* GetZbufferData(int x1, int y1, int x2, int y2) override;
  int GetZbufferData(int x1, int y1, int x2, int y2, float* z) override;
  int GetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray* buffer) override;
  int SetZbufferData(int x1, int y1, int x2, int y2, float* buffer) override;
  int SetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray* buffer) override;
 
  void ActivateTexture(vtkTextureObject*);
 
  void DeactivateTexture(vtkTextureObject*);
 
  int GetTextureUnitForTexture(vtkTextureObject*);
 
  int GetDepthBufferSize() override;
 
  bool GetUsingSRGBColorSpace();
 
  int GetColorBufferSizes(int* rgba) override;
 
  int GetColorBufferInternalFormat(int attachmentPoint);
 
  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();
 
  void GetOpenGLVersion(int& major, int& minor);
 
  virtual vtkMTimeType GetContextCreationTime();
 
  vtkOpenGLShaderCache* GetShaderCache();
 
  vtkOpenGLVertexBufferObjectCache* GetVBOCache();
 
 
  vtkGetObjectMacro(RenderFramebuffer, vtkOpenGLFramebufferObject);
 
  vtkGetObjectMacro(DisplayFramebuffer, vtkOpenGLFramebufferObject);
 
  vtkTextureUnitManager* GetTextureUnitManager();
 
  void WaitForCompletion() override;
 
  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; }
 
  virtual bool IsPointSpriteBugPresent() { return false; }
 
  int GetDefaultTextureInternalFormat(
    int vtktype, int numComponents, bool needInteger, bool needFloat, bool needSRGB);
 
  std::string GetOpenGLSupportMessage() { return this->OpenGLSupportMessage; }
 
  int SupportsOpenGL() override;
 
  const char* ReportCapabilities() override;
 
  void Initialize() override {}
 
  std::set<vtkGenericOpenGLResourceFreeCallback*> Resources;
 
  void RegisterGraphicsResources(vtkGenericOpenGLResourceFreeCallback* cb)
  {
    std::set<vtkGenericOpenGLResourceFreeCallback*>::iterator it = this->Resources.find(cb);
    if (it == this->Resources.end())
    {
      this->Resources.insert(cb);
    }
  }
 
  void UnregisterGraphicsResources(vtkGenericOpenGLResourceFreeCallback* cb)
  {
    std::set<vtkGenericOpenGLResourceFreeCallback*>::iterator it = this->Resources.find(cb);
    if (it != this->Resources.end())
    {
      this->Resources.erase(it);
    }
  }
 
  virtual void PushContext() { this->MakeCurrent(); }
  virtual void PopContext() {}
 
  bool InitializeFromCurrentContext() override;
 
  virtual bool SetSwapControl(int) { return false; }
 
  // Get the state object used to keep track of
  // OpenGL state
  virtual vtkOpenGLState* GetState() { return this->State; }
 
  // Get a VBO that can be shared by many
  // It consists of normalized display
  // coordinates for a quad and tcoords
  vtkOpenGLBufferObject* GetTQuad2DVBO();
 
  // Activate and return thje texture unit for a generic 2d 64x64
  // float greyscale noise texture ranging from 0 to 1. The texture is
  // a hard-coded blue noise texture.  This texture unit will automatically
  // be deactivated at the end of the render process.
  int GetNoiseTextureUnit();
 
  void End() override;
 
  void Render() override;
 
  void StereoMidpoint() override;
 
  // does VTKs framebuffer require resolving for reading pixels
  bool GetBufferNeedsResolving();
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  void BlitDisplayFramebuffer();
 
  void BlitDisplayFramebufferColorAndDepth();
 
  void BlitDisplayFramebuffer(int right, int srcX, int srcY, int srcWidth, int srcHeight, int destX,
    int destY, int destWidth, int destHeight, int bufferMode, int interpolation);
 
 
  void BlitToRenderFramebuffer(bool includeDepth);
  void BlitToRenderFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int destX,
    int destY, int destWidth, int destHeight, int bufferMode, int interpolation);
 
  enum FrameBlitModes
  {
    BlitToHardware,         // hardware buffers
    BlitToCurrent,          // currently bound draw framebuffer, without depth buffer
    BlitToCurrentWithDepth, // currently bound draw framebuffer, including depth buffer
    NoBlit                  // no blit, GUI or external code will handle the blit
  };
 
 
  vtkSetClampMacro(FrameBlitMode, FrameBlitModes, BlitToHardware, NoBlit);
  vtkGetMacro(FrameBlitMode, FrameBlitModes);
  void SetFrameBlitModeToBlitToHardware() { this->SetFrameBlitMode(BlitToHardware); }
  void SetFrameBlitModeToBlitToCurrent() { this->SetFrameBlitMode(BlitToCurrent); }
  void SetFrameBlitModeToBlitToCurrentWithDepth()
  {
    this->SetFrameBlitMode(BlitToCurrentWithDepth);
  }
  void SetFrameBlitModeToNoBlit() { this->SetFrameBlitMode(NoBlit); }
 
 
  vtkSetMacro(FramebufferFlipY, bool);
  vtkGetMacro(FramebufferFlipY, bool);
  vtkBooleanMacro(FramebufferFlipY, bool);
 
 
  vtkSetMacro(RenderBufferTargetDepthSize, int);
  vtkGetMacro(RenderBufferTargetDepthSize, int);
 
  // copy depth values from a source framebuffer to a destination framebuffer
  // using texture maps to do the copy. The source framebufferobject must be texture
  // backed. This method is designed to work around issues with trying to blit depth
  // values between framebuffers that have different depth formats.
 
  // blit entire source texture to active viewport
  virtual void TextureDepthBlit(vtkTextureObject* source);
 
  // blit specified source texels to active viewport
  virtual void TextureDepthBlit(vtkTextureObject* source, int srcX, int srcY, int srcX2, int srcY2);
 
  // blit specified source texels to specified viewport
  virtual void TextureDepthBlit(vtkTextureObject* source, int srcX, int srcY, int srcX2, int srcY2,
    int destX, int destY, int destX2, int destY2);
 
  typedef void (*VTKOpenGLAPIProc)();
  typedef VTKOpenGLAPIProc (*VTKOpenGLLoaderFunction)(void* userptr, const char* name);
  void SetOpenGLSymbolLoader(VTKOpenGLLoaderFunction loader, void* userData);
 
protected:
  vtkOpenGLRenderWindow();
  ~vtkOpenGLRenderWindow() override;
 
  // blits the display buffers to the appropriate hardware buffers
  virtual void BlitDisplayFramebuffersToHardware();
 
  // when frame is called, at the end blit to the hardware buffers
  FrameBlitModes FrameBlitMode;
 
  // a FSQ we use to resolve MSAA that handles gamma
  vtkOpenGLQuadHelper* ResolveQuad;
 
  // a FSQ we use to blit depth values
  vtkOpenGLQuadHelper* DepthBlitQuad;
 
  // a FSQ we use to flip framebuffer texture
  vtkOpenGLQuadHelper* FlipQuad;
 
  // a FSQ we use to read depth component on platforms with OpenGL ES implementations
  // because `glReadPixels` cannot be used to read GL_DEPTH_COMPONENT
  vtkOpenGLQuadHelper* DepthReadQuad;
 
  // flip quad helpers Y tcoord
  bool FramebufferFlipY;
 
  // resolve and flip renderframebuffer as needed
  // when copying to displayframebuffer. Returns
  // true if the color buffer was copied.
  virtual bool ResolveFlipRenderFramebuffer();
 
  // On GLES, the depth attachment buffer cannot be downloaded from
  // the GPU with `glReadPixels`.
  // This method reads the depth buffer bits.
  // The depth attachment size can be 8,16,24 or 32. The values are split into 4 8-bit numbers.
  // These are stored in the form of an RGBA color attachment in DepthFrameBuffer.
  // `glReadPixels` can read that RGBA format and reconstruct full 8,16,24 or 32-bit integer
  // followed by scaling down to 0-1.
  bool ReadDepthComponent(int depthSize);
 
  // used in testing for opengl support
  // in the SupportsOpenGL() method
  bool OpenGLSupportTested;
  int OpenGLSupportResult;
  std::string OpenGLSupportMessage;
 
  virtual int ReadPixels(
    const vtkRecti& rect, int front, int glFormat, int glType, void* data, int right = 0);
 
  int CreateFramebuffers(int width, int height);
  vtkOpenGLFramebufferObject* RenderFramebuffer;
  vtkOpenGLFramebufferObject* DisplayFramebuffer;
 
  // used when we need to resolve a multisampled
  // framebuffer
  vtkOpenGLFramebufferObject* ResolveFramebuffer;
 
  // used when we need to read depth component
  // with OpenGL ES 3
  vtkOpenGLFramebufferObject* DepthFramebuffer;
 
  virtual void CreateAWindow() = 0;
 
  virtual void DestroyWindow() = 0;
 
  void SaveGLState();
 
  void RestoreGLState();
 
  std::map<std::string, int> GLStateIntegers;
 
  vtkTypeBool OwnContext;
 
  vtkTimeStamp ContextCreationTime;
 
  vtkTextureObject* DrawPixelsTextureObject;
 
  float MaximumHardwareLineWidth;
 
  char* Capabilities;
 
  // used for fast quad rendering
  vtkOpenGLBufferObject* TQuad2DVBO;
 
  // noise texture
  vtkTextureObject* NoiseTextureObject;
 
  double FirstRenderTime;
 
  // keep track of in case we need to recreate the framebuffer
  int LastMultiSamples;
 
  // how much bits to use for depth of created Framebuffers
  int RenderBufferTargetDepthSize;
 
  int ScreenSize[2];
 
  struct
  {
    VTKOpenGLLoaderFunction LoadFunction = nullptr;
    void* UserData = nullptr;
  } SymbolLoader;
 
private:
  vtkOpenGLRenderWindow(const vtkOpenGLRenderWindow&) = delete;
  void operator=(const vtkOpenGLRenderWindow&) = delete;
 
  // Keeping `State` private so the only way to access it is through
  // `this->GetState()`.
  vtkOpenGLState* State;
};
 
VTK_ABI_NAMESPACE_END
#endif