# encoding: utf-8
# module vtkmodules.vtkRenderingOpenGL2
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingOpenGL2.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore
import vtkmodules.vtkRenderingHyperTreeGrid as __vtkmodules_vtkRenderingHyperTreeGrid


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, __a): # real signature unknown; restored from __doc__
        """
        ActivateTexture(self, __a:vtkTextureObject) -> None
        C++: void ActivateTexture(vtkTextureObject *)
        
        Activate a texture unit for this texture
        """
        pass

    def DeactivateTexture(self, __a): # real signature unknown; restored from __doc__
        """
        DeactivateTexture(self, __a:vtkTextureObject) -> None
        C++: void DeactivateTexture(vtkTextureObject *)
        
        Deactivate a previously activated texture
        """
        pass

    def GetBlendFuncState(self, __a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetBlendFuncState(self, __a:[int, ...]) -> None
        C++: void GetBlendFuncState(int *)
        """
        pass

    def GetCurrentDrawFramebufferState(self, drawBinding, drawBuffer): # real signature unknown; restored from __doc__
        """
        GetCurrentDrawFramebufferState(self, drawBinding:int,
            drawBuffer:int) -> None
        C++: void GetCurrentDrawFramebufferState(
            unsigned int &drawBinding, unsigned int &drawBuffer)
        
        Get the current stored state of the draw buffer and binding
        """
        pass

    def GetDefaultTextureInternalFormat(self, vtktype, numComponents, needInteger, needFloat, needSRGB): # real signature unknown; restored from __doc__
        """
        GetDefaultTextureInternalFormat(self, vtktype:int,
            numComponents:int, needInteger:bool, needFloat:bool,
            needSRGB: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
        """
        return 0

    def GetEnumState(self, name): # real signature unknown; restored from __doc__
        """
        GetEnumState(self, name:int) -> bool
        C++: bool GetEnumState(unsigned int name)
        """
        return False

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetRenderer(self): # real signature unknown; restored from __doc__
        """
        GetRenderer(self) -> str
        C++: std::string const &GetRenderer()
        
        Return the opengl renderer for this context. Note this is the
        renderer opengl property, not a vtk renderer.
        """
        return ""

    def GetShaderCache(self): # real signature unknown; restored from __doc__
        """
        GetShaderCache(self) -> vtkOpenGLShaderCache
        C++: virtual vtkOpenGLShaderCache *GetShaderCache()
        """
        return vtkOpenGLShaderCache

    def GetTextureUnitForTexture(self, __a): # real signature unknown; restored from __doc__
        """
        GetTextureUnitForTexture(self, __a:vtkTextureObject) -> int
        C++: int GetTextureUnitForTexture(vtkTextureObject *)
        
        Get the texture unit for a given texture object
        """
        return 0

    def GetTextureUnitManager(self): # real signature unknown; restored from __doc__
        """
        GetTextureUnitManager(self) -> vtkTextureUnitManager
        C++: vtkTextureUnitManager *GetTextureUnitManager()
        
        Returns its texture unit manager object. A new one will be
        created if one hasn't already been set up.
        """
        return vtkTextureUnitManager

    def GetVBOCache(self): # real signature unknown; restored from __doc__
        """
        GetVBOCache(self) -> vtkOpenGLVertexBufferObjectCache
        C++: virtual vtkOpenGLVertexBufferObjectCache *GetVBOCache()
        """
        return vtkOpenGLVertexBufferObjectCache

    def GetVendor(self): # real signature unknown; restored from __doc__
        """
        GetVendor(self) -> str
        C++: std::string const &GetVendor()
        
        Return the opengl vendor for this context
        """
        return ""

    def GetVersion(self): # real signature unknown; restored from __doc__
        """
        GetVersion(self) -> str
        C++: std::string const &GetVersion()
        
        Return the opengl version for this context
        """
        return ""

    def Initialize(self, __a): # real signature unknown; restored from __doc__
        """
        Initialize(self, __a:vtkOpenGLRenderWindow) -> None
        C++: void Initialize(vtkOpenGLRenderWindow *)
        
        Initialize OpenGL context using current state
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkOpenGLState
        C++: vtkOpenGLState *NewInstance()
        """
        return vtkOpenGLState

    def Pop(self): # real signature unknown; restored from __doc__
        """
        Pop(self) -> None
        C++: void Pop()
        
        Pop the state stack to restore a previous state. At the end of
        this method OpenGL state will be set to the new popped state.
        """
        pass

    def PopDrawFramebufferBinding(self): # real signature unknown; restored from __doc__
        """
        PopDrawFramebufferBinding(self) -> None
        C++: void PopDrawFramebufferBinding()
        """
        pass

    def PopFramebufferBindings(self): # real signature unknown; restored from __doc__
        """
        PopFramebufferBindings(self) -> None
        C++: void PopFramebufferBindings()
        """
        pass

    def PopReadFramebufferBinding(self): # real signature unknown; restored from __doc__
        """
        PopReadFramebufferBinding(self) -> None
        C++: void PopReadFramebufferBinding()
        """
        pass

    def Push(self): # real signature unknown; restored from __doc__
        """
        Push(self) -> None
        C++: void Push()
        
        Push all the recorded state onto the stack. Typically called
        after a Reset. Not generally used internally in VTK as it is
        rarely required to save more than a couple state settings within
        VTKs render process.
        """
        pass

    def PushDrawFramebufferBinding(self): # real signature unknown; restored from __doc__
        """
        PushDrawFramebufferBinding(self) -> None
        C++: void PushDrawFramebufferBinding()
        """
        pass

    def PushFramebufferBindings(self): # real signature unknown; restored from __doc__
        """
        PushFramebufferBindings(self) -> None
        C++: void PushFramebufferBindings()
        
        Store/Restore the current framebuffer bindings and buffers.
        """
        pass

    def PushReadFramebufferBinding(self): # real signature unknown; restored from __doc__
        """
        PushReadFramebufferBinding(self) -> None
        C++: void PushReadFramebufferBinding()
        """
        pass

    def Reset(self): # real signature unknown; restored from __doc__
        """
        Reset(self) -> None
        C++: void Reset()
        
        Record the OpenGL state into this class. Lots of get calls so
        probably a pipeline stall. This method is most useful when
        integrating VTK with something else that touches OpenGL such as a
        GUI library or external OpenGL code. As OpenGL has a lot of state
        it is easy for VTK and external libraries to interfere with each
        other by changing that state. When extrnal code is calling VTK
        you would typically call Reset() Push() Pop() Reset will record
        the current state from OpenGL. Push saves it on the stack. Pop
        pops it from the stack and reapplies it to OpenGL so that the
        state is the same as when Pushed. Note that OpenGL has an
        incredible amount of state. This class only handles the values
        that VTK is known to touch. If you find other values that need
        saving please feel free to report an issue or provide an MR.
        """
        pass

    def ResetEnumState(self, name): # real signature unknown; restored from __doc__
        """
        ResetEnumState(self, name:int) -> None
        C++: void ResetEnumState(unsigned int name)
        
        convenience method to reset an enum state from current openGL
        context
        """
        pass

    def ResetFramebufferBindings(self): # real signature unknown; restored from __doc__
        """
        ResetFramebufferBindings(self) -> None
        C++: void ResetFramebufferBindings()
        """
        pass

    def ResetGLActiveTexture(self): # real signature unknown; restored from __doc__
        """
        ResetGLActiveTexture(self) -> None
        C++: void ResetGLActiveTexture()
        """
        pass

    def ResetGLBlendEquationState(self): # real signature unknown; restored from __doc__
        """
        ResetGLBlendEquationState(self) -> None
        C++: void ResetGLBlendEquationState()
        """
        pass

    def ResetGLBlendFuncState(self): # real signature unknown; restored from __doc__
        """
        ResetGLBlendFuncState(self) -> None
        C++: void ResetGLBlendFuncState()
        """
        pass

    def ResetGLClearColorState(self): # real signature unknown; restored from __doc__
        """
        ResetGLClearColorState(self) -> None
        C++: void ResetGLClearColorState()
        """
        pass

    def ResetGLClearDepthState(self): # real signature unknown; restored from __doc__
        """
        ResetGLClearDepthState(self) -> None
        C++: void ResetGLClearDepthState()
        """
        pass

    def ResetGLColorMaskState(self): # real signature unknown; restored from __doc__
        """
        ResetGLColorMaskState(self) -> None
        C++: void ResetGLColorMaskState()
        """
        pass

    def ResetGLCullFaceState(self): # real signature unknown; restored from __doc__
        """
        ResetGLCullFaceState(self) -> None
        C++: void ResetGLCullFaceState()
        """
        pass

    def ResetGLDepthFuncState(self): # real signature unknown; restored from __doc__
        """
        ResetGLDepthFuncState(self) -> None
        C++: void ResetGLDepthFuncState()
        """
        pass

    def ResetGLDepthMaskState(self): # real signature unknown; restored from __doc__
        """
        ResetGLDepthMaskState(self) -> None
        C++: void ResetGLDepthMaskState()
        """
        pass

    def ResetGLScissorState(self): # real signature unknown; restored from __doc__
        """
        ResetGLScissorState(self) -> None
        C++: void ResetGLScissorState()
        """
        pass

    def ResetGLViewportState(self): # real signature unknown; restored from __doc__
        """
        ResetGLViewportState(self) -> None
        C++: void ResetGLViewportState()
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkOpenGLState
        C++: static vtkOpenGLState *SafeDownCast(vtkObjectBase *o)
        """
        return vtkOpenGLState

    def SetEnumState(self, name, value): # real signature unknown; restored from __doc__
        """
        SetEnumState(self, name:int, value:bool) -> None
        C++: void SetEnumState(unsigned int name, bool value)
        """
        pass

    def SetTextureUnitManager(self, textureUnitManager): # real signature unknown; restored from __doc__
        """
        SetTextureUnitManager(self,
            textureUnitManager:vtkTextureUnitManager) -> None
        C++: void SetTextureUnitManager(
            vtkTextureUnitManager *textureUnitManager)
        
        Set the texture unit manager.
        """
        pass

    def SetVBOCache(self, val): # real signature unknown; restored from __doc__
        """
        SetVBOCache(self, val:vtkOpenGLVertexBufferObjectCache) -> None
        C++: void SetVBOCache(vtkOpenGLVertexBufferObjectCache *val)
        """
        pass

    def VerifyNoActiveTextures(self): # real signature unknown; restored from __doc__
        """
        VerifyNoActiveTextures(self) -> None
        C++: void VerifyNoActiveTextures()
        
        Check to make sure no textures have been left active
        """
        pass

    def vtkBindFramebuffer(self, target, fo): # real signature unknown; restored from __doc__
        """
        vtkBindFramebuffer(self, target:int,
            fo:vtkOpenGLFramebufferObject) -> None
        C++: void vtkBindFramebuffer(unsigned int target,
            vtkOpenGLFramebufferObject *fo)
        """
        pass

    def vtkDrawBuffers(self, n, __b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkDrawBuffers(self, n:int, __b:[int, ...],
            __c:vtkOpenGLFramebufferObject) -> None
        C++: void vtkDrawBuffers(unsigned int n, unsigned int *,
            vtkOpenGLFramebufferObject *)
        """
        pass

    def vtkglActiveTexture(self, __a): # real signature unknown; restored from __doc__
        """
        vtkglActiveTexture(self, __a:int) -> None
        C++: void vtkglActiveTexture(unsigned int)
        """
        pass

    def vtkglBindFramebuffer(self, target, fb): # real signature unknown; restored from __doc__
        """
        vtkglBindFramebuffer(self, target:int, fb:int) -> None
        C++: void vtkglBindFramebuffer(unsigned int target,
            unsigned int fb)
        """
        pass

    def vtkglBlendEquation(self, val): # real signature unknown; restored from __doc__
        """
        vtkglBlendEquation(self, val:int) -> None
        C++: void vtkglBlendEquation(unsigned int val)
        """
        pass

    def vtkglBlendEquationSeparate(self, col, alpha): # real signature unknown; restored from __doc__
        """
        vtkglBlendEquationSeparate(self, col:int, alpha:int) -> None
        C++: void vtkglBlendEquationSeparate(unsigned int col,
            unsigned int alpha)
        """
        pass

    def vtkglBlendFunc(self, sfactor, dfactor): # real signature unknown; restored from __doc__
        """
        vtkglBlendFunc(self, sfactor:int, dfactor:int) -> None
        C++: void vtkglBlendFunc(unsigned int sfactor,
            unsigned int dfactor)
        """
        pass

    def vtkglBlendFuncSeparate(self, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha): # real signature unknown; restored from __doc__
        """
        vtkglBlendFuncSeparate(self, sfactorRGB:int, dfactorRGB:int,
            sfactorAlpha:int, dfactorAlpha:int) -> None
        C++: void vtkglBlendFuncSeparate(unsigned int sfactorRGB,
            unsigned int dfactorRGB, unsigned int sfactorAlpha,
            unsigned int dfactorAlpha)
        """
        pass

    def vtkglBlitFramebuffer(self, __a, __b, __c, __d, __e, __f, __g, __h, __i, __j): # real signature unknown; restored from __doc__
        """
        vtkglBlitFramebuffer(self, __a:int, __b:int, __c:int, __d:int,
            __e:int, __f:int, __g:int, __h:int, __i:int, __j:int) -> None
        C++: void vtkglBlitFramebuffer(int, int, int, int, int, int, int,
            int, unsigned int, unsigned int)
        
        Perform a blit but handle some driver bugs safely. Use this
        instead of directly calling glBlitFramebuffer.
        """
        pass

    def vtkglClear(self, mask): # real signature unknown; restored from __doc__
        """
        vtkglClear(self, mask:int) -> None
        C++: void vtkglClear(unsigned int mask)
        """
        pass

    def vtkglClearColor(self, red, green, blue, alpha): # real signature unknown; restored from __doc__
        """
        vtkglClearColor(self, red:float, green:float, blue:float,
            alpha:float) -> None
        C++: void vtkglClearColor(float red, float green, float blue,
            float alpha)
        """
        pass

    def vtkglClearDepth(self, depth): # real signature unknown; restored from __doc__
        """
        vtkglClearDepth(self, depth:float) -> None
        C++: void vtkglClearDepth(double depth)
        """
        pass

    def vtkglColorMask(self, r, g, b, a): # real signature unknown; restored from __doc__
        """
        vtkglColorMask(self, r:int, g:int, b:int, a:int) -> None
        C++: void vtkglColorMask(unsigned char r, unsigned char g,
            unsigned char b, unsigned char a)
        """
        pass

    def vtkglCullFace(self, val): # real signature unknown; restored from __doc__
        """
        vtkglCullFace(self, val:int) -> None
        C++: void vtkglCullFace(unsigned int val)
        """
        pass

    def vtkglDepthFunc(self, val): # real signature unknown; restored from __doc__
        """
        vtkglDepthFunc(self, val:int) -> None
        C++: void vtkglDepthFunc(unsigned int val)
        """
        pass

    def vtkglDepthMask(self, flag): # real signature unknown; restored from __doc__
        """
        vtkglDepthMask(self, flag:int) -> None
        C++: void vtkglDepthMask(unsigned char flag)
        """
        pass

    def vtkglDisable(self, cap): # real signature unknown; restored from __doc__
        """
        vtkglDisable(self, cap:int) -> None
        C++: void vtkglDisable(unsigned int cap)
        """
        pass

    def vtkglDrawBuffer(self, __a): # real signature unknown; restored from __doc__
        """
        vtkglDrawBuffer(self, __a:int) -> None
        C++: void vtkglDrawBuffer(unsigned int)
        """
        pass

    def vtkglDrawBuffers(self, n, __b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkglDrawBuffers(self, n:int, __b:[int, ...]) -> None
        C++: void vtkglDrawBuffers(unsigned int n, unsigned int *)
        """
        pass

    def vtkglEnable(self, cap): # real signature unknown; restored from __doc__
        """
        vtkglEnable(self, cap:int) -> None
        C++: void vtkglEnable(unsigned int cap)
        """
        pass

    def vtkglGetBooleanv(self, pname, params, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkglGetBooleanv(self, pname:int, params:[int, ...]) -> None
        C++: void vtkglGetBooleanv(unsigned int pname,
            unsigned char *params)
        """
        pass

    def vtkglGetDoublev(self, pname, params, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkglGetDoublev(self, pname:int, params:[float, ...]) -> None
        C++: void vtkglGetDoublev(unsigned int pname, double *params)
        """
        pass

    def vtkglGetFloatv(self, pname, params, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkglGetFloatv(self, pname:int, params:[float, ...]) -> None
        C++: void vtkglGetFloatv(unsigned int pname, float *params)
        """
        pass

    def vtkglGetIntegerv(self, pname, params, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        vtkglGetIntegerv(self, pname:int, params:[int, ...]) -> None
        C++: void vtkglGetIntegerv(unsigned int pname, int *params)
        """
        pass

    def vtkglLineWidth(self, __a): # real signature unknown; restored from __doc__
        """
        vtkglLineWidth(self, __a:float) -> None
        C++: void vtkglLineWidth(float)
        """
        pass

    def vtkglPixelStorei(self, __a, __b): # real signature unknown; restored from __doc__
        """
        vtkglPixelStorei(self, __a:int, __b:int) -> None
        C++: void vtkglPixelStorei(unsigned int, int)
        """
        pass

    def vtkglPointSize(self, __a): # real signature unknown; restored from __doc__
        """
        vtkglPointSize(self, __a:float) -> None
        C++: void vtkglPointSize(float)
        """
        pass

    def vtkglReadBuffer(self, __a): # real signature unknown; restored from __doc__
        """
        vtkglReadBuffer(self, __a:int) -> None
        C++: void vtkglReadBuffer(unsigned int)
        """
        pass

    def vtkglScissor(self, x, y, width, height): # real signature unknown; restored from __doc__
        """
        vtkglScissor(self, x:int, y:int, width:int, height:int) -> None
        C++: void vtkglScissor(int x, int y, int width, int height)
        """
        pass

    def vtkglStencilFunc(self, func, ref, mask): # real signature unknown; restored from __doc__
        """
        vtkglStencilFunc(self, func:int, ref:int, mask:int) -> None
        C++: void vtkglStencilFunc(unsigned int func, int ref,
            unsigned int mask)
        """
        pass

    def vtkglStencilFuncSeparate(self, face, func, ref, mask): # real signature unknown; restored from __doc__
        """
        vtkglStencilFuncSeparate(self, face:int, func:int, ref:int,
            mask:int) -> None
        C++: void vtkglStencilFuncSeparate(unsigned int face,
            unsigned int func, int ref, unsigned int mask)
        """
        pass

    def vtkglStencilMask(self, mask): # real signature unknown; restored from __doc__
        """
        vtkglStencilMask(self, mask:int) -> None
        C++: void vtkglStencilMask(unsigned int mask)
        """
        pass

    def vtkglStencilMaskSeparate(self, face, mask): # real signature unknown; restored from __doc__
        """
        vtkglStencilMaskSeparate(self, face:int, mask:int) -> None
        C++: void vtkglStencilMaskSeparate(unsigned int face,
            unsigned int mask)
        """
        pass

    def vtkglStencilOp(self, sfail, dpfail, dppass): # real signature unknown; restored from __doc__
        """
        vtkglStencilOp(self, sfail:int, dpfail:int, dppass:int) -> None
        C++: void vtkglStencilOp(unsigned int sfail, unsigned int dpfail,
            unsigned int dppass)
        """
        pass

    def vtkglStencilOpSeparate(self, face, sfail, dpfail, dppass): # real signature unknown; restored from __doc__
        """
        vtkglStencilOpSeparate(self, face:int, sfail:int, dpfail:int,
            dppass:int) -> None
        C++: void vtkglStencilOpSeparate(unsigned int face,
            unsigned int sfail, unsigned int dpfail, unsigned int dppass)
        """
        pass

    def vtkglViewport(self, x, y, width, height): # real signature unknown; restored from __doc__
        """
        vtkglViewport(self, x:int, y:int, width:int, height:int) -> None
        C++: void vtkglViewport(int x, int y, int width, int height)
        """
        pass

    def vtkReadBuffer(self, __a, __b): # real signature unknown; restored from __doc__
        """
        vtkReadBuffer(self, __a:int, __b:vtkOpenGLFramebufferObject)
            -> None
        C++: void vtkReadBuffer(unsigned int,
            vtkOpenGLFramebufferObject *)
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkOpenGLState', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglClearColor': <method 'vtkglClearColor' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglClearDepth': <method 'vtkglClearDepth' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglDepthFunc': <method 'vtkglDepthFunc' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglDepthMask': <method 'vtkglDepthMask' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglColorMask': <method 'vtkglColorMask' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglViewport': <method 'vtkglViewport' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglScissor': <method 'vtkglScissor' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglEnable': <method 'vtkglEnable' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglDisable': <method 'vtkglDisable' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBlendFunc': <method 'vtkglBlendFunc' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBlendFuncSeparate': <method 'vtkglBlendFuncSeparate' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBlendEquation': <method 'vtkglBlendEquation' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBlendEquationSeparate': <method 'vtkglBlendEquationSeparate' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglCullFace': <method 'vtkglCullFace' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglActiveTexture': <method 'vtkglActiveTexture' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBindFramebuffer': <method 'vtkglBindFramebuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglDrawBuffer': <method 'vtkglDrawBuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglDrawBuffers': <method 'vtkglDrawBuffers' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglReadBuffer': <method 'vtkglReadBuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglPointSize': <method 'vtkglPointSize' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglLineWidth': <method 'vtkglLineWidth' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilMaskSeparate': <method 'vtkglStencilMaskSeparate' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilMask': <method 'vtkglStencilMask' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilOpSeparate': <method 'vtkglStencilOpSeparate' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilOp': <method 'vtkglStencilOp' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilFuncSeparate': <method 'vtkglStencilFuncSeparate' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglStencilFunc': <method 'vtkglStencilFunc' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkBindFramebuffer': <method 'vtkBindFramebuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkDrawBuffers': <method 'vtkDrawBuffers' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkReadBuffer': <method 'vtkReadBuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglPixelStorei': <method 'vtkglPixelStorei' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLClearColorState': <method 'ResetGLClearColorState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLClearDepthState': <method 'ResetGLClearDepthState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLDepthFuncState': <method 'ResetGLDepthFuncState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLDepthMaskState': <method 'ResetGLDepthMaskState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLColorMaskState': <method 'ResetGLColorMaskState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLViewportState': <method 'ResetGLViewportState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLScissorState': <method 'ResetGLScissorState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLBlendFuncState': <method 'ResetGLBlendFuncState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLBlendEquationState': <method 'ResetGLBlendEquationState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLCullFaceState': <method 'ResetGLCullFaceState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetGLActiveTexture': <method 'ResetGLActiveTexture' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglClear': <method 'vtkglClear' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglGetBooleanv': <method 'vtkglGetBooleanv' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglGetIntegerv': <method 'vtkglGetIntegerv' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglGetDoublev': <method 'vtkglGetDoublev' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglGetFloatv': <method 'vtkglGetFloatv' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetBlendFuncState': <method 'GetBlendFuncState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetEnumState': <method 'GetEnumState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'SetEnumState': <method 'SetEnumState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetEnumState': <method 'ResetEnumState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ActivateTexture': <method 'ActivateTexture' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'DeactivateTexture': <method 'DeactivateTexture' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetTextureUnitForTexture': <method 'GetTextureUnitForTexture' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'VerifyNoActiveTextures': <method 'VerifyNoActiveTextures' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PushFramebufferBindings': <method 'PushFramebufferBindings' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PushDrawFramebufferBinding': <method 'PushDrawFramebufferBinding' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PushReadFramebufferBinding': <method 'PushReadFramebufferBinding' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PopFramebufferBindings': <method 'PopFramebufferBindings' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PopDrawFramebufferBinding': <method 'PopDrawFramebufferBinding' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'PopReadFramebufferBinding': <method 'PopReadFramebufferBinding' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'ResetFramebufferBindings': <method 'ResetFramebufferBindings' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'Initialize': <method 'Initialize' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'SetTextureUnitManager': <method 'SetTextureUnitManager' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetTextureUnitManager': <method 'GetTextureUnitManager' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetShaderCache': <method 'GetShaderCache' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetVBOCache': <method 'GetVBOCache' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'SetVBOCache': <method 'SetVBOCache' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetDefaultTextureInternalFormat': <method 'GetDefaultTextureInternalFormat' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetCurrentDrawFramebufferState': <method 'GetCurrentDrawFramebufferState' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'vtkglBlitFramebuffer': <method 'vtkglBlitFramebuffer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'Reset': <method 'Reset' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'Push': <method 'Push' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'Pop': <method 'Pop' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetVersion': <method 'GetVersion' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetVendor': <method 'GetVendor' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, 'GetRenderer': <method 'GetRenderer' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF8205FD380>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkRenderingOpenGL2.vtkOpenGLState' objects>, '__doc__': 'vtkOpenGLState - OpenGL state storage\\n\\nSuperclass: vtkObject\\n\\nvtkOpenGLState is a class designed to keep track of the state of an\\nOpenGL context. Applications using VTK have so much control over the\\nrendering process that is can be difficult in VTK code to know if the\\nOpenGL state is correct for your code. The two traditional solutions\\nhave been to set everything yourself and to save and restore OpenGL\\nstate that you change. The former makes your code work, the latter\\nhelps prevent your code from breaking something else. The problem is\\nthat the former results in tons of redundant OpenGL calls and the\\nlater is done by querying the OpenGL state which can cause a pipeline\\nsync/stall which is very slow.\\n\\nTo address these issues this class stores OpenGL state for commonly\\nused functions. Requests made to change state to the current state\\nbecome no-ops. Queries of state can be done by querying the state\\nstored in this class without impacting the OpenGL driver.\\n\\nThis class is designed to hold all context related values and could\\njust as well be considered a representation of the OpenGL context.\\n\\nTo facilitate saving state and restoring it this class contains a\\nnumber of nested classes named Scopedthat store the state of that\\nglFunction and when they go out of scope they restore it. This is\\nuseful when you want to change the OpenGL state and then\\nautomatically restore it when done. They can be used as follows\\n\\n{\\n  vtkOpenGLState *ostate = renWin->GetState();\\n  vtkOpenGLState::ScopedglDepthMask dmsaved(ostate);\\n  // the prior state is now saved\\n  ...\\n  ostate->glDepthMask(GL_TRUE);  // maybe change the state\\n  ... etc } // prior state will be restored here as it goes out of\\nscope\\n\\nYou must use this class to make state changing OpenGL class otherwise\\nthe results will be undefined.\\n\\nFor convenience some OpenGL calls that do not impact state are also\\nprovided.\\n\\n'})"
    __vtkname__ = 'vtkOpenGLState'