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

from .vtkViewport import vtkViewport

class vtkRenderer(vtkViewport):
    """
    vtkRenderer - abstract specification for renderers
    
    Superclass: vtkViewport
    
    vtkRenderer provides an abstract specification for renderers. A
    renderer is an object that controls the rendering process for
    objects. Rendering is the process of converting geometry, a
    specification for lights, and a camera view into an image.
    vtkRenderer also performs coordinate transformation between world
    coordinates, view coordinates (the computer graphics rendering
    coordinate system), and display coordinates (the actual screen
    coordinates on the display device). Certain advanced rendering
    features such as two-sided lighting can also be controlled.
    
    @sa
    vtkRenderWindow vtkActor vtkCamera vtkLight vtkVolume
    """
    def AddActor(self, vtkProp):
        """
        V.AddActor(vtkProp)
        C++: void AddActor(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def AddCuller(self, vtkCuller):
        """
        V.AddCuller(vtkCuller)
        C++: void AddCuller(vtkCuller *)
        
        Add an culler to the list of cullers.
        """
        ...
    
    def AddLight(self, vtkLight):
        """
        V.AddLight(vtkLight)
        C++: void AddLight(vtkLight *)
        
        Add a light to the list of lights.
        """
        ...
    
    def AddVolume(self, vtkProp):
        """
        V.AddVolume(vtkProp)
        C++: void AddVolume(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def AutomaticLightCreationOff(self):
        """
        V.AutomaticLightCreationOff()
        C++: virtual void AutomaticLightCreationOff()
        
        Turn on/off a flag which disables the automatic light creation
        capability. Normally in VTK if no lights are associated with the
        renderer, then a light is automatically created. However, in
        special circumstances this feature is undesirable, so the
        following boolean is provided to disable automatic light
        creation. (Turn AutomaticLightCreation off if you do not want
        lights to be created.)
        """
        ...
    
    def AutomaticLightCreationOn(self):
        """
        V.AutomaticLightCreationOn()
        C++: virtual void AutomaticLightCreationOn()
        
        Turn on/off a flag which disables the automatic light creation
        capability. Normally in VTK if no lights are associated with the
        renderer, then a light is automatically created. However, in
        special circumstances this feature is undesirable, so the
        following boolean is provided to disable automatic light
        creation. (Turn AutomaticLightCreation off if you do not want
        lights to be created.)
        """
        ...
    
    def BackingStoreOff(self):
        """
        V.BackingStoreOff()
        C++: virtual void BackingStoreOff()
        
        Turn on/off using backing store. This may cause the re-rendering
        time to be slightly slower when the view changes. But it is much
        faster when the image has not changed, such as during an expose
        event.
        """
        ...
    
    def BackingStoreOn(self):
        """
        V.BackingStoreOn()
        C++: virtual void BackingStoreOn()
        
        Turn on/off using backing store. This may cause the re-rendering
        time to be slightly slower when the view changes. But it is much
        faster when the image has not changed, such as during an expose
        event.
        """
        ...
    
    def CaptureGL2PSSpecialProp(self, vtkProp):
        """
        V.CaptureGL2PSSpecialProp(vtkProp) -> int
        C++: int CaptureGL2PSSpecialProp(vtkProp *)
        
        This function is called to capture an instance of vtkProp that
        requires special handling during
        vtkRenderWindow::CaptureGL2PSSpecialProps().
        """
        ...
    
    def Clear(self):
        """
        V.Clear()
        C++: virtual void Clear()
        
        Clear the image to the background color.
        """
        ...
    
    def ClearLights(self):
        """
        V.ClearLights()
        C++: virtual void ClearLights(void)
        
        Internal method temporarily removes lights before reloading them
        into graphics pipeline.
        """
        ...
    
    def ComputeVisiblePropBounds(self, p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.ComputeVisiblePropBounds([float, float, float, float, float,
            float])
        C++: void ComputeVisiblePropBounds(double bounds[6])
        V.ComputeVisiblePropBounds() -> (float, float, float, float,
            float, float)
        C++: double *ComputeVisiblePropBounds()
        
        Compute the bounding box of all the visible props Used in
        ResetCamera() and ResetCameraClippingRange()
        """
        ...
    
    def CreateLight(self):
        """
        V.CreateLight()
        C++: void CreateLight(void)
        
        Create and add a light to renderer.
        """
        ...
    
    def DeviceRender(self):
        """
        V.DeviceRender()
        C++: virtual void DeviceRender()
        
        Create an image. Subclasses of vtkRenderer must implement this
        method.
        """
        ...
    
    def DeviceRenderOpaqueGeometry(self, vtkFrameBufferObjectBase):
        """
        V.DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase)
        C++: virtual void DeviceRenderOpaqueGeometry(
            vtkFrameBufferObjectBase *fbo=nullptr)
        
        Render opaque polygonal geometry. Default implementation just
        calls UpdateOpaquePolygonalGeometry(). Subclasses of vtkRenderer
        that can deal with, e.g. hidden line removal must override this
        method.
        """
        ...
    
    def DeviceRenderTranslucentPolygonalGeometry(self, vtkFrameBufferObjectBase):
        """
        V.DeviceRenderTranslucentPolygonalGeometry(
            vtkFrameBufferObjectBase)
        C++: virtual void DeviceRenderTranslucentPolygonalGeometry(
            vtkFrameBufferObjectBase *fbo=nullptr)
        
        Render translucent polygonal geometry. Default implementation
        just call UpdateTranslucentPolygonalGeometry(). Subclasses of
        vtkRenderer that can deal with depth peeling must override this
        method. If UseDepthPeeling and UseDepthPeelingForVolumes are
        true, volumetric data will be rendered here as well. It updates
        boolean ivar LastRenderingUsedDepthPeeling.
        """
        ...
    
    def DrawOff(self):
        """
        V.DrawOff()
        C++: virtual void DrawOff()
        
        When this flag is off, render commands are ignored.  It is used
        to either multiplex a vtkRenderWindow or render only part of a
        vtkRenderWindow. By default, Draw is on.
        """
        ...
    
    def DrawOn(self):
        """
        V.DrawOn()
        C++: virtual void DrawOn()
        
        When this flag is off, render commands are ignored.  It is used
        to either multiplex a vtkRenderWindow or render only part of a
        vtkRenderWindow. By default, Draw is on.
        """
        ...
    
    def EraseOff(self):
        """
        V.EraseOff()
        C++: virtual void EraseOff()
        
        When this flag is off, the renderer will not erase the background
        or the Zbuffer.  It is used to have overlapping renderers. Both
        the RenderWindow Erase and Render Erase must be on for the camera
        to clear the renderer.  By default, Erase is on.
        """
        ...
    
    def EraseOn(self):
        """
        V.EraseOn()
        C++: virtual void EraseOn()
        
        When this flag is off, the renderer will not erase the background
        or the Zbuffer.  It is used to have overlapping renderers. Both
        the RenderWindow Erase and Render Erase must be on for the camera
        to clear the renderer.  By default, Erase is on.
        """
        ...
    
    def GetActiveCamera(self):
        """
        V.GetActiveCamera() -> vtkCamera
        C++: vtkCamera *GetActiveCamera()
        
        Get the current camera. If there is not camera assigned to the
        renderer already, a new one is created automatically. This does
        *not* reset the camera.
        """
        ...
    
    def GetActors(self):
        """
        V.GetActors() -> vtkActorCollection
        C++: vtkActorCollection *GetActors()
        
        Return any actors in this renderer.
        """
        ...
    
    def GetAllocatedRenderTime(self):
        """
        V.GetAllocatedRenderTime() -> float
        C++: virtual double GetAllocatedRenderTime()
        
        Set/Get the amount of time this renderer is allowed to spend
        rendering its scene. This is used by vtkLODActor's.
        """
        ...
    
    def GetAmbient(self):
        """
        V.GetAmbient() -> (float, float, float)
        C++: virtual double *GetAmbient()
        
        Set the intensity of ambient lighting.
        """
        ...
    
    def GetAutomaticLightCreation(self):
        """
        V.GetAutomaticLightCreation() -> int
        C++: virtual vtkTypeBool GetAutomaticLightCreation()
        
        Turn on/off a flag which disables the automatic light creation
        capability. Normally in VTK if no lights are associated with the
        renderer, then a light is automatically created. However, in
        special circumstances this feature is undesirable, so the
        following boolean is provided to disable automatic light
        creation. (Turn AutomaticLightCreation off if you do not want
        lights to be created.)
        """
        ...
    
    def GetBackgroundTexture(self):
        """
        V.GetBackgroundTexture() -> vtkTexture
        C++: virtual vtkTexture *GetBackgroundTexture()
        
        Set/Get the texture to be used for the monocular or stereo left
        eye background. If set and enabled this gets the priority over
        the gradient background.
        """
        ...
    
    def GetBackingStore(self):
        """
        V.GetBackingStore() -> int
        C++: virtual vtkTypeBool GetBackingStore()
        
        Turn on/off using backing store. This may cause the re-rendering
        time to be slightly slower when the view changes. But it is much
        faster when the image has not changed, such as during an expose
        event.
        """
        ...
    
    def GetClippingRangeExpansion(self):
        """
        V.GetClippingRangeExpansion() -> float
        C++: virtual double GetClippingRangeExpansion()
        
        Specify enlargement of bounds when resetting the camera clipping
        range.  By default the range is not expanded by any percent of
        the (far - near) on the near and far sides
        """
        ...
    
    def GetClippingRangeExpansionMaxValue(self):
        """
        V.GetClippingRangeExpansionMaxValue() -> float
        C++: virtual double GetClippingRangeExpansionMaxValue()
        
        Specify enlargement of bounds when resetting the camera clipping
        range.  By default the range is not expanded by any percent of
        the (far - near) on the near and far sides
        """
        ...
    
    def GetClippingRangeExpansionMinValue(self):
        """
        V.GetClippingRangeExpansionMinValue() -> float
        C++: virtual double GetClippingRangeExpansionMinValue()
        
        Specify enlargement of bounds when resetting the camera clipping
        range.  By default the range is not expanded by any percent of
        the (far - near) on the near and far sides
        """
        ...
    
    def GetCullers(self):
        """
        V.GetCullers() -> vtkCullerCollection
        C++: vtkCullerCollection *GetCullers()
        
        Return the collection of cullers.
        """
        ...
    
    def GetDelegate(self):
        """
        V.GetDelegate() -> vtkRendererDelegate
        C++: virtual vtkRendererDelegate *GetDelegate()
        
        Set/Get a custom Render call. Allows to hook a Render call from
        an external project.It will be used in place of
        vtkRenderer::Render() if it is not NULL and its Used ivar is set
        to true. Initial value is NULL.
        """
        ...
    
    def GetDraw(self):
        """
        V.GetDraw() -> int
        C++: virtual vtkTypeBool GetDraw()
        
        When this flag is off, render commands are ignored.  It is used
        to either multiplex a vtkRenderWindow or render only part of a
        vtkRenderWindow. By default, Draw is on.
        """
        ...
    
    def GetEnvironmentRight(self):
        """
        V.GetEnvironmentRight() -> (float, float, float)
        C++: virtual double *GetEnvironmentRight()
        
        Set/Get the environment right vector.
        """
        ...
    
    def GetEnvironmentTexture(self):
        """
        V.GetEnvironmentTexture() -> vtkTexture
        C++: virtual vtkTexture *GetEnvironmentTexture()
        
        Set/Get the environment texture used for image based lighting.
        This texture is supposed to represent the scene background. If it
        is not a cubemap, the texture is supposed to represent an
        equirectangular projection. If used with raytracing backends, the
        texture must be an equirectangular projection and must be
        constructed with a valid vtkImageData. Warning, this texture must
        be expressed in linear color space. If the texture is in sRGB
        color space, set the color flag on the texture or set the
        argument isSRGB to true.
        @sa vtkTexture::UseSRGBColorSpaceOn
        """
        ...
    
    def GetEnvironmentUp(self):
        """
        V.GetEnvironmentUp() -> (float, float, float)
        C++: virtual double *GetEnvironmentUp()
        
        Set/Get the environment up vector.
        """
        ...
    
    def GetErase(self):
        """
        V.GetErase() -> int
        C++: virtual vtkTypeBool GetErase()
        
        When this flag is off, the renderer will not erase the background
        or the Zbuffer.  It is used to have overlapping renderers. Both
        the RenderWindow Erase and Render Erase must be on for the camera
        to clear the renderer.  By default, Erase is on.
        """
        ...
    
    def GetFXAAOptions(self):
        """
        V.GetFXAAOptions() -> vtkFXAAOptions
        C++: virtual vtkFXAAOptions *GetFXAAOptions()
        
        The configuration object for FXAA antialiasing.
        """
        ...
    
    def GetInformation(self):
        """
        V.GetInformation() -> vtkInformation
        C++: virtual vtkInformation *GetInformation()
        
        Set/Get the information object associated with this algorithm.
        """
        ...
    
    def GetInteractive(self):
        """
        V.GetInteractive() -> int
        C++: virtual vtkTypeBool GetInteractive()
        
        Turn on/off interactive status.  An interactive renderer is one
        that can receive events from an interactor.  Should only be set
        if there are multiple renderers in the same section of the
        viewport.
        """
        ...
    
    def GetLastRenderingUsedDepthPeeling(self):
        """
        V.GetLastRenderingUsedDepthPeeling() -> int
        C++: virtual vtkTypeBool GetLastRenderingUsedDepthPeeling()
        
        Tells if the last call to
        DeviceRenderTranslucentPolygonalGeometry() actually used depth
        peeling. Initial value is false.
        """
        ...
    
    def GetLastRenderTimeInSeconds(self):
        """
        V.GetLastRenderTimeInSeconds() -> float
        C++: virtual double GetLastRenderTimeInSeconds()
        
        Get the time required, in seconds, for the last Render call.
        """
        ...
    
    def GetLayer(self):
        """
        V.GetLayer() -> int
        C++: virtual int GetLayer()
        
        Set/Get the layer that this renderer belongs to.  This is only
        used if there are layered renderers.
        
        * Note: Changing the layer will update the PreserveColorBuffer
          setting. If
        * the layer is 0, PreserveColorBuffer will be set to false,
          making the
        * bottom renderer opaque. If the layer is non-zero,
          PreserveColorBuffer will
        * be set to true, giving the renderer a transparent background.
          If other
        * PreserveColorBuffer configurations are desired, they must be
          adjusted after
        * the layer is set.
        """
        ...
    
    def GetLeftBackgroundTexture(self):
        """
        V.GetLeftBackgroundTexture() -> vtkTexture
        C++: vtkTexture *GetLeftBackgroundTexture()
        
        Set/Get the texture to be used for the monocular or stereo left
        eye background. If set and enabled this gets the priority over
        the gradient background.
        """
        ...
    
    def GetLightFollowCamera(self):
        """
        V.GetLightFollowCamera() -> int
        C++: virtual vtkTypeBool GetLightFollowCamera()
        
        Turn on/off the automatic repositioning of lights as the camera
        moves. If LightFollowCamera is on, lights that are designated as
        Headlights or CameraLights will be adjusted to move with this
        renderer's camera. If LightFollowCamera is off, the lights will
        not be adjusted.
        
        * (Note: In previous versions of vtk, this light-tracking
        * functionality was part of the interactors, not the renderer.
          For
        * backwards compatibility, the older, more limited interactor
        * behavior is enabled by default. To disable this mode, turn the
        * interactor's LightFollowCamera flag OFF, and leave the
          renderer's
        * LightFollowCamera flag ON.)
        """
        ...
    
    def GetLights(self):
        """
        V.GetLights() -> vtkLightCollection
        C++: vtkLightCollection *GetLights()
        
        Return the collection of lights.
        """
        ...
    
    def GetMaximumNumberOfPeels(self):
        """
        V.GetMaximumNumberOfPeels() -> int
        C++: virtual int GetMaximumNumberOfPeels()
        
        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.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Return the MTime of the renderer also considering its ivars.
        """
        ...
    
    def GetNearClippingPlaneTolerance(self):
        """
        V.GetNearClippingPlaneTolerance() -> float
        C++: virtual double GetNearClippingPlaneTolerance()
        
        Specify tolerance for near clipping plane distance to the camera
        as a percentage of the far clipping plane distance. By default
        this will be set to 0.01 for 16 bit zbuffers and 0.001 for higher
        depth z buffers
        """
        ...
    
    def GetNearClippingPlaneToleranceMaxValue(self):
        """
        V.GetNearClippingPlaneToleranceMaxValue() -> float
        C++: virtual double GetNearClippingPlaneToleranceMaxValue()
        
        Specify tolerance for near clipping plane distance to the camera
        as a percentage of the far clipping plane distance. By default
        this will be set to 0.01 for 16 bit zbuffers and 0.001 for higher
        depth z buffers
        """
        ...
    
    def GetNearClippingPlaneToleranceMinValue(self):
        """
        V.GetNearClippingPlaneToleranceMinValue() -> float
        C++: virtual double GetNearClippingPlaneToleranceMinValue()
        
        Specify tolerance for near clipping plane distance to the camera
        as a percentage of the far clipping plane distance. By default
        this will be set to 0.01 for 16 bit zbuffers and 0.001 for higher
        depth z buffers
        """
        ...
    
    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 GetNumberOfPropsRendered(self):
        """
        V.GetNumberOfPropsRendered() -> int
        C++: virtual int GetNumberOfPropsRendered()
        
        Should be used internally only during a render Get the number of
        props that were rendered using a RenderOpaqueGeometry or
        RenderTranslucentPolygonalGeometry call. This is used to know if
        something is in the frame buffer.
        """
        ...
    
    def GetOcclusionRatio(self):
        """
        V.GetOcclusionRatio() -> float
        C++: virtual double GetOcclusionRatio()
        
        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.
        """
        ...
    
    def GetOcclusionRatioMaxValue(self):
        """
        V.GetOcclusionRatioMaxValue() -> float
        C++: virtual double GetOcclusionRatioMaxValue()
        
        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.
        """
        ...
    
    def GetOcclusionRatioMinValue(self):
        """
        V.GetOcclusionRatioMinValue() -> float
        C++: virtual double GetOcclusionRatioMinValue()
        
        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.
        """
        ...
    
    def GetPass(self):
        """
        V.GetPass() -> vtkRenderPass
        C++: virtual vtkRenderPass *GetPass()
        """
        ...
    
    def GetPreserveColorBuffer(self):
        """
        V.GetPreserveColorBuffer() -> int
        C++: virtual vtkTypeBool GetPreserveColorBuffer()
        
        By default, the renderer at layer 0 is opaque, and all non-zero
        layer renderers are transparent. This flag allows this behavior
        to be overridden. If true, this setting will force the renderer
        to preserve the existing color buffer regardless of layer. If
        false, it will always be cleared at the start of rendering.
        
        * This flag influences the Transparent() method, and is updated
          by calls to
        * SetLayer(). For this reason it should only be set after
          changing the layer.
        """
        ...
    
    def GetPreserveDepthBuffer(self):
        """
        V.GetPreserveDepthBuffer() -> int
        C++: virtual vtkTypeBool GetPreserveDepthBuffer()
        
        By default, the depth buffer is reset for each renderer. If this
        flag is true, this renderer will use the existing depth buffer
        for its rendering.
        """
        ...
    
    def GetRenderWindow(self):
        """
        V.GetRenderWindow() -> vtkRenderWindow
        C++: vtkRenderWindow *GetRenderWindow()
        
        Specify the rendering window in which to draw. This is
        automatically set when the renderer is created by MakeRenderer. 
        The user probably shouldn't ever need to call this method.
        """
        ...
    
    def GetRightBackgroundTexture(self):
        """
        V.GetRightBackgroundTexture() -> vtkTexture
        C++: virtual vtkTexture *GetRightBackgroundTexture()
        
        Set/Get the texture to be used for the right eye background. If
        set and enabled this gets the priority over the gradient
        background.
        """
        ...
    
    def GetSelector(self):
        """
        V.GetSelector() -> vtkHardwareSelector
        C++: virtual vtkHardwareSelector *GetSelector()
        
        Get the current hardware selector. If the Selector is set, it
        implies the current render pass is for selection.
        Mappers/Properties may choose to behave differently when
        rendering for hardware selection.
        """
        ...
    
    def GetTexturedBackground(self):
        """
        V.GetTexturedBackground() -> bool
        C++: virtual bool GetTexturedBackground()
        
        Set/Get whether this viewport should have a textured background.
        Default is off.
        """
        ...
    
    def GetTiledAspectRatio(self):
        """
        V.GetTiledAspectRatio() -> float
        C++: double GetTiledAspectRatio()
        
        Compute the aspect ratio of this renderer for the current tile.
        When tiled displays are used the aspect ratio of the renderer for
        a given tile may be different that the aspect ratio of the
        renderer when rendered in it entirety
        """
        ...
    
    def GetTimeFactor(self):
        """
        V.GetTimeFactor() -> float
        C++: virtual double GetTimeFactor()
        
        Get the ratio between allocated time and actual render time.
        TimeFactor has been taken out of the render process. It is still
        computed in case someone finds it useful. It may be taken away in
        the future.
        """
        ...
    
    def GetTwoSidedLighting(self):
        """
        V.GetTwoSidedLighting() -> int
        C++: virtual vtkTypeBool GetTwoSidedLighting()
        
        Turn on/off two-sided lighting of surfaces. If two-sided lighting
        is off, then only the side of the surface facing the light(s)
        will be lit, and the other side dark. If two-sided lighting on,
        both sides of the surface will be lit.
        """
        ...
    
    def GetUseDepthPeeling(self):
        """
        V.GetUseDepthPeeling() -> int
        C++: virtual vtkTypeBool GetUseDepthPeeling()
        
        Turn on/off rendering of translucent material with depth peeling
        technique. The render window must have alpha bits (ie call
        SetAlphaBitPlanes(1)) and no multisample buffer (ie call
        SetMultiSamples(0) ) to support depth peeling. If UseDepthPeeling
        is on and the GPU supports it, depth peeling is used for
        rendering translucent materials. If UseDepthPeeling is off, alpha
        blending is used. Initial value is off.
        """
        ...
    
    def GetUseDepthPeelingForVolumes(self):
        """
        V.GetUseDepthPeelingForVolumes() -> bool
        C++: virtual bool GetUseDepthPeelingForVolumes()
        """
        ...
    
    def GetUseFXAA(self):
        """
        V.GetUseFXAA() -> bool
        C++: virtual bool GetUseFXAA()
        
        Turn on/off FXAA anti-aliasing, if supported. Initial value is
        off.
        """
        ...
    
    def GetUseHiddenLineRemoval(self):
        """
        V.GetUseHiddenLineRemoval() -> int
        C++: virtual vtkTypeBool GetUseHiddenLineRemoval()
        
        If this flag is true and the rendering engine supports it,
        wireframe geometry will be drawn using hidden line removal.
        """
        ...
    
    def GetUseImageBasedLighting(self):
        """
        V.GetUseImageBasedLighting() -> bool
        C++: virtual bool GetUseImageBasedLighting()
        
        If this flag is true and the rendering engine supports it, image
        based lighting is enabled and surface rendering displays
        environment reflections. The input cube map have to be set with
        SetEnvironmentCubeMap. If not cubemap is specified, this feature
        is disable.
        """
        ...
    
    def GetUseShadows(self):
        """
        V.GetUseShadows() -> int
        C++: virtual vtkTypeBool GetUseShadows()
        
        Turn on/off rendering of shadows if supported Initial value is
        off.
        """
        ...
    
    def GetVolumes(self):
        """
        V.GetVolumes() -> vtkVolumeCollection
        C++: vtkVolumeCollection *GetVolumes()
        
        Return the collection of volumes.
        """
        ...
    
    def GetVTKWindow(self):
        """
        V.GetVTKWindow() -> vtkWindow
        C++: vtkWindow *GetVTKWindow() override;
        
        Specify the rendering window in which to draw. This is
        automatically set when the renderer is created by MakeRenderer. 
        The user probably shouldn't ever need to call this method.
        """
        ...
    
    def GetZ(self, p_int, p_int_1):
        """
        V.GetZ(int, int) -> float
        C++: double GetZ(int x, int y)
        
        Given a pixel location, return the Z value. The z value is
        normalized (0,1) between the front and back clipping planes.
        """
        ...
    
    def InteractiveOff(self):
        """
        V.InteractiveOff()
        C++: virtual void InteractiveOff()
        
        Turn on/off interactive status.  An interactive renderer is one
        that can receive events from an interactor.  Should only be set
        if there are multiple renderers in the same section of the
        viewport.
        """
        ...
    
    def InteractiveOn(self):
        """
        V.InteractiveOn()
        C++: virtual void InteractiveOn()
        
        Turn on/off interactive status.  An interactive renderer is one
        that can receive events from an interactor.  Should only be set
        if there are multiple renderers in the same section of the
        viewport.
        """
        ...
    
    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 IsActiveCameraCreated(self):
        """
        V.IsActiveCameraCreated() -> int
        C++: vtkTypeBool IsActiveCameraCreated()
        
        This method returns 1 if the ActiveCamera has already been set or
        automatically created by the renderer. It returns 0 if the
        ActiveCamera does not yet exist.
        """
        ...
    
    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 LightFollowCameraOff(self):
        """
        V.LightFollowCameraOff()
        C++: virtual void LightFollowCameraOff()
        
        Turn on/off the automatic repositioning of lights as the camera
        moves. If LightFollowCamera is on, lights that are designated as
        Headlights or CameraLights will be adjusted to move with this
        renderer's camera. If LightFollowCamera is off, the lights will
        not be adjusted.
        
        * (Note: In previous versions of vtk, this light-tracking
        * functionality was part of the interactors, not the renderer.
          For
        * backwards compatibility, the older, more limited interactor
        * behavior is enabled by default. To disable this mode, turn the
        * interactor's LightFollowCamera flag OFF, and leave the
          renderer's
        * LightFollowCamera flag ON.)
        """
        ...
    
    def LightFollowCameraOn(self):
        """
        V.LightFollowCameraOn()
        C++: virtual void LightFollowCameraOn()
        
        Turn on/off the automatic repositioning of lights as the camera
        moves. If LightFollowCamera is on, lights that are designated as
        Headlights or CameraLights will be adjusted to move with this
        renderer's camera. If LightFollowCamera is off, the lights will
        not be adjusted.
        
        * (Note: In previous versions of vtk, this light-tracking
        * functionality was part of the interactors, not the renderer.
          For
        * backwards compatibility, the older, more limited interactor
        * behavior is enabled by default. To disable this mode, turn the
        * interactor's LightFollowCamera flag OFF, and leave the
          renderer's
        * LightFollowCamera flag ON.)
        """
        ...
    
    def MakeCamera(self):
        """
        V.MakeCamera() -> vtkCamera
        C++: virtual vtkCamera *MakeCamera()
        
        Create a new Camera sutible for use with this type of Renderer.
        For example, a vtkMesaRenderer should create a vtkMesaCamera in
        this function.   The default is to just call vtkCamera::New.
        """
        ...
    
    def MakeLight(self):
        """
        V.MakeLight() -> vtkLight
        C++: virtual vtkLight *MakeLight()
        
        Create a new Light sutible for use with this type of Renderer.
        For example, a vtkMesaRenderer should create a vtkMesaLight in
        this function.   The default is to just call vtkLight::New.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkRenderer
        C++: vtkRenderer *NewInstance()
        """
        ...
    
    def PickProp(self, p_float, p_float_1):
        """
        V.PickProp(float, float) -> vtkAssemblyPath
        C++: vtkAssemblyPath *PickProp(double selectionX,
            double selectionY) override;
        V.PickProp(float, float, float, float) -> vtkAssemblyPath
        C++: vtkAssemblyPath *PickProp(double selectionX1,
            double selectionY1, double selectionX2, double selectionY2)
            override;
        
        Return the prop (via a vtkAssemblyPath) that has the highest z
        value at the given x, y position in the viewport.  Basically, the
        top most prop that renders the pixel at selectionX, selectionY
        will be returned. If nothing was picked then NULL is returned. 
        This method selects from the renderers Prop list.
        """
        ...
    
    def PoseToView(self, p_float, p_float_1, p_float_2):
        """
        V.PoseToView(float, float, float)
        C++: void PoseToView(double &wx, double &wy, double &wz) override;
        
        Convert to from pose coordinates
        """
        ...
    
    def PoseToWorld(self, p_float, p_float_1, p_float_2):
        """
        V.PoseToWorld(float, float, float)
        C++: void PoseToWorld(double &wx, double &wy, double &wz)
            override;
        
        Convert to from pose coordinates
        """
        ...
    
    def PreserveColorBufferOff(self):
        """
        V.PreserveColorBufferOff()
        C++: virtual void PreserveColorBufferOff()
        
        By default, the renderer at layer 0 is opaque, and all non-zero
        layer renderers are transparent. This flag allows this behavior
        to be overridden. If true, this setting will force the renderer
        to preserve the existing color buffer regardless of layer. If
        false, it will always be cleared at the start of rendering.
        
        * This flag influences the Transparent() method, and is updated
          by calls to
        * SetLayer(). For this reason it should only be set after
          changing the layer.
        """
        ...
    
    def PreserveColorBufferOn(self):
        """
        V.PreserveColorBufferOn()
        C++: virtual void PreserveColorBufferOn()
        
        By default, the renderer at layer 0 is opaque, and all non-zero
        layer renderers are transparent. This flag allows this behavior
        to be overridden. If true, this setting will force the renderer
        to preserve the existing color buffer regardless of layer. If
        false, it will always be cleared at the start of rendering.
        
        * This flag influences the Transparent() method, and is updated
          by calls to
        * SetLayer(). For this reason it should only be set after
          changing the layer.
        """
        ...
    
    def PreserveDepthBufferOff(self):
        """
        V.PreserveDepthBufferOff()
        C++: virtual void PreserveDepthBufferOff()
        
        By default, the depth buffer is reset for each renderer. If this
        flag is true, this renderer will use the existing depth buffer
        for its rendering.
        """
        ...
    
    def PreserveDepthBufferOn(self):
        """
        V.PreserveDepthBufferOn()
        C++: virtual void PreserveDepthBufferOn()
        
        By default, the depth buffer is reset for each renderer. If this
        flag is true, this renderer will use the existing depth buffer
        for its rendering.
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: virtual void ReleaseGraphicsResources(vtkWindow *)
        """
        ...
    
    def RemoveActor(self, vtkProp):
        """
        V.RemoveActor(vtkProp)
        C++: void RemoveActor(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def RemoveAllLights(self):
        """
        V.RemoveAllLights()
        C++: void RemoveAllLights()
        
        Remove all lights from the list of lights.
        """
        ...
    
    def RemoveCuller(self, vtkCuller):
        """
        V.RemoveCuller(vtkCuller)
        C++: void RemoveCuller(vtkCuller *)
        
        Remove an actor from the list of cullers.
        """
        ...
    
    def RemoveLight(self, vtkLight):
        """
        V.RemoveLight(vtkLight)
        C++: void RemoveLight(vtkLight *)
        
        Remove a light from the list of lights.
        """
        ...
    
    def RemoveVolume(self, vtkProp):
        """
        V.RemoveVolume(vtkProp)
        C++: void RemoveVolume(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def Render(self):
        """
        V.Render()
        C++: virtual void Render()
        
        CALLED BY vtkRenderWindow ONLY. End-user pass your way and call
        vtkRenderWindow::Render(). Create an image. This is a superclass
        method which will in turn call the DeviceRender method of
        Subclasses of vtkRenderer.
        """
        ...
    
    def ResetCamera(self):
        """
        V.ResetCamera()
        C++: virtual void ResetCamera()
        V.ResetCamera([float, float, float, float, float, float])
        C++: virtual void ResetCamera(double bounds[6])
        V.ResetCamera(float, float, float, float, float, float)
        C++: virtual void ResetCamera(double xmin, double xmax,
            double ymin, double ymax, double zmin, double zmax)
        
        Automatically set up the camera based on the visible actors. The
        camera will reposition itself to view the center point of the
        actors, and move along its initial view plane normal (i.e.,
        vector defined from camera position to focal point) so that all
        of the actors can be seen.
        """
        ...
    
    def ResetCameraClippingRange(self):
        """
        V.ResetCameraClippingRange()
        C++: virtual void ResetCameraClippingRange()
        V.ResetCameraClippingRange([float, float, float, float, float,
            float])
        C++: virtual void ResetCameraClippingRange(double bounds[6])
        V.ResetCameraClippingRange(float, float, float, float, float,
            float)
        C++: virtual void ResetCameraClippingRange(double xmin,
            double xmax, double ymin, double ymax, double zmin,
            double zmax)
        
        Reset the camera clipping range based on the bounds of the
        visible actors. This ensures that no props are cut off
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkRenderer
        C++: static vtkRenderer *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetActiveCamera(self, vtkCamera):
        """
        V.SetActiveCamera(vtkCamera)
        C++: void SetActiveCamera(vtkCamera *)
        
        Specify the camera to use for this renderer.
        """
        ...
    
    def SetAllocatedRenderTime(self, p_float):
        """
        V.SetAllocatedRenderTime(float)
        C++: virtual void SetAllocatedRenderTime(double _arg)
        
        Set/Get the amount of time this renderer is allowed to spend
        rendering its scene. This is used by vtkLODActor's.
        """
        ...
    
    def SetAmbient(self, p_float, p_float_1, p_float_2):
        """
        V.SetAmbient(float, float, float)
        C++: virtual void SetAmbient(double _arg1, double _arg2,
            double _arg3)
        V.SetAmbient((float, float, float))
        C++: virtual void SetAmbient(const double _arg[3])
        
        Set the intensity of ambient lighting.
        """
        ...
    
    def SetAutomaticLightCreation(self, p_int):
        """
        V.SetAutomaticLightCreation(int)
        C++: virtual void SetAutomaticLightCreation(vtkTypeBool _arg)
        
        Turn on/off a flag which disables the automatic light creation
        capability. Normally in VTK if no lights are associated with the
        renderer, then a light is automatically created. However, in
        special circumstances this feature is undesirable, so the
        following boolean is provided to disable automatic light
        creation. (Turn AutomaticLightCreation off if you do not want
        lights to be created.)
        """
        ...
    
    def SetBackgroundTexture(self, vtkTexture):
        """
        V.SetBackgroundTexture(vtkTexture)
        C++: virtual void SetBackgroundTexture(vtkTexture *)
        
        Set/Get the texture to be used for the monocular or stereo left
        eye background. If set and enabled this gets the priority over
        the gradient background.
        """
        ...
    
    def SetBackingStore(self, p_int):
        """
        V.SetBackingStore(int)
        C++: virtual void SetBackingStore(vtkTypeBool _arg)
        
        Turn on/off using backing store. This may cause the re-rendering
        time to be slightly slower when the view changes. But it is much
        faster when the image has not changed, such as during an expose
        event.
        """
        ...
    
    def SetClippingRangeExpansion(self, p_float):
        """
        V.SetClippingRangeExpansion(float)
        C++: virtual void SetClippingRangeExpansion(double _arg)
        
        Specify enlargement of bounds when resetting the camera clipping
        range.  By default the range is not expanded by any percent of
        the (far - near) on the near and far sides
        """
        ...
    
    def SetDelegate(self, vtkRendererDelegate):
        """
        V.SetDelegate(vtkRendererDelegate)
        C++: void SetDelegate(vtkRendererDelegate *d)
        
        Set/Get a custom Render call. Allows to hook a Render call from
        an external project.It will be used in place of
        vtkRenderer::Render() if it is not NULL and its Used ivar is set
        to true. Initial value is NULL.
        """
        ...
    
    def SetDraw(self, p_int):
        """
        V.SetDraw(int)
        C++: virtual void SetDraw(vtkTypeBool _arg)
        
        When this flag is off, render commands are ignored.  It is used
        to either multiplex a vtkRenderWindow or render only part of a
        vtkRenderWindow. By default, Draw is on.
        """
        ...
    
    def SetEnvironmentRight(self, p_float, p_float_1, p_float_2):
        """
        V.SetEnvironmentRight(float, float, float)
        C++: virtual void SetEnvironmentRight(double _arg1, double _arg2,
            double _arg3)
        V.SetEnvironmentRight((float, float, float))
        C++: virtual void SetEnvironmentRight(const double _arg[3])
        
        Set/Get the environment right vector.
        """
        ...
    
    def SetEnvironmentTexture(self, vtkTexture, bool):
        """
        V.SetEnvironmentTexture(vtkTexture, bool)
        C++: virtual void SetEnvironmentTexture(vtkTexture *texture,
            bool isSRGB=false)
        
        Set/Get the environment texture used for image based lighting.
        This texture is supposed to represent the scene background. If it
        is not a cubemap, the texture is supposed to represent an
        equirectangular projection. If used with raytracing backends, the
        texture must be an equirectangular projection and must be
        constructed with a valid vtkImageData. Warning, this texture must
        be expressed in linear color space. If the texture is in sRGB
        color space, set the color flag on the texture or set the
        argument isSRGB to true.
        @sa vtkTexture::UseSRGBColorSpaceOn
        """
        ...
    
    def SetEnvironmentUp(self, p_float, p_float_1, p_float_2):
        """
        V.SetEnvironmentUp(float, float, float)
        C++: virtual void SetEnvironmentUp(double _arg1, double _arg2,
            double _arg3)
        V.SetEnvironmentUp((float, float, float))
        C++: virtual void SetEnvironmentUp(const double _arg[3])
        
        Set/Get the environment up vector.
        """
        ...
    
    def SetErase(self, p_int):
        """
        V.SetErase(int)
        C++: virtual void SetErase(vtkTypeBool _arg)
        
        When this flag is off, the renderer will not erase the background
        or the Zbuffer.  It is used to have overlapping renderers. Both
        the RenderWindow Erase and Render Erase must be on for the camera
        to clear the renderer.  By default, Erase is on.
        """
        ...
    
    def SetFXAAOptions(self, vtkFXAAOptions):
        """
        V.SetFXAAOptions(vtkFXAAOptions)
        C++: virtual void SetFXAAOptions(vtkFXAAOptions *)
        
        The configuration object for FXAA antialiasing.
        """
        ...
    
    def SetGL2PSSpecialPropCollection(self, vtkPropCollection):
        """
        V.SetGL2PSSpecialPropCollection(vtkPropCollection)
        C++: void SetGL2PSSpecialPropCollection(vtkPropCollection *)
        
        Set the prop collection object used during
        vtkRenderWindow::CaptureGL2PSSpecialProps(). Do not call
        manually, this is handled automatically by the render window.
        """
        ...
    
    def SetInformation(self, vtkInformation):
        """
        V.SetInformation(vtkInformation)
        C++: virtual void SetInformation(vtkInformation *)
        
        Set/Get the information object associated with this algorithm.
        """
        ...
    
    def SetInteractive(self, p_int):
        """
        V.SetInteractive(int)
        C++: virtual void SetInteractive(vtkTypeBool _arg)
        
        Turn on/off interactive status.  An interactive renderer is one
        that can receive events from an interactor.  Should only be set
        if there are multiple renderers in the same section of the
        viewport.
        """
        ...
    
    def SetLayer(self, p_int):
        """
        V.SetLayer(int)
        C++: virtual void SetLayer(int layer)
        
        Set/Get the layer that this renderer belongs to.  This is only
        used if there are layered renderers.
        
        * Note: Changing the layer will update the PreserveColorBuffer
          setting. If
        * the layer is 0, PreserveColorBuffer will be set to false,
          making the
        * bottom renderer opaque. If the layer is non-zero,
          PreserveColorBuffer will
        * be set to true, giving the renderer a transparent background.
          If other
        * PreserveColorBuffer configurations are desired, they must be
          adjusted after
        * the layer is set.
        """
        ...
    
    def SetLeftBackgroundTexture(self, vtkTexture):
        """
        V.SetLeftBackgroundTexture(vtkTexture)
        C++: virtual void SetLeftBackgroundTexture(vtkTexture *)
        
        Set/Get the texture to be used for the monocular or stereo left
        eye background. If set and enabled this gets the priority over
        the gradient background.
        """
        ...
    
    def SetLightCollection(self, vtkLightCollection):
        """
        V.SetLightCollection(vtkLightCollection)
        C++: void SetLightCollection(vtkLightCollection *lights)
        
        Set the collection of lights. We cannot name it SetLights because
        of TestSetGet
        \pre lights_exist: lights!=0
        \post lights_set: lights==this->GetLights()
        """
        ...
    
    def SetLightFollowCamera(self, p_int):
        """
        V.SetLightFollowCamera(int)
        C++: virtual void SetLightFollowCamera(vtkTypeBool _arg)
        
        Turn on/off the automatic repositioning of lights as the camera
        moves. If LightFollowCamera is on, lights that are designated as
        Headlights or CameraLights will be adjusted to move with this
        renderer's camera. If LightFollowCamera is off, the lights will
        not be adjusted.
        
        * (Note: In previous versions of vtk, this light-tracking
        * functionality was part of the interactors, not the renderer.
          For
        * backwards compatibility, the older, more limited interactor
        * behavior is enabled by default. To disable this mode, turn the
        * interactor's LightFollowCamera flag OFF, and leave the
          renderer's
        * LightFollowCamera flag ON.)
        """
        ...
    
    def SetMaximumNumberOfPeels(self, p_int):
        """
        V.SetMaximumNumberOfPeels(int)
        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.
        """
        ...
    
    def SetNearClippingPlaneTolerance(self, p_float):
        """
        V.SetNearClippingPlaneTolerance(float)
        C++: virtual void SetNearClippingPlaneTolerance(double _arg)
        
        Specify tolerance for near clipping plane distance to the camera
        as a percentage of the far clipping plane distance. By default
        this will be set to 0.01 for 16 bit zbuffers and 0.001 for higher
        depth z buffers
        """
        ...
    
    def SetOcclusionRatio(self, p_float):
        """
        V.SetOcclusionRatio(float)
        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.
        """
        ...
    
    def SetPass(self, vtkRenderPass):
        """
        V.SetPass(vtkRenderPass)
        C++: void SetPass(vtkRenderPass *p)
        """
        ...
    
    def SetPreserveColorBuffer(self, p_int):
        """
        V.SetPreserveColorBuffer(int)
        C++: virtual void SetPreserveColorBuffer(vtkTypeBool _arg)
        
        By default, the renderer at layer 0 is opaque, and all non-zero
        layer renderers are transparent. This flag allows this behavior
        to be overridden. If true, this setting will force the renderer
        to preserve the existing color buffer regardless of layer. If
        false, it will always be cleared at the start of rendering.
        
        * This flag influences the Transparent() method, and is updated
          by calls to
        * SetLayer(). For this reason it should only be set after
          changing the layer.
        """
        ...
    
    def SetPreserveDepthBuffer(self, p_int):
        """
        V.SetPreserveDepthBuffer(int)
        C++: virtual void SetPreserveDepthBuffer(vtkTypeBool _arg)
        
        By default, the depth buffer is reset for each renderer. If this
        flag is true, this renderer will use the existing depth buffer
        for its rendering.
        """
        ...
    
    def SetRenderWindow(self, vtkRenderWindow):
        """
        V.SetRenderWindow(vtkRenderWindow)
        C++: void SetRenderWindow(vtkRenderWindow *)
        
        Specify the rendering window in which to draw. This is
        automatically set when the renderer is created by MakeRenderer. 
        The user probably shouldn't ever need to call this method.
        """
        ...
    
    def SetRightBackgroundTexture(self, vtkTexture):
        """
        V.SetRightBackgroundTexture(vtkTexture)
        C++: virtual void SetRightBackgroundTexture(vtkTexture *)
        
        Set/Get the texture to be used for the right eye background. If
        set and enabled this gets the priority over the gradient
        background.
        """
        ...
    
    def SetTexturedBackground(self, bool):
        """
        V.SetTexturedBackground(bool)
        C++: virtual void SetTexturedBackground(bool _arg)
        
        Set/Get whether this viewport should have a textured background.
        Default is off.
        """
        ...
    
    def SetTwoSidedLighting(self, p_int):
        """
        V.SetTwoSidedLighting(int)
        C++: virtual void SetTwoSidedLighting(vtkTypeBool _arg)
        
        Turn on/off two-sided lighting of surfaces. If two-sided lighting
        is off, then only the side of the surface facing the light(s)
        will be lit, and the other side dark. If two-sided lighting on,
        both sides of the surface will be lit.
        """
        ...
    
    def SetUseDepthPeeling(self, p_int):
        """
        V.SetUseDepthPeeling(int)
        C++: virtual void SetUseDepthPeeling(vtkTypeBool _arg)
        
        Turn on/off rendering of translucent material with depth peeling
        technique. The render window must have alpha bits (ie call
        SetAlphaBitPlanes(1)) and no multisample buffer (ie call
        SetMultiSamples(0) ) to support depth peeling. If UseDepthPeeling
        is on and the GPU supports it, depth peeling is used for
        rendering translucent materials. If UseDepthPeeling is off, alpha
        blending is used. Initial value is off.
        """
        ...
    
    def SetUseDepthPeelingForVolumes(self, bool):
        """
        V.SetUseDepthPeelingForVolumes(bool)
        C++: virtual void SetUseDepthPeelingForVolumes(bool _arg)
        
        This flag is on and the GPU supports it, depth-peel volumes along
        with the translucent geometry. Only supported on OpenGL2 with
        dual-depth peeling. Default is false.
        """
        ...
    
    def SetUseFXAA(self, bool):
        """
        V.SetUseFXAA(bool)
        C++: virtual void SetUseFXAA(bool _arg)
        
        Turn on/off FXAA anti-aliasing, if supported. Initial value is
        off.
        """
        ...
    
    def SetUseHiddenLineRemoval(self, p_int):
        """
        V.SetUseHiddenLineRemoval(int)
        C++: virtual void SetUseHiddenLineRemoval(vtkTypeBool _arg)
        
        If this flag is true and the rendering engine supports it,
        wireframe geometry will be drawn using hidden line removal.
        """
        ...
    
    def SetUseImageBasedLighting(self, bool):
        """
        V.SetUseImageBasedLighting(bool)
        C++: virtual void SetUseImageBasedLighting(bool _arg)
        
        If this flag is true and the rendering engine supports it, image
        based lighting is enabled and surface rendering displays
        environment reflections. The input cube map have to be set with
        SetEnvironmentCubeMap. If not cubemap is specified, this feature
        is disable.
        """
        ...
    
    def SetUseShadows(self, p_int):
        """
        V.SetUseShadows(int)
        C++: virtual void SetUseShadows(vtkTypeBool _arg)
        
        Turn on/off rendering of shadows if supported Initial value is
        off.
        """
        ...
    
    def StereoMidpoint(self):
        """
        V.StereoMidpoint()
        C++: virtual void StereoMidpoint()
        
        Do anything necessary between rendering the left and right
        viewpoints in a stereo render. Doesn't do anything except in the
        derived vtkIceTRenderer in ParaView.
        """
        ...
    
    def TexturedBackgroundOff(self):
        """
        V.TexturedBackgroundOff()
        C++: virtual void TexturedBackgroundOff()
        
        Set/Get whether this viewport should have a textured background.
        Default is off.
        """
        ...
    
    def TexturedBackgroundOn(self):
        """
        V.TexturedBackgroundOn()
        C++: virtual void TexturedBackgroundOn()
        
        Set/Get whether this viewport should have a textured background.
        Default is off.
        """
        ...
    
    def Transparent(self):
        """
        V.Transparent() -> int
        C++: int Transparent()
        
        Returns a boolean indicating if this renderer is transparent.  It
        is transparent if it is not in the deepest layer of its render
        window.
        """
        ...
    
    def TwoSidedLightingOff(self):
        """
        V.TwoSidedLightingOff()
        C++: virtual void TwoSidedLightingOff()
        
        Turn on/off two-sided lighting of surfaces. If two-sided lighting
        is off, then only the side of the surface facing the light(s)
        will be lit, and the other side dark. If two-sided lighting on,
        both sides of the surface will be lit.
        """
        ...
    
    def TwoSidedLightingOn(self):
        """
        V.TwoSidedLightingOn()
        C++: virtual void TwoSidedLightingOn()
        
        Turn on/off two-sided lighting of surfaces. If two-sided lighting
        is off, then only the side of the surface facing the light(s)
        will be lit, and the other side dark. If two-sided lighting on,
        both sides of the surface will be lit.
        """
        ...
    
    def UpdateLightsGeometryToFollowCamera(self):
        """
        V.UpdateLightsGeometryToFollowCamera() -> int
        C++: virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void)
        
        Ask the lights in the scene that are not in world space (for
        instance, Headlights or CameraLights that are attached to the
        camera) to update their geometry to match the active camera.
        """
        ...
    
    def UseDepthPeelingForVolumesOff(self):
        """
        V.UseDepthPeelingForVolumesOff()
        C++: virtual void UseDepthPeelingForVolumesOff()
        """
        ...
    
    def UseDepthPeelingForVolumesOn(self):
        """
        V.UseDepthPeelingForVolumesOn()
        C++: virtual void UseDepthPeelingForVolumesOn()
        """
        ...
    
    def UseDepthPeelingOff(self):
        """
        V.UseDepthPeelingOff()
        C++: virtual void UseDepthPeelingOff()
        
        Turn on/off rendering of translucent material with depth peeling
        technique. The render window must have alpha bits (ie call
        SetAlphaBitPlanes(1)) and no multisample buffer (ie call
        SetMultiSamples(0) ) to support depth peeling. If UseDepthPeeling
        is on and the GPU supports it, depth peeling is used for
        rendering translucent materials. If UseDepthPeeling is off, alpha
        blending is used. Initial value is off.
        """
        ...
    
    def UseDepthPeelingOn(self):
        """
        V.UseDepthPeelingOn()
        C++: virtual void UseDepthPeelingOn()
        
        Turn on/off rendering of translucent material with depth peeling
        technique. The render window must have alpha bits (ie call
        SetAlphaBitPlanes(1)) and no multisample buffer (ie call
        SetMultiSamples(0) ) to support depth peeling. If UseDepthPeeling
        is on and the GPU supports it, depth peeling is used for
        rendering translucent materials. If UseDepthPeeling is off, alpha
        blending is used. Initial value is off.
        """
        ...
    
    def UseFXAAOff(self):
        """
        V.UseFXAAOff()
        C++: virtual void UseFXAAOff()
        
        Turn on/off FXAA anti-aliasing, if supported. Initial value is
        off.
        """
        ...
    
    def UseFXAAOn(self):
        """
        V.UseFXAAOn()
        C++: virtual void UseFXAAOn()
        
        Turn on/off FXAA anti-aliasing, if supported. Initial value is
        off.
        """
        ...
    
    def UseHiddenLineRemovalOff(self):
        """
        V.UseHiddenLineRemovalOff()
        C++: virtual void UseHiddenLineRemovalOff()
        
        If this flag is true and the rendering engine supports it,
        wireframe geometry will be drawn using hidden line removal.
        """
        ...
    
    def UseHiddenLineRemovalOn(self):
        """
        V.UseHiddenLineRemovalOn()
        C++: virtual void UseHiddenLineRemovalOn()
        
        If this flag is true and the rendering engine supports it,
        wireframe geometry will be drawn using hidden line removal.
        """
        ...
    
    def UseImageBasedLightingOff(self):
        """
        V.UseImageBasedLightingOff()
        C++: virtual void UseImageBasedLightingOff()
        
        If this flag is true and the rendering engine supports it, image
        based lighting is enabled and surface rendering displays
        environment reflections. The input cube map have to be set with
        SetEnvironmentCubeMap. If not cubemap is specified, this feature
        is disable.
        """
        ...
    
    def UseImageBasedLightingOn(self):
        """
        V.UseImageBasedLightingOn()
        C++: virtual void UseImageBasedLightingOn()
        
        If this flag is true and the rendering engine supports it, image
        based lighting is enabled and surface rendering displays
        environment reflections. The input cube map have to be set with
        SetEnvironmentCubeMap. If not cubemap is specified, this feature
        is disable.
        """
        ...
    
    def UseShadowsOff(self):
        """
        V.UseShadowsOff()
        C++: virtual void UseShadowsOff()
        
        Turn on/off rendering of shadows if supported Initial value is
        off.
        """
        ...
    
    def UseShadowsOn(self):
        """
        V.UseShadowsOn()
        C++: virtual void UseShadowsOn()
        
        Turn on/off rendering of shadows if supported Initial value is
        off.
        """
        ...
    
    def ViewToPose(self, p_float, p_float_1, p_float_2):
        """
        V.ViewToPose(float, float, float)
        C++: void ViewToPose(double &wx, double &wy, double &wz) override;
        
        Convert to from pose coordinates
        """
        ...
    
    def ViewToWorld(self):
        """
        V.ViewToWorld()
        C++: void ViewToWorld() override;
        V.ViewToWorld(float, float, float)
        C++: void ViewToWorld(double &wx, double &wy, double &wz)
            override;
        
        Convert view point coordinates to world coordinates.
        """
        ...
    
    def VisibleActorCount(self):
        """
        V.VisibleActorCount() -> int
        C++: int VisibleActorCount()
        
        Returns the number of visible actors.
        """
        ...
    
    def VisibleVolumeCount(self):
        """
        V.VisibleVolumeCount() -> int
        C++: int VisibleVolumeCount()
        
        Returns the number of visible volumes.
        """
        ...
    
    def WorldToPose(self, p_float, p_float_1, p_float_2):
        """
        V.WorldToPose(float, float, float)
        C++: void WorldToPose(double &wx, double &wy, double &wz)
            override;
        
        Convert to from pose coordinates
        """
        ...
    
    def WorldToView(self):
        """
        V.WorldToView()
        C++: void WorldToView() override;
        V.WorldToView(float, float, float)
        C++: void WorldToView(double &wx, double &wy, double &wz)
            override;
        
        Convert world point coordinates to view coordinates.
        """
        ...
    
    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__ = ...


