"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore

class vtkOpenGLState(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkOpenGLState - OpenGL state storage
    
    Superclass: vtkObject
    
    vtkOpenGLState is a class designed to keep track of the state of an
    OpenGL context. Applications using VTK have so much control over the
    rendering process that is can be difficult in VTK code to know if the
    OpenGL state is correct for your code. The two traditional solutions
    have been to set everything yourself and to save and restore OpenGL
    state that you change. The former makes your code work, the latter
    helps prevent your code from breaking something else. The problem is
    that the former results in tons of redundant OpenGL calls and the
    later is done by querying the OpenGL state which can cause a pipeline
    sync/stall which is very slow.
    
    To address these issues this class stores OpenGL state for commonly
    used functions. Requests made to change state to the current state
    become no-ops. Queries of state can be done by querying the state
    stored in this class without impacting the OpenGL driver.
    
    This class is designed to hold all context related values and could
    just as well be considered a representation of the OpenGL context.
    
    To facilitate saving state and restoring it this class contains a
    number of nested classes named Scopedthat store the state of that
    glFunction and when they go out of scope they restore it. This is
    useful when you want to change the OpenGL state and then
    automatically restore it when done. They can be used as follows
    
    {
      vtkOpenGLState *ostate = renWin->GetState();
      vtkOpenGLState::ScopedglDepthMask dmsaved(ostate);
      // the prior state is now saved
      ...
      ostate->glDepthMask(GL_TRUE);  // maybe change the state
      ... etc } // prior state will be restored here as it goes out of
    scope
    
    You must use this class to make state changing OpenGL class otherwise
    the results will be undefined.
    
    For convenience some OpenGL calls that do not impact state are also
    provided.
    """
    def ActivateTexture(self, vtkTextureObject):
        """
        V.ActivateTexture(vtkTextureObject)
        C++: void ActivateTexture(vtkTextureObject *)
        
        Activate a texture unit for this texture
        """
        ...
    
    def DeactivateTexture(self, vtkTextureObject):
        """
        V.DeactivateTexture(vtkTextureObject)
        C++: void DeactivateTexture(vtkTextureObject *)
        
        Deactivate a previously activated texture
        """
        ...
    
    def GetBlendFuncState(self, *int):
        """
        V.GetBlendFuncState([int, ...])
        C++: void GetBlendFuncState(int *)
        """
        ...
    
    def GetDefaultTextureInternalFormat(self, p_int, p_int_1, bool, bool_1, bool_2):
        """
        V.GetDefaultTextureInternalFormat(int, int, bool, bool, bool)
            -> int
        C++: int GetDefaultTextureInternalFormat(int vtktype,
            int numComponents, bool needInteger, bool needFloat,
            bool needSRGB)
        
        Get a mapping of vtk data types to native texture formats for
        this window we put this on the RenderWindow so that every texture
        does not have to build these structures themselves
        """
        ...
    
    def GetEnumState(self, p_int):
        """
        V.GetEnumState(int) -> bool
        C++: bool GetEnumState(unsigned int name)
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetShaderCache(self):
        """
        V.GetShaderCache() -> vtkOpenGLShaderCache
        C++: virtual vtkOpenGLShaderCache *GetShaderCache()
        """
        ...
    
    def GetTextureUnitForTexture(self, vtkTextureObject):
        """
        V.GetTextureUnitForTexture(vtkTextureObject) -> int
        C++: int GetTextureUnitForTexture(vtkTextureObject *)
        
        Get the texture unit for a given texture object
        """
        ...
    
    def GetTextureUnitManager(self):
        """
        V.GetTextureUnitManager() -> vtkTextureUnitManager
        C++: vtkTextureUnitManager *GetTextureUnitManager()
        
        Returns its texture unit manager object. A new one will be
        created if one hasn't already been set up.
        """
        ...
    
    def GetVBOCache(self):
        """
        V.GetVBOCache() -> vtkOpenGLVertexBufferObjectCache
        C++: virtual vtkOpenGLVertexBufferObjectCache *GetVBOCache()
        """
        ...
    
    def Initialize(self, vtkOpenGLRenderWindow):
        """
        V.Initialize(vtkOpenGLRenderWindow)
        C++: void Initialize(vtkOpenGLRenderWindow *)
        
        Initialize OpenGL context using current state
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkOpenGLState
        C++: vtkOpenGLState *NewInstance()
        """
        ...
    
    def PopDrawFramebufferBinding(self):
        """
        V.PopDrawFramebufferBinding()
        C++: void PopDrawFramebufferBinding()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def PopFramebufferBindings(self):
        """
        V.PopFramebufferBindings()
        C++: void PopFramebufferBindings()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def PopReadFramebufferBinding(self):
        """
        V.PopReadFramebufferBinding()
        C++: void PopReadFramebufferBinding()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def PushDrawFramebufferBinding(self):
        """
        V.PushDrawFramebufferBinding()
        C++: void PushDrawFramebufferBinding()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def PushFramebufferBindings(self):
        """
        V.PushFramebufferBindings()
        C++: void PushFramebufferBindings()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def PushReadFramebufferBinding(self):
        """
        V.PushReadFramebufferBinding()
        C++: void PushReadFramebufferBinding()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def ResetEnumState(self, p_int):
        """
        V.ResetEnumState(int)
        C++: void ResetEnumState(unsigned int name)
        
        convenience method to reset an enum state from current openGL
        context
        """
        ...
    
    def ResetFramebufferBindings(self):
        """
        V.ResetFramebufferBindings()
        C++: void ResetFramebufferBindings()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        ...
    
    def ResetGLActiveTexture(self):
        """
        V.ResetGLActiveTexture()
        C++: void ResetGLActiveTexture()
        """
        ...
    
    def ResetGLBlendEquationState(self):
        """
        V.ResetGLBlendEquationState()
        C++: void ResetGLBlendEquationState()
        """
        ...
    
    def ResetGLBlendFuncState(self):
        """
        V.ResetGLBlendFuncState()
        C++: void ResetGLBlendFuncState()
        """
        ...
    
    def ResetGLClearColorState(self):
        """
        V.ResetGLClearColorState()
        C++: void ResetGLClearColorState()
        """
        ...
    
    def ResetGLClearDepthState(self):
        """
        V.ResetGLClearDepthState()
        C++: void ResetGLClearDepthState()
        """
        ...
    
    def ResetGLColorMaskState(self):
        """
        V.ResetGLColorMaskState()
        C++: void ResetGLColorMaskState()
        """
        ...
    
    def ResetGLCullFaceState(self):
        """
        V.ResetGLCullFaceState()
        C++: void ResetGLCullFaceState()
        """
        ...
    
    def ResetGLDepthFuncState(self):
        """
        V.ResetGLDepthFuncState()
        C++: void ResetGLDepthFuncState()
        """
        ...
    
    def ResetGLDepthMaskState(self):
        """
        V.ResetGLDepthMaskState()
        C++: void ResetGLDepthMaskState()
        """
        ...
    
    def ResetGLScissorState(self):
        """
        V.ResetGLScissorState()
        C++: void ResetGLScissorState()
        """
        ...
    
    def ResetGLViewportState(self):
        """
        V.ResetGLViewportState()
        C++: void ResetGLViewportState()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkOpenGLState
        C++: static vtkOpenGLState *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetEnumState(self, p_int, bool):
        """
        V.SetEnumState(int, bool)
        C++: void SetEnumState(unsigned int name, bool value)
        """
        ...
    
    def SetTextureUnitManager(self, vtkTextureUnitManager):
        """
        V.SetTextureUnitManager(vtkTextureUnitManager)
        C++: void SetTextureUnitManager(
            vtkTextureUnitManager *textureUnitManager)
        
        Set the texture unit manager.
        """
        ...
    
    def SetVBOCache(self, vtkOpenGLVertexBufferObjectCache):
        """
        V.SetVBOCache(vtkOpenGLVertexBufferObjectCache)
        C++: void SetVBOCache(vtkOpenGLVertexBufferObjectCache *val)
        """
        ...
    
    def VerifyNoActiveTextures(self):
        """
        V.VerifyNoActiveTextures()
        C++: void VerifyNoActiveTextures()
        
        Check to make sure no textures have been left active
        """
        ...
    
    def vtkBindFramebuffer(self, p_int, vtkOpenGLFramebufferObject):
        """
        V.vtkBindFramebuffer(int, vtkOpenGLFramebufferObject)
        C++: void vtkBindFramebuffer(unsigned int target,
            vtkOpenGLFramebufferObject *fo)
        """
        ...
    
    def vtkDrawBuffers(self, p_int, *int, **kwargs):
        """
        V.vtkDrawBuffers(int, [int, ...], vtkOpenGLFramebufferObject)
        C++: void vtkDrawBuffers(unsigned int n, unsigned int *,
            vtkOpenGLFramebufferObject *)
        """
        ...
    
    def vtkglActiveTexture(self, p_int):
        """
        V.vtkglActiveTexture(int)
        C++: void vtkglActiveTexture(unsigned int)
        """
        ...
    
    def vtkglBindFramebuffer(self, p_int, p_int_1):
        """
        V.vtkglBindFramebuffer(int, int)
        C++: void vtkglBindFramebuffer(unsigned int target,
            unsigned int fb)
        """
        ...
    
    def vtkglBlendEquation(self, p_int):
        """
        V.vtkglBlendEquation(int)
        C++: void vtkglBlendEquation(unsigned int val)
        """
        ...
    
    def vtkglBlendEquationSeparate(self, p_int, p_int_1):
        """
        V.vtkglBlendEquationSeparate(int, int)
        C++: void vtkglBlendEquationSeparate(unsigned int col,
            unsigned int alpha)
        """
        ...
    
    def vtkglBlendFunc(self, p_int, p_int_1):
        """
        V.vtkglBlendFunc(int, int)
        C++: void vtkglBlendFunc(unsigned int sfactor,
            unsigned int dfactor)
        """
        ...
    
    def vtkglBlendFuncSeparate(self, p_int, p_int_1, p_int_2, p_int_3):
        """
        V.vtkglBlendFuncSeparate(int, int, int, int)
        C++: void vtkglBlendFuncSeparate(unsigned int sfactorRGB,
            unsigned int dfactorRGB, unsigned int sfactorAlpha,
            unsigned int dfactorAlpha)
        """
        ...
    
    def vtkglClear(self, p_int):
        """
        V.vtkglClear(int)
        C++: void vtkglClear(unsigned int mask)
        """
        ...
    
    def vtkglClearColor(self, p_float, p_float_1, p_float_2, p_float_3):
        """
        V.vtkglClearColor(float, float, float, float)
        C++: void vtkglClearColor(float red, float green, float blue,
            float alpha)
        """
        ...
    
    def vtkglClearDepth(self, p_float):
        """
        V.vtkglClearDepth(float)
        C++: void vtkglClearDepth(double depth)
        """
        ...
    
    def vtkglColorMask(self, p_int, p_int_1, p_int_2, p_int_3):
        """
        V.vtkglColorMask(int, int, int, int)
        C++: void vtkglColorMask(unsigned char r, unsigned char g,
            unsigned char b, unsigned char a)
        """
        ...
    
    def vtkglCullFace(self, p_int):
        """
        V.vtkglCullFace(int)
        C++: void vtkglCullFace(unsigned int val)
        """
        ...
    
    def vtkglDepthFunc(self, p_int):
        """
        V.vtkglDepthFunc(int)
        C++: void vtkglDepthFunc(unsigned int val)
        """
        ...
    
    def vtkglDepthMask(self, p_int):
        """
        V.vtkglDepthMask(int)
        C++: void vtkglDepthMask(unsigned char flag)
        """
        ...
    
    def vtkglDisable(self, p_int):
        """
        V.vtkglDisable(int)
        C++: void vtkglDisable(unsigned int cap)
        """
        ...
    
    def vtkglDrawBuffer(self, p_int):
        """
        V.vtkglDrawBuffer(int)
        C++: void vtkglDrawBuffer(unsigned int)
        """
        ...
    
    def vtkglDrawBuffers(self, p_int, *int):
        """
        V.vtkglDrawBuffers(int, [int, ...])
        C++: void vtkglDrawBuffers(unsigned int n, unsigned int *)
        """
        ...
    
    def vtkglEnable(self, p_int):
        """
        V.vtkglEnable(int)
        C++: void vtkglEnable(unsigned int cap)
        """
        ...
    
    def vtkglGetBooleanv(self, p_int, *int):
        """
        V.vtkglGetBooleanv(int, [int, ...])
        C++: void vtkglGetBooleanv(unsigned int pname,
            unsigned char *params)
        """
        ...
    
    def vtkglGetDoublev(self, p_int, *float):
        """
        V.vtkglGetDoublev(int, [float, ...])
        C++: void vtkglGetDoublev(unsigned int pname, double *params)
        """
        ...
    
    def vtkglGetFloatv(self, p_int, *float):
        """
        V.vtkglGetFloatv(int, [float, ...])
        C++: void vtkglGetFloatv(unsigned int pname, float *params)
        """
        ...
    
    def vtkglGetIntegerv(self, p_int, *int):
        """
        V.vtkglGetIntegerv(int, [int, ...])
        C++: void vtkglGetIntegerv(unsigned int pname, int *params)
        """
        ...
    
    def vtkglReadBuffer(self, p_int):
        """
        V.vtkglReadBuffer(int)
        C++: void vtkglReadBuffer(unsigned int)
        """
        ...
    
    def vtkglScissor(self, p_int, p_int_1, p_int_2, p_int_3):
        """
        V.vtkglScissor(int, int, int, int)
        C++: void vtkglScissor(int x, int y, int width, int height)
        """
        ...
    
    def vtkglViewport(self, p_int, p_int_1, p_int_2, p_int_3):
        """
        V.vtkglViewport(int, int, int, int)
        C++: void vtkglViewport(int x, int y, int width, int height)
        """
        ...
    
    def vtkReadBuffer(self, p_int, vtkOpenGLFramebufferObject):
        """
        V.vtkReadBuffer(int, vtkOpenGLFramebufferObject)
        C++: void vtkReadBuffer(unsigned int,
            vtkOpenGLFramebufferObject *)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


