"""
This type stub file was generated by pyright.
"""

from .vtkProp3D import vtkProp3D

class vtkActor(vtkProp3D):
    """
    vtkActor - represents an object (geometry & properties) in a rendered
    scene
    
    Superclass: vtkProp3D
    
    vtkActor is used to represent an entity in a rendering scene.  It
    inherits functions related to the actors position, and orientation
    from vtkProp. The actor also has scaling and maintains a reference to
    the defining geometry (i.e., the mapper), rendering properties, and
    possibly a texture map. vtkActor combines these instance variables
    into one 4x4 transformation matrix as follows: [x y z 1] = [x y z 1]
    Translate(-origin) Scale(scale) Rot(y) Rot(x) Rot (z) Trans(origin)
    Trans(position)
    
    @sa
    vtkProperty vtkTexture vtkMapper vtkAssembly vtkFollower vtkLODActor
    """
    def ApplyProperties(self):
        """
        V.ApplyProperties()
        C++: virtual void ApplyProperties()
        
        Apply the current properties to all parts that compose this
        actor. This method is overloaded in vtkAssembly to apply the
        assemblies' properties to all its parts in a recursive manner.
        Typically the use of this method is to set the desired properties
        in the assembly, and then push the properties down to the
        assemblies parts with ApplyProperties().
        """
        ...
    
    def ForceOpaqueOff(self):
        """
        V.ForceOpaqueOff()
        C++: virtual void ForceOpaqueOff()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def ForceOpaqueOn(self):
        """
        V.ForceOpaqueOn()
        C++: virtual void ForceOpaqueOn()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def ForceTranslucentOff(self):
        """
        V.ForceTranslucentOff()
        C++: virtual void ForceTranslucentOff()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def ForceTranslucentOn(self):
        """
        V.ForceTranslucentOn()
        C++: virtual void ForceTranslucentOn()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def GetActors(self, vtkPropCollection):
        """
        V.GetActors(vtkPropCollection)
        C++: void GetActors(vtkPropCollection *) override;
        
        For some exporters and other other operations we must be able to
        collect all the actors or volumes. These methods are used in that
        process.
        """
        ...
    
    def GetBackfaceProperty(self):
        """
        V.GetBackfaceProperty() -> vtkProperty
        C++: virtual vtkProperty *GetBackfaceProperty()
        
        Set/Get the property object that controls this actors backface
        surface properties.  This should be an instance of a vtkProperty
        object. If one isn't specified, then the front face properties
        will be used.  Multiple actors can share one property object.
        """
        ...
    
    def GetBounds(self):
        """
        V.GetBounds() -> (float, float, float, float, float, float)
        C++: double *GetBounds() override;
        V.GetBounds([float, float, float, float, float, float])
        C++: void GetBounds(double bounds[6])
        
        Get the bounds for this Prop3D as
        (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).
        """
        ...
    
    def GetForceOpaque(self):
        """
        V.GetForceOpaque() -> bool
        C++: virtual bool GetForceOpaque()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def GetForceTranslucent(self):
        """
        V.GetForceTranslucent() -> bool
        C++: virtual bool GetForceTranslucent()
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def GetMapper(self):
        """
        V.GetMapper() -> vtkMapper
        C++: virtual vtkMapper *GetMapper()
        
        Returns the Mapper that this actor is getting its data from.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Get the actors mtime plus consider its properties and texture if
        set.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetProperty(self):
        """
        V.GetProperty() -> vtkProperty
        C++: vtkProperty *GetProperty()
        
        Set/Get the property object that controls this actors surface
        properties.  This should be an instance of a vtkProperty object. 
        Every actor must have a property associated with it.  If one
        isn't specified, then one will be generated automatically.
        Multiple actors can share one property object.
        """
        ...
    
    def GetRedrawMTime(self):
        """
        V.GetRedrawMTime() -> int
        C++: vtkMTimeType GetRedrawMTime() override;
        
        Return the mtime of anything that would cause the rendered image
        to appear differently. Usually this involves checking the mtime
        of the prop plus anything else it depends on such as properties,
        textures, etc.
        """
        ...
    
    def GetSupportsSelection(self):
        """
        V.GetSupportsSelection() -> bool
        C++: bool GetSupportsSelection() override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT
        USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS Used by
        vtkHardwareSelector to determine if the prop supports hardware
        selection.
        """
        ...
    
    def GetTexture(self):
        """
        V.GetTexture() -> vtkTexture
        C++: virtual vtkTexture *GetTexture()
        
        Set/Get the texture object to control rendering texture maps. 
        This will be a vtkTexture object. An actor does not need to have
        an associated texture map and multiple actors can share one
        texture.
        """
        ...
    
    def HasOpaqueGeometry(self):
        """
        V.HasOpaqueGeometry() -> int
        C++: vtkTypeBool HasOpaqueGeometry() override;
        
        Does this prop have some opaque/translucent polygonal geometry?
        """
        ...
    
    def HasTranslucentPolygonalGeometry(self):
        """
        V.HasTranslucentPolygonalGeometry() -> int
        C++: vtkTypeBool HasTranslucentPolygonalGeometry() override;
        
        Does this prop have some opaque/translucent polygonal geometry?
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsRenderingTranslucentPolygonalGeometry(self):
        """
        V.IsRenderingTranslucentPolygonalGeometry() -> bool
        C++: bool IsRenderingTranslucentPolygonalGeometry() override;
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def MakeProperty(self):
        """
        V.MakeProperty() -> vtkProperty
        C++: virtual vtkProperty *MakeProperty()
        
        Create a new property suitable for use with this type of Actor.
        For example, a vtkMesaActor should create a vtkMesaProperty in
        this function.   The default is to just call vtkProperty::New.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkActor
        C++: vtkActor *NewInstance()
        """
        ...
    
    def ProcessSelectorPixelBuffers(self, vtkHardwareSelector, Stvector_IjE):
        """
        V.ProcessSelectorPixelBuffers(vtkHardwareSelector, Stvector_IjE)
        C++: void ProcessSelectorPixelBuffers(vtkHardwareSelector *sel,
            std::vector<unsigned int> &pixeloffsets) override;
        
        allows a prop to update a selections color buffers Default just
        forwards to the Mapper
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *) override;
        
        Release any graphics resources that are being consumed by this
        actor. The parameter window could be used to determine which
        graphic resources to release.
        """
        ...
    
    def Render(self, vtkRenderer, vtkMapper):
        """
        V.Render(vtkRenderer, vtkMapper)
        C++: virtual void Render(vtkRenderer *, vtkMapper *)
        
        This causes the actor to be rendered. It in turn will render the
        actor's property, texture map and then mapper. If a property
        hasn't been assigned, then the actor will create one
        automatically. Note that a side effect of this method is that the
        pipeline will be updated.
        """
        ...
    
    def RenderOpaqueGeometry(self, vtkViewport):
        """
        V.RenderOpaqueGeometry(vtkViewport) -> int
        C++: int RenderOpaqueGeometry(vtkViewport *viewport) override;
        
        Support the standard render methods.
        """
        ...
    
    def RenderTranslucentPolygonalGeometry(self, vtkViewport):
        """
        V.RenderTranslucentPolygonalGeometry(vtkViewport) -> int
        C++: int RenderTranslucentPolygonalGeometry(vtkViewport *viewport)
             override;
        
        Support the standard render methods.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkActor
        C++: static vtkActor *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetBackfaceProperty(self, vtkProperty):
        """
        V.SetBackfaceProperty(vtkProperty)
        C++: void SetBackfaceProperty(vtkProperty *lut)
        
        Set/Get the property object that controls this actors backface
        surface properties.  This should be an instance of a vtkProperty
        object. If one isn't specified, then the front face properties
        will be used.  Multiple actors can share one property object.
        """
        ...
    
    def SetForceOpaque(self, bool):
        """
        V.SetForceOpaque(bool)
        C++: virtual void SetForceOpaque(bool _arg)
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def SetForceTranslucent(self, bool):
        """
        V.SetForceTranslucent(bool)
        C++: virtual void SetForceTranslucent(bool _arg)
        
        Force the actor to be treated as opaque or translucent
        """
        ...
    
    def SetIsRenderingTranslucentPolygonalGeometry(self, bool):
        """
        V.SetIsRenderingTranslucentPolygonalGeometry(bool)
        C++: void SetIsRenderingTranslucentPolygonalGeometry(bool val)
        """
        ...
    
    def SetMapper(self, vtkMapper):
        """
        V.SetMapper(vtkMapper)
        C++: virtual void SetMapper(vtkMapper *)
        
        This is the method that is used to connect an actor to the end of
        a visualization pipeline, i.e. the mapper. This should be a
        subclass of vtkMapper. Typically vtkPolyDataMapper and
        vtkDataSetMapper will be used.
        """
        ...
    
    def SetProperty(self, vtkProperty):
        """
        V.SetProperty(vtkProperty)
        C++: void SetProperty(vtkProperty *lut)
        
        Set/Get the property object that controls this actors surface
        properties.  This should be an instance of a vtkProperty object. 
        Every actor must have a property associated with it.  If one
        isn't specified, then one will be generated automatically.
        Multiple actors can share one property object.
        """
        ...
    
    def SetTexture(self, vtkTexture):
        """
        V.SetTexture(vtkTexture)
        C++: virtual void SetTexture(vtkTexture *)
        
        Set/Get the texture object to control rendering texture maps. 
        This will be a vtkTexture object. An actor does not need to have
        an associated texture map and multiple actors can share one
        texture.
        """
        ...
    
    def ShallowCopy(self, vtkProp):
        """
        V.ShallowCopy(vtkProp)
        C++: void ShallowCopy(vtkProp *prop) override;
        
        Shallow copy of an actor. Overloads the virtual vtkProp method.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


