# 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 from .vtkOpenGLRenderPass import vtkOpenGLRenderPass class vtkDepthPeelingPass(vtkOpenGLRenderPass): """ vtkDepthPeelingPass - Implement Depth Peeling for use within a framebuffer pass Superclass: vtkOpenGLRenderPass Note that this implementation is used as a fallback for drivers that don't support floating point textures. Most renderings will use the subclass vtkDualDepthPeelingPass instead. Render the translucent polygonal geometry of a scene without sorting polygons in the view direction. This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-value and background color/gradient/transparent color. An opaque pass may have been performed right after the initialization. The depth peeling algorithm works by rendering the translucent polygonal geometry multiple times (once for each peel). The actually rendering of the translucent polygonal geometry is performed by its delegate TranslucentPass. This delegate is therefore used multiple times. Its delegate is usually set to a vtkTranslucentPass. This implementation makes use of textures and is suitable for ES3 For ES3 it must be embedded within a pass that makes use of framebuffers so that the required OpaqueZTexture and OpaqueRGBATexture can be passed from the outer framebuffer pass. For OpenGL ES3 be aware the occlusion ratio test is not supported. The maximum number of peels is used instead so set it to a reasonable value. For many scenes a value of 4 or 5 will work well. @sa vtkRenderPass, vtkTranslucentPass, vtkFramebufferPass """ def GetMaximumNumberOfPeels(self): # real signature unknown; restored from __doc__ """ GetMaximumNumberOfPeels(self) -> int C++: virtual int GetMaximumNumberOfPeels() """ return 0 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 GetOcclusionRatio(self): # real signature unknown; restored from __doc__ """ GetOcclusionRatio(self) -> float C++: virtual double GetOcclusionRatio() """ return 0.0 def GetOcclusionRatioMaxValue(self): # real signature unknown; restored from __doc__ """ GetOcclusionRatioMaxValue(self) -> float C++: virtual double GetOcclusionRatioMaxValue() """ return 0.0 def GetOcclusionRatioMinValue(self): # real signature unknown; restored from __doc__ """ GetOcclusionRatioMinValue(self) -> float C++: virtual double GetOcclusionRatioMinValue() """ return 0.0 def GetTranslucentPass(self): # real signature unknown; restored from __doc__ """ GetTranslucentPass(self) -> vtkRenderPass C++: virtual vtkRenderPass *GetTranslucentPass() Delegate for rendering the translucent polygonal geometry. If it is NULL, nothing will be rendered and a warning will be emitted. It is usually set to a vtkTranslucentPass. Initial value is a NULL pointer. """ 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) -> vtkDepthPeelingPass C++: vtkDepthPeelingPass *NewInstance() """ return vtkDepthPeelingPass def PostReplaceShaderValues(self, vertexShader, geometryShader, fragmentShader, mapper, prop): # real signature unknown; restored from __doc__ """ PostReplaceShaderValues(self, vertexShader:str, geometryShader:str, fragmentShader:str, mapper:vtkAbstractMapper, prop:vtkProp) -> bool C++: bool PostReplaceShaderValues(std::string &vertexShader, std::string &geometryShader, std::string &fragmentShader, vtkAbstractMapper *mapper, vtkProp *prop) override; """ return False def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, w:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *w) override; Release graphics resources and ask components to release their own resources. \pre w_exists: w!=0 """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkDepthPeelingPass C++: static vtkDepthPeelingPass *SafeDownCast(vtkObjectBase *o) """ return vtkDepthPeelingPass def SetDepthFormat(self, _arg): # real signature unknown; restored from __doc__ """ SetDepthFormat(self, _arg:int) -> None C++: virtual void SetDepthFormat(int _arg) Set the format to use for the depth texture e.g. vtkTextureObject::Float32 """ pass def SetMaximumNumberOfPeels(self, _arg): # real signature unknown; restored from __doc__ """ SetMaximumNumberOfPeels(self, _arg:int) -> None C++: virtual void SetMaximumNumberOfPeels(int _arg) In case of depth peeling, define the maximum number of peeling layers. Initial value is 4. A special value of 0 means no maximum limit. It has to be a positive value. """ pass def SetOcclusionRatio(self, _arg): # real signature unknown; restored from __doc__ """ SetOcclusionRatio(self, _arg:float) -> None C++: virtual void SetOcclusionRatio(double _arg) In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.0, meaning rendering have to be exact. Greater values may speed-up the rendering with small impact on the quality. """ pass def SetOpaqueRGBATexture(self, __a): # real signature unknown; restored from __doc__ """ SetOpaqueRGBATexture(self, __a:vtkTextureObject) -> None C++: void SetOpaqueRGBATexture(vtkTextureObject *) """ pass def SetOpaqueZTexture(self, __a): # real signature unknown; restored from __doc__ """ SetOpaqueZTexture(self, __a:vtkTextureObject) -> None C++: void SetOpaqueZTexture(vtkTextureObject *) """ pass def SetShaderParameters(self, program, mapper, prop, VAO, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetShaderParameters(self, program:vtkShaderProgram, mapper:vtkAbstractMapper, prop:vtkProp, VAO:vtkOpenGLVertexArrayObject=...) -> bool C++: bool SetShaderParameters(vtkShaderProgram *program, vtkAbstractMapper *mapper, vtkProp *prop, vtkOpenGLVertexArrayObject *VAO=nullptr) override; Update the uniforms of the shader program. Return false on error. """ pass def SetTranslucentPass(self, translucentPass): # real signature unknown; restored from __doc__ """ SetTranslucentPass(self, translucentPass:vtkRenderPass) -> None C++: virtual void SetTranslucentPass( vtkRenderPass *translucentPass) """ 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__\': \'vtkDepthPeelingPass\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'ReleaseGraphicsResources\': , \'GetTranslucentPass\': , \'SetTranslucentPass\': , \'SetOcclusionRatio\': , \'GetOcclusionRatioMinValue\': , \'GetOcclusionRatioMaxValue\': , \'GetOcclusionRatio\': , \'SetMaximumNumberOfPeels\': , \'GetMaximumNumberOfPeels\': , \'PostReplaceShaderValues\': , \'SetShaderParameters\': , \'SetOpaqueZTexture\': , \'SetOpaqueRGBATexture\': , \'SetDepthFormat\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkDepthPeelingPass - Implement Depth Peeling for use within a\\nframebuffer pass\\n\\nSuperclass: vtkOpenGLRenderPass\\n\\nNote that this implementation is used as a fallback for drivers that\\ndon\'t support floating point textures. Most renderings will use the\\nsubclass vtkDualDepthPeelingPass instead.\\n\\nRender the translucent polygonal geometry of a scene without sorting\\npolygons in the view direction.\\n\\nThis pass expects an initialized depth buffer and color buffer.\\nInitialized buffers means they have been cleared with farest z-value\\nand background color/gradient/transparent color. An opaque pass may\\nhave been performed right after the initialization.\\n\\nThe depth peeling algorithm works by rendering the translucent\\npolygonal geometry multiple times (once for each peel). The actually\\nrendering of the translucent polygonal geometry is performed by its\\ndelegate TranslucentPass. This delegate is therefore used multiple\\ntimes.\\n\\nIts delegate is usually set to a vtkTranslucentPass.\\n\\nThis implementation makes use of textures and is suitable for ES3 For\\nES3 it must be embedded within a pass that makes use of framebuffers\\nso that the required OpaqueZTexture and OpaqueRGBATexture can be\\npassed from the outer framebuffer pass. For OpenGL ES3 be aware the\\nocclusion ratio test is not supported. The maximum number of peels is\\nused instead so set it to a reasonable value. For many scenes a value\\nof 4 or 5 will work well.\\n\\n@sa\\nvtkRenderPass, vtkTranslucentPass, vtkFramebufferPass\\n\\n"})' __vtkname__ = 'vtkDepthPeelingPass'