vtkOpenGLState.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 vtkOpenGLState_h
#define vtkOpenGLState_h
 
#include "vtkObject.h"
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include <array>                       // for ivar
#include <list>                        // for ivar
#include <map>                         // for ivar
#include <stack>                       // for ivar
#include <string>                      // for ivar
 
VTK_ABI_NAMESPACE_BEGIN
class vtkOpenGLFramebufferObject;
class vtkOpenGLRenderWindow;
class vtkOpenGLShaderCache;
class vtkOpenGLTextureNormalizationHelper;
class vtkOpenGLVertexBufferObjectCache;
class vtkTextureObject;
class vtkTextureUnitManager;
 
class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLState : public vtkObject
{
public:
  static vtkOpenGLState* New();
  vtkTypeMacro(vtkOpenGLState, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  // cached OpenGL methods. By calling these the context will check
  // the current value prior to making the OpenGL call. This can reduce
  // the burden on the driver.
  //
  void vtkglClearColor(float red, float green, float blue, float alpha);
  void vtkglClearDepth(double depth);
  void vtkglDepthFunc(unsigned int val);
  void vtkglDepthMask(unsigned char flag);
  void vtkglColorMask(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
  void vtkglViewport(int x, int y, int width, int height);
  void vtkglScissor(int x, int y, int width, int height);
  void vtkglEnable(unsigned int cap);
  void vtkglDisable(unsigned int cap);
  void vtkglBlendFunc(unsigned int sfactor, unsigned int dfactor)
  {
    this->vtkglBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
  }
  void vtkglBlendFuncSeparate(unsigned int sfactorRGB, unsigned int dfactorRGB,
    unsigned int sfactorAlpha, unsigned int dfactorAlpha);
  void vtkglBlendEquation(unsigned int val);
  void vtkglBlendEquationSeparate(unsigned int col, unsigned int alpha);
  void vtkglCullFace(unsigned int val);
  void vtkglActiveTexture(unsigned int);
 
  void vtkglBindFramebuffer(unsigned int target, unsigned int fb);
  void vtkglDrawBuffer(unsigned int);
  void vtkglDrawBuffers(unsigned int n, unsigned int*);
  void vtkglReadBuffer(unsigned int);
 
  void vtkglPointSize(float);
  void vtkglLineWidth(float);
  void vtkglStencilMaskSeparate(unsigned int face, unsigned int mask);
  void vtkglStencilMask(unsigned int mask);
  void vtkglStencilOpSeparate(
    unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass);
  void vtkglStencilOp(unsigned int sfail, unsigned int dpfail, unsigned int dppass);
  void vtkglStencilFuncSeparate(unsigned int face, unsigned int func, int ref, unsigned int mask);
  void vtkglStencilFunc(unsigned int func, int ref, unsigned int mask);
 
  void vtkBindFramebuffer(unsigned int target, vtkOpenGLFramebufferObject* fo);
  void vtkDrawBuffers(unsigned int n, unsigned int*, vtkOpenGLFramebufferObject*);
  void vtkReadBuffer(unsigned int, vtkOpenGLFramebufferObject*);
 
  void vtkglPixelStorei(unsigned int, int);

  // Methods to reset the state to the current OpenGL context value.
  // These methods are useful when interfacing with third party code
  // that may have changed the opengl state.
  //
  void ResetGLClearColorState();
  void ResetGLClearDepthState();
  void ResetGLDepthFuncState();
  void ResetGLDepthMaskState();
  void ResetGLColorMaskState();
  void ResetGLViewportState();
  void ResetGLScissorState();
  void ResetGLBlendFuncState();
  void ResetGLBlendEquationState();
  void ResetGLCullFaceState();
  void ResetGLActiveTexture();

  // OpenGL functions that we provide an API for even though they may
  // not hold any state.
  void vtkglClear(unsigned int mask);

  // Get methods that can be used to query state if the state is not cached
  // they fall through and call the underlying opengl functions
  void vtkglGetBooleanv(unsigned int pname, unsigned char* params);
  void vtkglGetIntegerv(unsigned int pname, int* params);
  void vtkglGetDoublev(unsigned int pname, double* params);
  void vtkglGetFloatv(unsigned int pname, float* params);
 
  // convenience to get all 4 values at once
  void GetBlendFuncState(int*);
 
  // convenience to return a bool
  // as opposed to a unsigned char
  bool GetEnumState(unsigned int name);
 
  // convenience method to set a enum (glEnable/glDisable)
  void SetEnumState(unsigned int name, bool value);

  void ResetEnumState(unsigned int name);
 
  // superclass for Scoped subclasses
  template <typename T>
  class VTKRENDERINGOPENGL2_EXPORT ScopedValue
  {
  public:
    ~ScopedValue() // restore value
    {
      ((*this->State).*(this->Method))(this->Value);
    }
 
  protected:
    vtkOpenGLState* State;
    T Value;
    void (vtkOpenGLState::*Method)(T);
  };

  void ActivateTexture(vtkTextureObject*);

  void DeactivateTexture(vtkTextureObject*);

  int GetTextureUnitForTexture(vtkTextureObject*);

  void VerifyNoActiveTextures();


  void PushFramebufferBindings()
  {
    this->PushDrawFramebufferBinding();
    this->PushReadFramebufferBinding();
  }
  void PushDrawFramebufferBinding();
  void PushReadFramebufferBinding();
 
  void PopFramebufferBindings()
  {
    this->PopReadFramebufferBinding();
    this->PopDrawFramebufferBinding();
  }
  void PopDrawFramebufferBinding();
  void PopReadFramebufferBinding();
 
  void ResetFramebufferBindings();
 
  // Scoped classes you can use to save state
  class VTKRENDERINGOPENGL2_EXPORT ScopedglDepthMask : public ScopedValue<unsigned char>
  {
  public:
    ScopedglDepthMask(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglClearColor : public ScopedValue<std::array<float, 4>>
  {
  public:
    ScopedglClearColor(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglColorMask
    : public ScopedValue<std::array<unsigned char, 4>>
  {
  public:
    ScopedglColorMask(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglScissor : public ScopedValue<std::array<int, 4>>
  {
  public:
    ScopedglScissor(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglViewport : public ScopedValue<std::array<int, 4>>
  {
  public:
    ScopedglViewport(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglBlendFuncSeparate
    : public ScopedValue<std::array<unsigned int, 4>>
  {
  public:
    ScopedglBlendFuncSeparate(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglDepthFunc : public ScopedValue<unsigned int>
  {
  public:
    ScopedglDepthFunc(vtkOpenGLState* state);
  };
  class VTKRENDERINGOPENGL2_EXPORT ScopedglActiveTexture : public ScopedValue<unsigned int>
  {
  public:
    ScopedglActiveTexture(vtkOpenGLState* state);
  };
 
  class ScopedglEnableDisable
  {
  public:
    ScopedglEnableDisable(vtkOpenGLState* state, unsigned int name)
    {
      this->State = state;
      this->Name = name;
      unsigned char val;
      this->State->vtkglGetBooleanv(name, &val);
      this->Value = val == 1;
    }
    ~ScopedglEnableDisable() // restore value
    {
      this->State->SetEnumState(this->Name, this->Value);
    }
 
  protected:
    vtkOpenGLState* State;
    unsigned int Name;
    bool Value;
  };

  void Initialize(vtkOpenGLRenderWindow*);

  void SetTextureUnitManager(vtkTextureUnitManager* textureUnitManager);

  vtkTextureUnitManager* GetTextureUnitManager();
 
  // get the shader program cache for this context
  vtkGetObjectMacro(ShaderCache, vtkOpenGLShaderCache);
 
  // get the vbo buffer cache for this context
  vtkGetObjectMacro(VBOCache, vtkOpenGLVertexBufferObjectCache);
 
  // set the VBO Cache to use for this state
  // this allows two contexts to share VBOs
  // basically this is OPenGL's support for shared
  // lists
  void SetVBOCache(vtkOpenGLVertexBufferObjectCache* val);

  int GetDefaultTextureInternalFormat(
    int vtktype, int numComponents, bool needInteger, bool needFloat, bool needSRGB);

  void GetCurrentDrawFramebufferState(unsigned int& drawBinding, unsigned int& drawBuffer);

  void vtkglBlitFramebuffer(int, int, int, int, int, int, int, int, unsigned int, unsigned int);

  void Reset();

  void Push();

  void Pop();

  std::string const& GetVersion() { return this->Version; }

  std::string const& GetVendor() { return this->Vendor; }

  std::string const& GetRenderer() { return this->Renderer; }

  bool GetSupportsTextureNorm16() { return this->SupportsTextureNorm16; }

  vtkOpenGLTextureNormalizationHelper* GetTextureNormalizationHelper()
  {
    return this->TextureNormalizationHelper;
  }
 
protected:
  vtkOpenGLState(); // set initial values
  ~vtkOpenGLState() override;
 
  void BlendFuncSeparate(std::array<unsigned int, 4> val);
  void ClearColor(std::array<float, 4> val);
  void ColorMask(std::array<unsigned char, 4> val);
  void Scissor(std::array<int, 4> val);
  void Viewport(std::array<int, 4> val);
 
  int TextureInternalFormats[VTK_OBJECT + 1][3][5];
  bool SupportsTextureNorm16 = false;
  void InitializeTextureInternalFormats();
 
  vtkTextureUnitManager* TextureUnitManager;
  vtkOpenGLTextureNormalizationHelper* TextureNormalizationHelper = nullptr;
  std::map<const vtkTextureObject*, int> TextureResourceIds;

  void CheckState();
 
  // framebuffers hold state themselves
  // specifically they hold their draw and read buffers
  // and when bound they reinstate those buffers
  class VTKRENDERINGOPENGL2_EXPORT BufferBindingState
  {
  public:
    BufferBindingState();
    unsigned int Binding;
    unsigned int ReadBuffer;
    unsigned int DrawBuffers[10];
    unsigned int GetBinding();
    unsigned int GetDrawBuffer(unsigned int);
    unsigned int GetReadBuffer();
  };
  std::list<BufferBindingState> DrawBindings;
  std::list<BufferBindingState> ReadBindings;
 
  // static opengl properties
  int MajorVersion;
  int MinorVersion;
  int MaxTessellationLevel;
  int MaxTextureSize;
  std::string Vendor;
  std::string Renderer;
  std::string Version;
 
  class VTKRENDERINGOPENGL2_EXPORT GLState
  {
  public:
    double ClearDepth;
    unsigned char DepthMask;
    unsigned int DepthFunc;
    unsigned int BlendEquationValue1;
    unsigned int BlendEquationValue2;
    unsigned int CullFaceMode;
    unsigned int ActiveTexture;
 
    float PointSize;
    float LineWidth;
    unsigned int StencilMaskFront;
    unsigned int StencilMaskBack;
    std::array<unsigned int, 3> StencilFuncFront;
    std::array<unsigned int, 3> StencilFuncBack;
    std::array<unsigned int, 3> StencilOpFront;
    std::array<unsigned int, 3> StencilOpBack;
 
    int PackAlignment;
    int UnpackAlignment;
    int UnpackRowLength;
    int UnpackImageHeight;
 
    std::array<float, 4> ClearColor;
    std::array<unsigned char, 4> ColorMask;
    std::array<int, 4> Viewport;
    std::array<int, 4> Scissor;
    std::array<unsigned int, 4> BlendFunc;
    bool DepthTest;
    bool CullFace;
    bool ScissorTest;
    bool StencilTest;
    bool Blend;
    bool MultiSample;
    bool CubeMapSeamless;
    bool LineSmooth;
    int BoundVAO;
    int BoundArrayBuffer;
    int BoundElementArrayBuffer;
    int BoundProgram;
    BufferBindingState DrawBinding;
    BufferBindingState ReadBinding;
    GLState() = default;
  };
 
  std::stack<GLState> Stack;
 
  vtkOpenGLVertexBufferObjectCache* VBOCache;
  vtkOpenGLShaderCache* ShaderCache;
 
private:
  vtkOpenGLState(const vtkOpenGLState&) = delete;
  void operator=(const vtkOpenGLState&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif