# 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 vtkOpenGLFramebufferObject(__vtkmodules_vtkRenderingCore.vtkFrameBufferObjectBase): """ vtkOpenGLFramebufferObject - Internal class which encapsulates OpenGL FramebufferObject Superclass: vtkFrameBufferObjectBase Before delving into this class it is best to have some background in some OpenGL terms. OpenGL has a notion of a currently bound Framebuffers for drawing and reading. It can be the default framebuffer such as created with a standard window/context or it can be a user created Framebuffer objects. When draw and read commands are invoked, they apply to the current draw and/or read framebuffers. A framebuffer consists of color buffers and an optional depth buffer. The FramebufferObject does not hold the memory for these buffers, it just keeps track of what buffers are attached to it. The buffers themselves hold the storage for the pixels/depths. In the context of this discussion a buffer can be either a vtkTextureObject (both 2D or a slice of a 3D texture) or a vtkRenderbuffer. In some cases a renderbuffer may be faster or more lightweight but you cannot pass a renderbuffer into a shader for sampling in a later pass like you can a texture. You attach these buffers to the Framebuffer using methods such as AddColorAttachment or AddDepthAttachment In normal usage a buffer is Attached to a FramebufferObject and then some or all of the attached buffers are activated for drawing or reading. When you have a framebuffer bound along with some buffers attached to it you can then activate specific buffers for drawing or reading. So you have draw and read framebuffer objects (bindings) and then for the currently bound FramebufferObjects you have active draw and read buffers. A single FramebufferObject can be bound to both Draw and Read. You cannot assign and activate a TextureObject for drawing on the FO and at the same time pass it in as a Texture to the shader program. That type of operation is very common and must be done in two steps. - Render to the FO with the Texture attached as an active buffer - deactivate the texture obj and then render with the texture obj as a texture passed into the shader Typical use cases: The simplest example{.cpp} fbo->SetContext(renWin); fbo->SaveCurrentBindingsAndBuffers(); fbo->PopulateFramebuffer(width, height); ... fbo->RestorePreviousBindingsAndBuffers(); If you wish to use a texture you created {.cpp} fbo->SetContext(renWin); fbo->SaveCurrentBindingsAndBuffers(); fbo->Bind(); fbo->AddColorAttachment(0, vtkTextureObj); fbo->AddDepthAttachment(); // auto create depth buffer fbo->ActivateBuffer(0); ... fbo->RestorePreviousBindingsAndBuffers(); If you will be using a FO repeatedly then it is best to create it attach the buffers and then use as needed for example Typical use case:{.cpp} // setup the FBO once fbo->SetContext(renWin); fbo->SaveCurrentBindingsAndBuffers(); fbo->AddColorAttachment(0, vtkTextureObj); fbo->AddDepthAttachment(); // auto create depth buffer fbo->RestorePreviousBindingsAndBuffers(); // use it many times fbo->SaveCurrentBindingsAndBuffers(); fbo->Bind(); fbo->ActivateBuffer(0); ... // render here etc fbo->RestorePreviousBindingsAndBuffers(); If you with to only bind the framebuffer for drawing or reading there are mode specific versions of some methods that only apply to the mode specified Draw/Read/Both. The mode argument uses OpenGL constants so this class provides convenience methods to return them named GetDrawMode() GetReadMode() and GetBothMode() so that your code does not need to be polluted with OpenGL headers/constants. This class replaces both vtkFrameBufferObject and vtkFrameBufferObject2 and contins methods from both of them. Most methods from FO2 should work with this class. Just rename FBO2 to FBO and make sure to Save and Restore the bindings and buffers. If you have been using the old FO class, which had comments in the header saying not to use it. Then you are in for a bit more of a conversion but generally it should still be easy. Use the code samples above (or any of the classes in OpenGL2 that currently use FBOs) to guide you. They have all been converted to this class. Where previously a DepthBuffer was automatically created for you, you now need to do it explicitly using AddDepthAttachment(). Note the capitalization of FramebufferObject @sa vtkTextureObject, vtkRenderbufferObject """ def ActivateBuffer(self, id): # real signature unknown; restored from __doc__ """ ActivateBuffer(self, id:int) -> None C++: void ActivateBuffer(unsigned int id) """ pass def ActivateDrawBuffer(self, id): # real signature unknown; restored from __doc__ """ ActivateDrawBuffer(self, id:int) -> None C++: void ActivateDrawBuffer(unsigned int id) """ pass def ActivateDrawBuffers(self, n): # real signature unknown; restored from __doc__ """ ActivateDrawBuffers(self, n:int) -> None C++: void ActivateDrawBuffers(unsigned int n) ActivateDrawBuffers(self, ids:[int, ...], n:int) -> None C++: void ActivateDrawBuffers(unsigned int *ids, int n) """ pass def ActivateReadBuffer(self, id): # real signature unknown; restored from __doc__ """ ActivateReadBuffer(self, id:int) -> None C++: void ActivateReadBuffer(unsigned int id) """ pass def AddColorAttachment(self, attId, tex, zslice=0, format=0, mipmapLevel=0): # real signature unknown; restored from __doc__ """ AddColorAttachment(self, attId:int, tex:vtkTextureObject, zslice:int=0, format:int=0, mipmapLevel:int=0) -> None C++: void AddColorAttachment(unsigned int attId, vtkTextureObject *tex, unsigned int zslice=0, unsigned int format=0, unsigned int mipmapLevel=0) AddColorAttachment(self, attId:int, tex:vtkRenderbuffer) -> None C++: void AddColorAttachment(unsigned int attId, vtkRenderbuffer *tex) Directly assign/remove a texture to color attachments. """ pass def AddDepthAttachment(self): # real signature unknown; restored from __doc__ """ AddDepthAttachment(self) -> None C++: void AddDepthAttachment() AddDepthAttachment(self, tex:vtkTextureObject) -> None C++: void AddDepthAttachment(vtkTextureObject *tex) AddDepthAttachment(self, tex:vtkRenderbuffer) -> None C++: void AddDepthAttachment(vtkRenderbuffer *tex) Directly assign/remove a texture/renderbuffer to depth attachments. """ pass def Bind(self): # real signature unknown; restored from __doc__ """ Bind(self) -> None C++: void Bind() Bind(self, mode:int) -> None C++: void Bind(unsigned int mode) Make the draw frame buffer active. """ pass def Blit(self, srcExt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Blit(srcExt:(int, int, int, int), destExt:(int, int, int, int), bits:int, mapping:int) -> int C++: static int Blit(const int srcExt[4], const int destExt[4], unsigned int bits, unsigned int mapping) Copy from the currently bound READ FBO to the currently bound DRAW FBO. The method is static so that one doesn't need to ccreate an instance when transferring between attachments in the default FBO. """ pass def CheckFrameBufferStatus(self, mode): # real signature unknown; restored from __doc__ """ CheckFrameBufferStatus(self, mode:int) -> int C++: int CheckFrameBufferStatus(unsigned int mode) Validate the current FBO configuration (attachments, formats, etc) prints detected errors to vtkErrorMacro. """ return 0 def DeactivateDrawBuffers(self): # real signature unknown; restored from __doc__ """ DeactivateDrawBuffers(self) -> None C++: void DeactivateDrawBuffers() """ pass def DeactivateReadBuffer(self): # real signature unknown; restored from __doc__ """ DeactivateReadBuffer(self) -> None C++: void DeactivateReadBuffer() """ pass def Download(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Download(self, extent:[int, int, int, int], vtkType:int, nComps:int, oglType:int, oglFormat:int) -> vtkPixelBufferObject C++: vtkPixelBufferObject *Download(int extent[4], int vtkType, int nComps, int oglType, int oglFormat) Download(extent:[int, int, int, int], vtkType:int, nComps:int, oglType:int, oglFormat:int, pbo:vtkPixelBufferObject) -> None C++: static void Download(int extent[4], int vtkType, int nComps, int oglType, int oglFormat, vtkPixelBufferObject *pbo) Download data from the read buffer of the current FBO. These are low level methods. In the static variant a PBO must be passed in since we don't have access to a context. The static method is provided so that one may download from the default FBO. """ pass def DownloadColor1(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ DownloadColor1(self, extent:[int, int, int, int], vtkType:int, channel:int) -> vtkPixelBufferObject C++: vtkPixelBufferObject *DownloadColor1(int extent[4], int vtkType, int channel) Download data from the read color attachment of the currently bound FBO into the returned PBO. The PBO must be free'd when you are finished with it. The number of components in the PBO is the same as in the name of the specific download function. When downloading a single color channel, the channel must be identified by index, 1->red, 2->green, 3-> blue. """ pass def DownloadColor3(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ DownloadColor3(self, extent:[int, int, int, int], vtkType:int) -> vtkPixelBufferObject C++: vtkPixelBufferObject *DownloadColor3(int extent[4], int vtkType) """ pass def DownloadColor4(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ DownloadColor4(self, extent:[int, int, int, int], vtkType:int) -> vtkPixelBufferObject C++: vtkPixelBufferObject *DownloadColor4(int extent[4], int vtkType) """ pass def DownloadDepth(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ DownloadDepth(self, extent:[int, int, int, int], vtkType:int) -> vtkPixelBufferObject C++: vtkPixelBufferObject *DownloadDepth(int extent[4], int vtkType) Download data from the depth attachment of the currently bound FBO. The returned PBO must be Delete'd by the caller. The returned PBO has one component. """ pass def GetActiveDrawBuffer(self, id): # real signature unknown; restored from __doc__ """ GetActiveDrawBuffer(self, id:int) -> int C++: unsigned int GetActiveDrawBuffer(unsigned int id) """ return 0 def GetActiveReadBuffer(self): # real signature unknown; restored from __doc__ """ GetActiveReadBuffer(self) -> int C++: virtual unsigned int GetActiveReadBuffer() """ return 0 def GetBothMode(self): # real signature unknown; restored from __doc__ """ GetBothMode() -> int C++: static unsigned int GetBothMode() """ return 0 def GetColorAttachmentAsTextureObject(self, num): # real signature unknown; restored from __doc__ """ GetColorAttachmentAsTextureObject(self, num:int) -> vtkTextureObject C++: vtkTextureObject *GetColorAttachmentAsTextureObject( unsigned int num) Return the texture object bound to the passed attachment number. In the case that a renderbuffer is used, this will return nullptr. """ return vtkTextureObject def GetContext(self): # real signature unknown; restored from __doc__ """ GetContext(self) -> vtkOpenGLRenderWindow C++: vtkOpenGLRenderWindow *GetContext() """ return vtkOpenGLRenderWindow def GetDepthAttachmentAsTextureObject(self): # real signature unknown; restored from __doc__ """ GetDepthAttachmentAsTextureObject(self) -> vtkTextureObject C++: vtkTextureObject *GetDepthAttachmentAsTextureObject() """ return vtkTextureObject def GetDrawMode(self): # real signature unknown; restored from __doc__ """ GetDrawMode() -> int C++: static unsigned int GetDrawMode() """ return 0 def GetFBOIndex(self): # real signature unknown; restored from __doc__ """ GetFBOIndex(self) -> int C++: virtual unsigned int GetFBOIndex() """ return 0 def GetLastSize(self): # real signature unknown; restored from __doc__ """ GetLastSize(self) -> Pointer C++: int *GetLastSize() override; GetLastSize(self, _arg1:int, _arg2:int) -> None C++: void GetLastSize(int &_arg1, int &_arg2) override; GetLastSize(self, _arg:[int, int]) -> None C++: void GetLastSize(int _arg[2]) override; Dimensions in pixels of the framebuffer. """ pass def GetMaximumNumberOfActiveTargets(self): # real signature unknown; restored from __doc__ """ GetMaximumNumberOfActiveTargets(self) -> int C++: unsigned int GetMaximumNumberOfActiveTargets() Returns the maximum number of targets that can be rendered to at one time. This limits the active targets set by SetActiveTargets(). The return value is valid only if GetContext is non-null. """ return 0 def GetMaximumNumberOfRenderTargets(self): # real signature unknown; restored from __doc__ """ GetMaximumNumberOfRenderTargets(self) -> int C++: unsigned int GetMaximumNumberOfRenderTargets() Returns the maximum number of render targets available. This limits the available attachment points for SetColorAttachment(). The return value is valid only if GetContext is non-null. """ return 0 def GetMultiSamples(self): # real signature unknown; restored from __doc__ """ GetMultiSamples(self) -> int C++: int GetMultiSamples() """ return 0 def GetNumberOfColorAttachments(self): # real signature unknown; restored from __doc__ """ GetNumberOfColorAttachments(self) -> int C++: int GetNumberOfColorAttachments() Return the number of color attachments for the given mode """ 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 GetReadMode(self): # real signature unknown; restored from __doc__ """ GetReadMode() -> int C++: static unsigned int GetReadMode() """ return 0 def InitializeViewport(self, width, height): # real signature unknown; restored from __doc__ """ InitializeViewport(self, width:int, height:int) -> None C++: void InitializeViewport(int width, int height) Set up ortho viewport with scissor, lighting, blend, and depth disabled. The method affects the current bound FBO. """ 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 IsSupported(self, __a): # real signature unknown; restored from __doc__ """ IsSupported(__a:vtkOpenGLRenderWindow) -> bool C++: static bool IsSupported(vtkOpenGLRenderWindow *) Returns if the context supports the required extensions. Extension will be loaded when the context is set. """ 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) -> vtkOpenGLFramebufferObject C++: vtkOpenGLFramebufferObject *NewInstance() """ return vtkOpenGLFramebufferObject def PopulateFramebuffer(self, width, height): # real signature unknown; restored from __doc__ """ PopulateFramebuffer(self, width:int, height:int) -> bool C++: bool PopulateFramebuffer(int width, int height) PopulateFramebuffer(self, width:int, height:int, useTextures:bool, numberOfColorAttachments:int, colorDataType:int, wantDepthAttachment:bool, depthBitplanes:int, multisamples:int, wantStencilAttachment:bool=False) -> bool C++: bool PopulateFramebuffer(int width, int height, bool useTextures, int numberOfColorAttachments, int colorDataType, bool wantDepthAttachment, int depthBitplanes, int multisamples, bool wantStencilAttachment=false) Convenience method to populate a framebuffer with attachments created as well. Returns true if a complete valid Framebuffer was created """ return False def ReleaseGraphicsResources(self, win): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, win:vtkWindow) -> None C++: virtual void ReleaseGraphicsResources(vtkWindow *win) Deactivate and UnBind """ pass def RemoveColorAttachment(self, index): # real signature unknown; restored from __doc__ """ RemoveColorAttachment(self, index:int) -> None C++: void RemoveColorAttachment(unsigned int index) """ pass def RemoveColorAttachments(self, num): # real signature unknown; restored from __doc__ """ RemoveColorAttachments(self, num:int) -> None C++: void RemoveColorAttachments(unsigned int num) """ pass def RemoveDepthAttachment(self): # real signature unknown; restored from __doc__ """ RemoveDepthAttachment(self) -> None C++: void RemoveDepthAttachment() """ pass def RenderQuad(self, minX, maxX, minY, maxY, program, vao): # real signature unknown; restored from __doc__ """ RenderQuad(self, minX:int, maxX:int, minY:int, maxY:int, program:vtkShaderProgram, vao:vtkOpenGLVertexArrayObject) -> None C++: void RenderQuad(int minX, int maxX, int minY, int maxY, vtkShaderProgram *program, vtkOpenGLVertexArrayObject *vao) Renders a quad at the given location with pixel coordinates. This method is provided as a convenience, since we often render quads in a FBO. \pre positive_minX: minX>=0 \pre increasing_x: minX<=maxX \pre valid_maxX: maxX=0 \pre increasing_y: minY<=maxY \pre valid_maxY: maxY None C++: void Resize(int width, int height) Resize all FO attachments """ pass def RestorePreviousBindingsAndBuffers(self): # real signature unknown; restored from __doc__ """ RestorePreviousBindingsAndBuffers(self) -> None C++: void RestorePreviousBindingsAndBuffers() RestorePreviousBindingsAndBuffers(self, mode:int) -> None C++: void RestorePreviousBindingsAndBuffers(unsigned int mode) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLFramebufferObject C++: static vtkOpenGLFramebufferObject *SafeDownCast( vtkObjectBase *o) """ return vtkOpenGLFramebufferObject def SaveCurrentBindingsAndBuffers(self): # real signature unknown; restored from __doc__ """ SaveCurrentBindingsAndBuffers(self) -> None C++: void SaveCurrentBindingsAndBuffers() SaveCurrentBindingsAndBuffers(self, mode:int) -> None C++: void SaveCurrentBindingsAndBuffers(unsigned int mode) Store/Restore the current framebuffer bindings and buffers. """ pass def SetContext(self, context): # real signature unknown; restored from __doc__ """ SetContext(self, context:vtkRenderWindow) -> None C++: void SetContext(vtkRenderWindow *context) Get/Set the context. Context must be a vtkOpenGLRenderWindow. This does not increase the reference count of the context to avoid reference loops. SetContext() may raise an error if the OpenGL context does not support the required OpenGL extensions. """ pass def Start(self, width, height): # real signature unknown; restored from __doc__ """ Start(self, width:int, height:int) -> bool C++: bool Start(int width, int height) User must take care that width/height match the dimensions of the user defined texture attachments. This method makes the "active buffers" the buffers that will get drawn into by subsequent drawing calls. Note that this does not clear the render buffers i.e. no glClear() calls are made by either of these methods. It's up to the caller to clear the buffers if needed. """ return False def StartNonOrtho(self, width, height): # real signature unknown; restored from __doc__ """ StartNonOrtho(self, width:int, height:int) -> bool C++: bool StartNonOrtho(int width, int height) """ return False def UnBind(self): # real signature unknown; restored from __doc__ """ UnBind(self) -> None C++: void UnBind() UnBind(self, mode:int) -> None C++: void UnBind(unsigned int mode) Unbind this buffer """ 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__': 'vtkOpenGLFramebufferObject', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetContext': , 'GetContext': , 'Bind': , 'UnBind': , 'SaveCurrentBindingsAndBuffers': , 'RestorePreviousBindingsAndBuffers': , 'Start': , 'StartNonOrtho': , 'InitializeViewport': , 'ActivateDrawBuffers': , 'ActivateDrawBuffer': , 'ActivateReadBuffer': , 'ActivateBuffer': , 'DeactivateDrawBuffers': , 'DeactivateReadBuffer': , 'GetActiveReadBuffer': , 'GetActiveDrawBuffer': , 'RenderQuad': , 'AddColorAttachment': , 'RemoveColorAttachment': , 'RemoveColorAttachments': , 'GetColorAttachmentAsTextureObject': , 'GetNumberOfColorAttachments': , 'AddDepthAttachment': , 'RemoveDepthAttachment': , 'GetDepthAttachmentAsTextureObject': , 'PopulateFramebuffer': , 'GetMaximumNumberOfActiveTargets': , 'GetMaximumNumberOfRenderTargets': , 'GetLastSize': , 'IsSupported': , 'CheckFrameBufferStatus': , 'ReleaseGraphicsResources': , 'GetFBOIndex': , 'Blit': , 'DownloadColor1': , 'DownloadColor3': , 'DownloadColor4': , 'DownloadDepth': , 'Download': , 'GetDrawMode': , 'GetReadMode': , 'GetBothMode': , 'Resize': , 'GetMultiSamples': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLFramebufferObject - Internal class which encapsulates OpenGL\\nFramebufferObject\\n\\nSuperclass: vtkFrameBufferObjectBase\\n\\nBefore delving into this class it is best to have some background in\\nsome OpenGL terms. OpenGL has a notion of a currently bound\\nFramebuffers for drawing and reading. It can be the default\\nframebuffer such as created with a standard window/context or it can\\nbe a user created Framebuffer objects. When draw and read commands\\nare invoked, they apply to the current draw and/or read framebuffers.\\n\\nA framebuffer consists of color buffers and an optional depth buffer.\\nThe FramebufferObject does not hold the memory for these buffers, it\\njust keeps track of what buffers are attached to it. The buffers\\nthemselves hold the storage for the pixels/depths.\\n\\nIn the context of this discussion a buffer can be either a\\nvtkTextureObject (both 2D or a slice of a 3D texture) or a\\nvtkRenderbuffer. In some cases a renderbuffer may be faster or more\\nlightweight but you cannot pass a renderbuffer into a shader for\\nsampling in a later pass like you can a texture.\\n\\nYou attach these buffers to the Framebuffer using methods such as\\nAddColorAttachment or AddDepthAttachment In normal usage a buffer is\\nAttached to a FramebufferObject and then some or all of the attached\\nbuffers are activated for drawing or reading.\\n\\nWhen you have a framebuffer bound along with some buffers attached to\\nit you can then activate specific buffers for drawing or reading. So\\nyou have draw and read framebuffer objects (bindings) and then for\\nthe currently bound FramebufferObjects you have active draw and read\\nbuffers.\\n\\nA single FramebufferObject can be bound to both Draw and Read. You\\ncannot assign and activate a TextureObject for drawing on the FO and\\nat the same time pass it in as a Texture to the shader program. That\\ntype of operation is very common and must be done in two steps.\\n- Render to the FO with the Texture attached as an active buffer\\n- deactivate the texture obj and then render with the texture obj as\\n a texture passed into the shader\\n\\nTypical use cases: The simplest example{.cpp}\\nfbo->SetContext(renWin);\\nfbo->SaveCurrentBindingsAndBuffers();\\nfbo->PopulateFramebuffer(width, height);\\n\\n...\\n\\nfbo->RestorePreviousBindingsAndBuffers();\\n\\nIf you wish to use a texture you created\\n\\n{.cpp}\\nfbo->SetContext(renWin);\\nfbo->SaveCurrentBindingsAndBuffers();\\nfbo->Bind();\\nfbo->AddColorAttachment(0, vtkTextureObj);\\nfbo->AddDepthAttachment(); // auto create depth buffer\\nfbo->ActivateBuffer(0);\\n\\n...\\n\\nfbo->RestorePreviousBindingsAndBuffers();\\n\\nIf you will be using a FO repeatedly then it is best to create it\\nattach the buffers and then use as needed for example\\n\\nTypical use case:{.cpp}\\n// setup the FBO once\\nfbo->SetContext(renWin);\\nfbo->SaveCurrentBindingsAndBuffers();\\nfbo->AddColorAttachment(0, vtkTextureObj);\\nfbo->AddDepthAttachment(); // auto create depth buffer\\nfbo->RestorePreviousBindingsAndBuffers();\\n\\n// use it many times fbo->SaveCurrentBindingsAndBuffers();\\nfbo->Bind(); fbo->ActivateBuffer(0); ... // render here etc\\nfbo->RestorePreviousBindingsAndBuffers();\\n\\nIf you with to only bind the framebuffer for drawing or reading there\\nare mode specific versions of some methods that only apply to the\\nmode specified Draw/Read/Both. The mode argument uses OpenGL\\nconstants so this class provides convenience methods to return them\\nnamed GetDrawMode() GetReadMode() and GetBothMode() so that your code\\ndoes not need to be polluted with OpenGL headers/constants.\\n\\nThis class replaces both vtkFrameBufferObject and\\nvtkFrameBufferObject2 and contins methods from both of them. Most\\nmethods from FO2 should work with this class. Just rename FBO2 to FBO\\nand make sure to Save and Restore the bindings and buffers. If you\\nhave been using the old FO class, which had comments in the header\\nsaying not to use it. Then you are in for a bit more of a conversion\\nbut generally it should still be easy. Use the code samples above (or\\nany of the classes in OpenGL2 that currently use FBOs) to guide you.\\nThey have all been converted to this class. Where previously a\\nDepthBuffer was automatically created for you, you now need to do it\\nexplicitly using AddDepthAttachment().\\n\\nNote the capitalization of FramebufferObject\\n\\n@sa\\nvtkTextureObject, vtkRenderbufferObject\\n\\n'})" __vtkname__ = 'vtkOpenGLFramebufferObject'