# 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 vtkOpenGLVertexBufferObjectGroup(__vtkmodules_vtkCommonCore.vtkObject): """ vtkOpenGLVertexBufferObjectGroup - manage vertex buffer objects shared within a mapper Superclass: vtkObject This class holds onto the VBOs that a mapper is using. The basic operation is that during the render process the mapper may cache a number of dataArrays as VBOs associated with attributes. This class keep track of freeing VBOs no longer used by the mapper and uploading new data as needed. When using CacheCataArray the same array can be set each time and this class will not rebuild or upload unless needed. When using the AppendDataArray API no caching is done and the VBOs will be rebuilt and uploaded each time. So when appending th emapper need to handle checking if the VBO should be updated. Use case: make this an ivar of your mapper vbg->CacheDataArray("vertexMC", vtkDataArray); vbg->BuildAllVBOs(); if (vbg->GetMTime() > your VAO update time) { vbg->AddAllAttributesToVAO(...); } Appended Use case: make this an ivar of your mapper if (you need to update your VBOs) { vbg->ClearAllVBOs(); vbg->AppendDataArray("vertexMC", vtkDataArray1); vbg->AppendDataArray("vertexMC", vtkDataArray2); vbg->AppendDataArray("vertexMC", vtkDataArray3); vbg->BuildAllVBOs(); vbg->AddAllAttributesToVAO(...); } use VAO """ def AddAllAttributesToVAO(self, program, vao): # real signature unknown; restored from __doc__ """ AddAllAttributesToVAO(self, program:vtkShaderProgram, vao:vtkOpenGLVertexArrayObject) -> None C++: void AddAllAttributesToVAO(vtkShaderProgram *program, vtkOpenGLVertexArrayObject *vao) Attach all VBOs to their attributes """ pass def AppendDataArray(self, attribute, da, destType): # real signature unknown; restored from __doc__ """ AppendDataArray(self, attribute:str, da:vtkDataArray, destType:int) -> None C++: void AppendDataArray(const char *attribute, vtkDataArray *da, int destType) Append a data array for an attribute in the VBO Group registers the data array until build is called """ pass def ArrayExists(self, attribute, da, offset, totalOffset): # real signature unknown; restored from __doc__ """ ArrayExists(self, attribute:str, da:vtkDataArray, offset:int, totalOffset:int) -> bool C++: bool ArrayExists(const char *attribute, vtkDataArray *da, vtkIdType &offset, vtkIdType &totalOffset) Check if the array already exists. offset is the index of the first vertex of the array if it exists. totalOffset is the total number of vertices in the appended arrays. Note that if the array does not exist, offset is equal to totalOffset. """ return False def BuildAllVBOs(self, __a): # real signature unknown; restored from __doc__ """ BuildAllVBOs(self, __a:vtkOpenGLVertexBufferObjectCache) -> None C++: void BuildAllVBOs(vtkOpenGLVertexBufferObjectCache *) BuildAllVBOs(self, __a:vtkViewport) -> None C++: void BuildAllVBOs(vtkViewport *) using the data arrays in this group build all the VBOs, once this has been called the reference to the data arrays will be freed. """ pass def CacheDataArray(self, attribute, da, cache, destType): # real signature unknown; restored from __doc__ """ CacheDataArray(self, attribute:str, da:vtkDataArray, cache:vtkOpenGLVertexBufferObjectCache, destType:int) -> None C++: void CacheDataArray(const char *attribute, vtkDataArray *da, vtkOpenGLVertexBufferObjectCache *cache, int destType) CacheDataArray(self, attribute:str, da:vtkDataArray, vp:vtkViewport, destType:int) -> None C++: void CacheDataArray(const char *attribute, vtkDataArray *da, vtkViewport *vp, int destType) Set the data array for an attribute in the VBO Group registers the data array until build is called once this is called a valid VBO will exist """ pass def ClearAllDataArrays(self): # real signature unknown; restored from __doc__ """ ClearAllDataArrays(self) -> None C++: void ClearAllDataArrays() Clear all the data arrays. Typically an internal method. Automatically called at the end of BuildAllVBOs to prepare for the next set of attributes. """ pass def ClearAllVBOs(self): # real signature unknown; restored from __doc__ """ ClearAllVBOs(self) -> None C++: void ClearAllVBOs() Force all the VBOs to be freed from this group. Call this prior to starting appending operations. Not needed for single array caching. """ pass def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Get the mtime of this groups VBOs """ return 0 def GetNumberOfComponents(self, attribute): # real signature unknown; restored from __doc__ """ GetNumberOfComponents(self, attribute:str) -> int C++: int GetNumberOfComponents(const char *attribute) Returns the number of components for this attribute zero if the attribute does not exist """ 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 GetNumberOfTuples(self, attribute): # real signature unknown; restored from __doc__ """ GetNumberOfTuples(self, attribute:str) -> int C++: int GetNumberOfTuples(const char *attribute) Returns the number of tuples for this attribute zero if the attribute does not exist """ return 0 def GetVBO(self, attribute): # real signature unknown; restored from __doc__ """ GetVBO(self, attribute:str) -> vtkOpenGLVertexBufferObject C++: vtkOpenGLVertexBufferObject *GetVBO(const char *attribute) Returns the VBO for an attribute, NULL if it is not present. """ return vtkOpenGLVertexBufferObject 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) -> vtkOpenGLVertexBufferObjectGroup C++: vtkOpenGLVertexBufferObjectGroup *NewInstance() """ return vtkOpenGLVertexBufferObjectGroup def ReleaseGraphicsResources(self, __a): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, __a:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *) Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. """ pass def RemoveAttribute(self, attribute): # real signature unknown; restored from __doc__ """ RemoveAttribute(self, attribute:str) -> None C++: void RemoveAttribute(const char *attribute) used to remove a no longer needed attribute Calling CacheDataArray with a nullptr attribute will also work. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLVertexBufferObjectGroup C++: static vtkOpenGLVertexBufferObjectGroup *SafeDownCast( vtkObjectBase *o) """ return vtkOpenGLVertexBufferObjectGroup 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__\': \'vtkOpenGLVertexBufferObjectGroup\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'GetNumberOfComponents\': , \'GetNumberOfTuples\': , \'ReleaseGraphicsResources\': , \'GetVBO\': , \'AddAllAttributesToVAO\': , \'RemoveAttribute\': , \'CacheDataArray\': , \'ArrayExists\': , \'AppendDataArray\': , \'BuildAllVBOs\': , \'ClearAllVBOs\': , \'ClearAllDataArrays\': , \'GetMTime\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkOpenGLVertexBufferObjectGroup - manage vertex buffer objects\\nshared within a mapper\\n\\nSuperclass: vtkObject\\n\\nThis class holds onto the VBOs that a mapper is using. The basic\\noperation is that during the render process the mapper may cache a\\nnumber of dataArrays as VBOs associated with attributes. This class\\nkeep track of freeing VBOs no longer used by the mapper and uploading\\nnew data as needed.\\n\\nWhen using CacheCataArray the same array can be set each time and\\nthis class will not rebuild or upload unless needed.\\n\\nWhen using the AppendDataArray API no caching is done and the VBOs\\nwill be rebuilt and uploaded each time. So when appending th emapper\\nneed to handle checking if the VBO should be updated.\\n\\nUse case:\\n make this an ivar of your mapper\\n vbg->CacheDataArray("vertexMC", vtkDataArray);\\n vbg->BuildAllVBOs();\\n if (vbg->GetMTime() > your VAO update time)\\n {\\n vbg->AddAllAttributesToVAO(...);\\n }\\n\\nAppended Use case:\\n make this an ivar of your mapper\\n if (you need to update your VBOs)\\n {\\n vbg->ClearAllVBOs();\\n vbg->AppendDataArray("vertexMC", vtkDataArray1);\\n vbg->AppendDataArray("vertexMC", vtkDataArray2);\\n vbg->AppendDataArray("vertexMC", vtkDataArray3);\\n vbg->BuildAllVBOs();\\n vbg->AddAllAttributesToVAO(...);\\n }\\n\\nuse VAO\\n\\n\'})' __vtkname__ = 'vtkOpenGLVertexBufferObjectGroup'