# 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 vtkOpenGLRenderWindow(__vtkmodules_vtkRenderingCore.vtkRenderWindow): """ vtkOpenGLRenderWindow - OpenGL rendering window Superclass: vtkRenderWindow vtkOpenGLRenderWindow is a concrete implementation of the abstract class vtkRenderWindow. vtkOpenGLRenderer interfaces to the OpenGL graphics library. Application programmers should normally use vtkRenderWindow instead of the OpenGL specific version. """ 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 BlitDisplayFramebuffer(self): # real signature unknown; restored from __doc__ """ BlitDisplayFramebuffer(self) -> None C++: void BlitDisplayFramebuffer() BlitDisplayFramebuffer(self, right:int, srcX:int, srcY:int, srcWidth:int, srcHeight:int, destX:int, destY:int, destWidth:int, destHeight:int, bufferMode:int, interpolation:int) -> None C++: void BlitDisplayFramebuffer(int right, int srcX, int srcY, int srcWidth, int srcHeight, int destX, int destY, int destWidth, int destHeight, int bufferMode, int interpolation) Blit a display framebuffer into a currently bound draw destination """ pass def BlitToRenderFramebuffer(self, includeDepth): # real signature unknown; restored from __doc__ """ BlitToRenderFramebuffer(self, includeDepth:bool) -> None C++: void BlitToRenderFramebuffer(bool includeDepth) BlitToRenderFramebuffer(self, srcX:int, srcY:int, srcWidth:int, srcHeight:int, destX:int, destY:int, destWidth:int, destHeight:int, bufferMode:int, interpolation:int) -> None C++: void BlitToRenderFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int destX, int destY, int destWidth, int destHeight, int bufferMode, int interpolation) Blit the currently bound read buffer to the renderbuffer. This is useful for taking rendering from an external system and then having VTK draw on top of it. """ 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 DrawPixels(self, x1, y1, x2, y2, numComponents, dataType, data): # real signature unknown; restored from __doc__ """ DrawPixels(self, x1:int, y1:int, x2:int, y2:int, numComponents:int, dataType:int, data:Pointer) -> None C++: virtual void DrawPixels(int x1, int y1, int x2, int y2, int numComponents, int dataType, void *data) DrawPixels(self, dstXmin:int, dstYmin:int, dstXmax:int, dstYmax:int, srcXmin:int, srcYmin:int, srcXmax:int, srcYmax:int, srcWidth:int, srcHeight:int, numComponents:int, dataType:int, data:Pointer) -> None C++: 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) DrawPixels(self, srcWidth:int, srcHeight:int, numComponents:int, dataType:int, data:Pointer) -> None C++: virtual void DrawPixels(int srcWidth, int srcHeight, int numComponents, int dataType, void *data) Replacement for the old glDrawPixels function """ pass def End(self): # real signature unknown; restored from __doc__ """ End(self) -> None C++: void End() override; Update the system, if needed, at end of render process """ pass def Frame(self): # real signature unknown; restored from __doc__ """ Frame(self) -> None C++: void Frame() override; A termination method performed at the end of the rendering process to do things like swapping buffers (if necessary) or similar actions. """ pass def FramebufferFlipYOff(self): # real signature unknown; restored from __doc__ """ FramebufferFlipYOff(self) -> None C++: virtual void FramebufferFlipYOff() """ pass def FramebufferFlipYOn(self): # real signature unknown; restored from __doc__ """ FramebufferFlipYOn(self) -> None C++: virtual void FramebufferFlipYOn() """ pass def GetBackBuffer(self): # real signature unknown; restored from __doc__ """ GetBackBuffer(self) -> int C++: unsigned int GetBackBuffer() """ return 0 def GetBackLeftBuffer(self): # real signature unknown; restored from __doc__ """ GetBackLeftBuffer(self) -> int C++: unsigned int GetBackLeftBuffer() """ return 0 def GetBackRightBuffer(self): # real signature unknown; restored from __doc__ """ GetBackRightBuffer(self) -> int C++: unsigned int GetBackRightBuffer() """ return 0 def GetBufferNeedsResolving(self): # real signature unknown; restored from __doc__ """ GetBufferNeedsResolving(self) -> bool C++: bool GetBufferNeedsResolving() """ return False def GetColorBufferInternalFormat(self, attachmentPoint): # real signature unknown; restored from __doc__ """ GetColorBufferInternalFormat(self, attachmentPoint:int) -> int C++: int GetColorBufferInternalFormat(int attachmentPoint) Get the internal format of current attached texture or render buffer. attachmentPoint is the index of attachment. Returns 0 if not able to determine. """ return 0 def GetColorBufferSizes(self, rgba, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetColorBufferSizes(self, rgba:[int, ...]) -> int C++: int GetColorBufferSizes(int *rgba) override; Get the size of the color buffer. Returns 0 if not able to determine otherwise sets R G B and A into buffer. """ pass def GetContextCreationTime(self): # real signature unknown; restored from __doc__ """ GetContextCreationTime(self) -> int C++: virtual vtkMTimeType GetContextCreationTime() Get the time when the OpenGL context was created. """ return 0 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 GetDepthBufferSize(self): # real signature unknown; restored from __doc__ """ GetDepthBufferSize(self) -> int C++: int GetDepthBufferSize() override; Get the size of the depth buffer. """ return 0 def GetDisplayFramebuffer(self): # real signature unknown; restored from __doc__ """ GetDisplayFramebuffer(self) -> vtkOpenGLFramebufferObject C++: virtual vtkOpenGLFramebufferObject *GetDisplayFramebuffer() Returns the display framebuffer object. """ return vtkOpenGLFramebufferObject def GetFrameBlitMode(self): # real signature unknown; restored from __doc__ """ GetFrameBlitMode(self) -> FrameBlitModes C++: virtual FrameBlitModes GetFrameBlitMode() """ pass def GetFrameBlitModeMaxValue(self): # real signature unknown; restored from __doc__ """ GetFrameBlitModeMaxValue(self) -> FrameBlitModes C++: virtual FrameBlitModes GetFrameBlitModeMaxValue() """ pass def GetFrameBlitModeMinValue(self): # real signature unknown; restored from __doc__ """ GetFrameBlitModeMinValue(self) -> FrameBlitModes C++: virtual FrameBlitModes GetFrameBlitModeMinValue() """ pass def GetFramebufferFlipY(self): # real signature unknown; restored from __doc__ """ GetFramebufferFlipY(self) -> bool C++: virtual bool GetFramebufferFlipY() """ return False def GetFrontBuffer(self): # real signature unknown; restored from __doc__ """ GetFrontBuffer(self) -> int C++: unsigned int GetFrontBuffer() """ return 0 def GetFrontLeftBuffer(self): # real signature unknown; restored from __doc__ """ GetFrontLeftBuffer(self) -> int C++: unsigned int GetFrontLeftBuffer() """ return 0 def GetFrontRightBuffer(self): # real signature unknown; restored from __doc__ """ GetFrontRightBuffer(self) -> int C++: unsigned int GetFrontRightBuffer() """ return 0 def GetGlobalMaximumNumberOfMultiSamples(self): # real signature unknown; restored from __doc__ """ GetGlobalMaximumNumberOfMultiSamples() -> int C++: static int GetGlobalMaximumNumberOfMultiSamples() """ return 0 def GetMaximumHardwareLineWidth(self): # real signature unknown; restored from __doc__ """ GetMaximumHardwareLineWidth(self) -> float C++: virtual float GetMaximumHardwareLineWidth() Return the largest line width supported by the hardware """ return 0.0 def GetNoiseTextureUnit(self): # real signature unknown; restored from __doc__ """ GetNoiseTextureUnit(self) -> int C++: int GetNoiseTextureUnit() """ 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 GetOffScreenFramebuffer(self): # real signature unknown; restored from __doc__ """ GetOffScreenFramebuffer(self) -> vtkOpenGLFramebufferObject C++: vtkOpenGLFramebufferObject *GetOffScreenFramebuffer() """ return vtkOpenGLFramebufferObject def GetOpenGLSupportMessage(self): # real signature unknown; restored from __doc__ """ GetOpenGLSupportMessage(self) -> str C++: std::string GetOpenGLSupportMessage() Return a message profiding additional details about the results of calling SupportsOpenGL() This can be used to retrieve more specifics about what failed """ return "" def GetOpenGLVersion(self, major, minor): # real signature unknown; restored from __doc__ """ GetOpenGLVersion(self, major:int, minor:int) -> None C++: void GetOpenGLVersion(int &major, int &minor) Get the major and minor version numbers of the OpenGL context we are using ala 3.2, 3.3, 4.0, etc... returns 0,0 if opengl has not been initialized yet """ pass def GetPixelData(self, x, y, x2, y2, front, right): # real signature unknown; restored from __doc__ """ GetPixelData(self, x:int, y:int, x2:int, y2:int, front:int, right:int) -> Pointer C++: unsigned char *GetPixelData(int x, int y, int x2, int y2, int front, int right) override; GetPixelData(self, x:int, y:int, x2:int, y2:int, front:int, data:vtkUnsignedCharArray, right:int) -> int C++: int GetPixelData(int x, int y, int x2, int y2, int front, vtkUnsignedCharArray *data, int right) override; Set/Get the pixel data of an image, transmitted as RGBRGB... front in this context indicates that the read should come from the display buffer versus the render buffer """ pass def GetRenderFramebuffer(self): # real signature unknown; restored from __doc__ """ GetRenderFramebuffer(self) -> vtkOpenGLFramebufferObject C++: virtual vtkOpenGLFramebufferObject *GetRenderFramebuffer() Returns the render framebuffer object. """ return vtkOpenGLFramebufferObject def GetRenderingBackend(self): # real signature unknown; restored from __doc__ """ GetRenderingBackend(self) -> str C++: const char *GetRenderingBackend() override; What rendering backend has the user requested """ return "" def GetRGBACharPixelData(self, x, y, x2, y2, front, right=0): # real signature unknown; restored from __doc__ """ GetRGBACharPixelData(self, x:int, y:int, x2:int, y2:int, front:int, right:int=0) -> Pointer C++: unsigned char *GetRGBACharPixelData(int x, int y, int x2, int y2, int front, int right=0) override; GetRGBACharPixelData(self, x:int, y:int, x2:int, y2:int, front:int, data:vtkUnsignedCharArray, right:int=0) -> int C++: int GetRGBACharPixelData(int x, int y, int x2, int y2, int front, vtkUnsignedCharArray *data, int right=0) override; """ pass def GetRGBAPixelData(self, x, y, x2, y2, front, right=0): # real signature unknown; restored from __doc__ """ GetRGBAPixelData(self, x:int, y:int, x2:int, y2:int, front:int, right:int=0) -> Pointer C++: float *GetRGBAPixelData(int x, int y, int x2, int y2, int front, int right=0) override; GetRGBAPixelData(self, x:int, y:int, x2:int, y2:int, front:int, data:vtkFloatArray, right:int=0) -> int C++: int GetRGBAPixelData(int x, int y, int x2, int y2, int front, vtkFloatArray *data, int right=0) override; Set/Get the pixel data of an image, transmitted as RGBARGBA... """ pass def GetShaderCache(self): # real signature unknown; restored from __doc__ """ GetShaderCache(self) -> vtkOpenGLShaderCache C++: vtkOpenGLShaderCache *GetShaderCache() Returns an Shader Cache object """ return vtkOpenGLShaderCache def GetState(self): # real signature unknown; restored from __doc__ """ GetState(self) -> vtkOpenGLState C++: virtual vtkOpenGLState *GetState() """ return vtkOpenGLState 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 GetTQuad2DVBO(self): # real signature unknown; restored from __doc__ """ GetTQuad2DVBO(self) -> vtkOpenGLBufferObject C++: vtkOpenGLBufferObject *GetTQuad2DVBO() """ return vtkOpenGLBufferObject def GetUsingSRGBColorSpace(self): # real signature unknown; restored from __doc__ """ GetUsingSRGBColorSpace(self) -> bool C++: bool GetUsingSRGBColorSpace() Is this window/fo in sRGB colorspace """ return False def GetVBOCache(self): # real signature unknown; restored from __doc__ """ GetVBOCache(self) -> vtkOpenGLVertexBufferObjectCache C++: vtkOpenGLVertexBufferObjectCache *GetVBOCache() Returns the VBO Cache """ return vtkOpenGLVertexBufferObjectCache def GetZbufferData(self, x1, y1, x2, y2): # real signature unknown; restored from __doc__ """ GetZbufferData(self, x1:int, y1:int, x2:int, y2:int) -> Pointer C++: float *GetZbufferData(int x1, int y1, int x2, int y2) override; GetZbufferData(self, x1:int, y1:int, x2:int, y2:int, z:[float, ...]) -> int C++: int GetZbufferData(int x1, int y1, int x2, int y2, float *z) override; GetZbufferData(self, x1:int, y1:int, x2:int, y2:int, buffer:vtkFloatArray) -> int C++: int GetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray *buffer) override; Set/Get the zbuffer data from an image """ pass def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: virtual void Initialize(void) Initialize the rendering window. This will setup all system-specific resources. This method and Finalize() must be symmetric and it should be possible to call them multiple times, even changing WindowId in-between. This is what WindowRemap does. """ pass def InitializeFromCurrentContext(self): # real signature unknown; restored from __doc__ """ InitializeFromCurrentContext(self) -> bool C++: bool InitializeFromCurrentContext() override; Initialize the render window from the information associated with the currently activated OpenGL context. """ return False 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 IsPointSpriteBugPresent(self): # real signature unknown; restored from __doc__ """ IsPointSpriteBugPresent(self) -> bool C++: virtual bool IsPointSpriteBugPresent() Returns true if driver has an EGL/OpenGL bug that makes vtkChartsCoreCxx-TestChartDoubleColors and other tests to fail because point sprites don't work correctly (gl_PointCoord is undefined) unless glEnable(GL_POINT_SPRITE) """ return False 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) -> vtkOpenGLRenderWindow C++: vtkOpenGLRenderWindow *NewInstance() """ return vtkOpenGLRenderWindow def OpenGLInit(self): # real signature unknown; restored from __doc__ """ OpenGLInit(self) -> None C++: virtual void OpenGLInit() Initialize OpenGL for this window. """ pass def OpenGLInitContext(self): # real signature unknown; restored from __doc__ """ OpenGLInitContext(self) -> None C++: virtual void OpenGLInitContext() """ pass def OpenGLInitState(self): # real signature unknown; restored from __doc__ """ OpenGLInitState(self) -> None C++: virtual void OpenGLInitState() """ pass def PopContext(self): # real signature unknown; restored from __doc__ """ PopContext(self) -> None C++: virtual void PopContext() """ pass def PushContext(self): # real signature unknown; restored from __doc__ """ PushContext(self) -> None C++: virtual void PushContext() Ability to push and pop this window's context as the current context. The idea being to if needed make this window's context current and when done releasing resources restore the prior context. The default implementation here is only meant as a backup for subclasses that lack a proper implementation. """ pass def RegisterGraphicsResources(self, cb): # real signature unknown; restored from __doc__ """ RegisterGraphicsResources(self, cb:vtkGenericOpenGLResourceFreeCallback) -> None C++: void RegisterGraphicsResources( vtkGenericOpenGLResourceFreeCallback *cb) """ pass def ReleaseGraphicsResources(self, __a): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, __a:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *) override; Free up any graphics resources associated with this window a value of NULL means the context may already be destroyed """ pass def ReleaseRGBAPixelData(self, data, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ReleaseRGBAPixelData(self, data:[float, ...]) -> None C++: void ReleaseRGBAPixelData(float *data) override; """ pass def Render(self): # real signature unknown; restored from __doc__ """ Render(self) -> None C++: void Render() override; Handle opengl specific code and calls superclass """ pass def ReportCapabilities(self): # real signature unknown; restored from __doc__ """ ReportCapabilities(self) -> str C++: const char *ReportCapabilities() override; Get report of capabilities for the render window """ return "" def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLRenderWindow C++: static vtkOpenGLRenderWindow *SafeDownCast(vtkObjectBase *o) """ return vtkOpenGLRenderWindow def SetFrameBlitMode(self, _arg): # real signature unknown; restored from __doc__ """ SetFrameBlitMode(self, _arg:FrameBlitModes) -> None C++: virtual void SetFrameBlitMode(FrameBlitModes _arg) SetGet how to handle blits at the end of a Frame() call. Only happens when SwapBuffers is true. """ pass def SetFrameBlitModeToBlitToCurrent(self): # real signature unknown; restored from __doc__ """ SetFrameBlitModeToBlitToCurrent(self) -> None C++: void SetFrameBlitModeToBlitToCurrent() """ pass def SetFrameBlitModeToBlitToHardware(self): # real signature unknown; restored from __doc__ """ SetFrameBlitModeToBlitToHardware(self) -> None C++: void SetFrameBlitModeToBlitToHardware() """ pass def SetFrameBlitModeToNoBlit(self): # real signature unknown; restored from __doc__ """ SetFrameBlitModeToNoBlit(self) -> None C++: void SetFrameBlitModeToNoBlit() """ pass def SetFramebufferFlipY(self, _arg): # real signature unknown; restored from __doc__ """ SetFramebufferFlipY(self, _arg:bool) -> None C++: virtual void SetFramebufferFlipY(bool _arg) Enable/Disable flipping the Y axis of the rendered texture. """ pass def SetGlobalMaximumNumberOfMultiSamples(self, val): # real signature unknown; restored from __doc__ """ SetGlobalMaximumNumberOfMultiSamples(val:int) -> None C++: static void SetGlobalMaximumNumberOfMultiSamples(int val) Set/Get the maximum number of multisamples """ pass def SetPixelData(self, x, y, x2, y2, data, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetPixelData(self, x:int, y:int, x2:int, y2:int, data:[int, ...], front:int, right:int) -> int C++: int SetPixelData(int x, int y, int x2, int y2, unsigned char *data, int front, int right) override; SetPixelData(self, x:int, y:int, x2:int, y2:int, data:vtkUnsignedCharArray, front:int, right:int) -> int C++: int SetPixelData(int x, int y, int x2, int y2, vtkUnsignedCharArray *data, int front, int right) override; Set/Get the pixel data of an image, transmitted as RGBRGBRGB. The front argument indicates if the front buffer should be used or the back buffer. It is the caller's responsibility to delete the resulting array. It is very important to realize that the memory in this array is organized from the bottom of the window to the top. The origin of the screen is in the lower left corner. The y axis increases as you go up the screen. So the storage of pixels is from left to right and from bottom to top. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal. """ pass def SetRGBACharPixelData(self, x, y, x2, y2, data, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetRGBACharPixelData(self, x:int, y:int, x2:int, y2:int, data:[int, ...], front:int, blend:int=0, right:int=0) -> int C++: int SetRGBACharPixelData(int x, int y, int x2, int y2, unsigned char *data, int front, int blend=0, int right=0) override; SetRGBACharPixelData(self, x:int, y:int, x2:int, y2:int, data:vtkUnsignedCharArray, front:int, blend:int=0, right:int=0) -> int C++: int SetRGBACharPixelData(int x, int y, int x2, int y2, vtkUnsignedCharArray *data, int front, int blend=0, int right=0) override; """ pass def SetRGBAPixelData(self, x, y, x2, y2, data, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetRGBAPixelData(self, x:int, y:int, x2:int, y2:int, data:[float, ...], front:int, blend:int=0, right:int=0) -> int C++: int SetRGBAPixelData(int x, int y, int x2, int y2, float *data, int front, int blend=0, int right=0) override; SetRGBAPixelData(self, x:int, y:int, x2:int, y2:int, data:vtkFloatArray, front:int, blend:int=0, right:int=0) -> int C++: int SetRGBAPixelData(int x, int y, int x2, int y2, vtkFloatArray *data, int front, int blend=0, int right=0) override; """ pass def SetSwapControl(self, __a): # real signature unknown; restored from __doc__ """ SetSwapControl(self, __a:int) -> bool C++: virtual bool SetSwapControl(int) Set the number of vertical syncs required between frames. A value of 0 means swap buffers as quickly as possible regardless of the vertical refresh. A value of 1 means swap buffers in sync with the vertical refresh to eliminate tearing. A value of -1 means use a value of 1 unless we missed a frame in which case swap immediately. Returns true if the call succeeded. """ return False def SetZbufferData(self, x1, y1, x2, y2, buffer, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetZbufferData(self, x1:int, y1:int, x2:int, y2:int, buffer:[float, ...]) -> int C++: int SetZbufferData(int x1, int y1, int x2, int y2, float *buffer) override; SetZbufferData(self, x1:int, y1:int, x2:int, y2:int, buffer:vtkFloatArray) -> int C++: int SetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray *buffer) override; """ pass def Start(self): # real signature unknown; restored from __doc__ """ Start(self) -> None C++: void Start(void) override; Begin the rendering process. """ pass def StereoMidpoint(self): # real signature unknown; restored from __doc__ """ StereoMidpoint(self) -> None C++: void StereoMidpoint() override; Intermediate method performs operations required between the rendering of the left and right eye. """ pass def SupportsOpenGL(self): # real signature unknown; restored from __doc__ """ SupportsOpenGL(self) -> int C++: int SupportsOpenGL() override; Does this render window support OpenGL? 0-false, 1-true """ return 0 def TextureDepthBlit(self, source): # real signature unknown; restored from __doc__ """ TextureDepthBlit(self, source:vtkTextureObject) -> None C++: virtual void TextureDepthBlit(vtkTextureObject *source) TextureDepthBlit(self, source:vtkTextureObject, srcX:int, srcY:int, srcX2:int, srcY2:int) -> None C++: virtual void TextureDepthBlit(vtkTextureObject *source, int srcX, int srcY, int srcX2, int srcY2) TextureDepthBlit(self, source:vtkTextureObject, srcX:int, srcY:int, srcX2:int, srcY2:int, destX:int, destY:int, destX2:int, destY2:int) -> None C++: virtual void TextureDepthBlit(vtkTextureObject *source, int srcX, int srcY, int srcX2, int srcY2, int destX, int destY, int destX2, int destY2) """ pass def UnregisterGraphicsResources(self, cb): # real signature unknown; restored from __doc__ """ UnregisterGraphicsResources(self, cb:vtkGenericOpenGLResourceFreeCallback) -> None C++: void UnregisterGraphicsResources( vtkGenericOpenGLResourceFreeCallback *cb) """ pass def WaitForCompletion(self): # real signature unknown; restored from __doc__ """ WaitForCompletion(self) -> None C++: void WaitForCompletion() override; Block the thread until the actual rendering is finished(). Useful for measurement only. """ 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.""" BlitToCurrent = 1 BlitToHardware = 0 FrameBlitModes = None # (!) real value is "" NoBlit = 2 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkOpenGLRenderWindow', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Start': , 'Frame': , 'GetRenderingBackend': , 'SetGlobalMaximumNumberOfMultiSamples': , 'GetGlobalMaximumNumberOfMultiSamples': , 'GetPixelData': , 'SetPixelData': , 'GetRGBAPixelData': , 'SetRGBAPixelData': , 'ReleaseRGBAPixelData': , 'GetRGBACharPixelData': , 'SetRGBACharPixelData': , 'GetZbufferData': , 'SetZbufferData': , 'ActivateTexture': , 'DeactivateTexture': , 'GetTextureUnitForTexture': , 'GetDepthBufferSize': , 'GetUsingSRGBColorSpace': , 'GetColorBufferSizes': , 'GetColorBufferInternalFormat': , 'OpenGLInit': , 'OpenGLInitState': , 'OpenGLInitContext': , 'GetOpenGLVersion': , 'GetBackLeftBuffer': , 'GetBackRightBuffer': , 'GetFrontLeftBuffer': , 'GetFrontRightBuffer': , 'GetBackBuffer': , 'GetFrontBuffer': , 'GetContextCreationTime': , 'GetShaderCache': , 'GetVBOCache': , 'GetRenderFramebuffer': , 'GetOffScreenFramebuffer': , 'GetDisplayFramebuffer': , 'GetTextureUnitManager': , 'WaitForCompletion': , 'DrawPixels': , 'GetMaximumHardwareLineWidth': , 'IsPointSpriteBugPresent': , 'GetDefaultTextureInternalFormat': , 'GetOpenGLSupportMessage': , 'SupportsOpenGL': , 'ReportCapabilities': , 'Initialize': , 'RegisterGraphicsResources': , 'UnregisterGraphicsResources': , 'PushContext': , 'PopContext': , 'InitializeFromCurrentContext': , 'SetSwapControl': , 'GetState': , 'GetTQuad2DVBO': , 'GetNoiseTextureUnit': , 'End': , 'Render': , 'StereoMidpoint': , 'GetBufferNeedsResolving': , 'ReleaseGraphicsResources': , 'BlitDisplayFramebuffer': , 'BlitToRenderFramebuffer': , 'SetFrameBlitMode': , 'GetFrameBlitModeMinValue': , 'GetFrameBlitModeMaxValue': , 'GetFrameBlitMode': , 'SetFrameBlitModeToBlitToHardware': , 'SetFrameBlitModeToBlitToCurrent': , 'SetFrameBlitModeToNoBlit': , 'SetFramebufferFlipY': , 'GetFramebufferFlipY': , 'FramebufferFlipYOn': , 'FramebufferFlipYOff': , 'TextureDepthBlit': , 'FrameBlitModes': , 'BlitToHardware': 0, 'BlitToCurrent': 1, 'NoBlit': 2, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLRenderWindow - OpenGL rendering window\\n\\nSuperclass: vtkRenderWindow\\n\\nvtkOpenGLRenderWindow is a concrete implementation of the abstract\\nclass vtkRenderWindow. vtkOpenGLRenderer interfaces to the OpenGL\\ngraphics library. Application programmers should normally use\\nvtkRenderWindow instead of the OpenGL specific version.\\n\\n'})" __vtkname__ = 'vtkOpenGLRenderWindow'