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

from .object import object

class vtkOpenGLRenderTimer(object):
    """
    vtkOpenGLRenderTimer - Asynchronously measures GPU execution time for
    a single event.
    
    This class posts events to the OpenGL server to measure execution
    times of GPU processes. The queries are asynchronous and multiple
    vtkOpenGLRenderTimers may overlap / be nested.
    
    This uses GL_TIMESTAMP rather than GL_ELAPSED_TIME, since only one
    GL_ELAPSED_TIME query may be active at a time. Since GL_TIMESTAMP is
    not available on OpenGL ES, timings will not be available on those
    platforms. Use the static IsSupported() method to determine if the
    timer is available.
    
    vtkOpenGLRenderTimer()
    """
    def GetElapsedMilliseconds(self):
        """
        V.GetElapsedMilliseconds() -> float
        C++: float GetElapsedMilliseconds()
        
        If Ready() returns true, get the elapsed time in the requested
        units.
        """
        ...
    
    def GetElapsedNanoseconds(self):
        """
        V.GetElapsedNanoseconds() -> int
        C++: vtkTypeUInt64 GetElapsedNanoseconds()
        
        If Ready() returns true, get the elapsed time in the requested
        units.
        """
        ...
    
    def GetElapsedSeconds(self):
        """
        V.GetElapsedSeconds() -> float
        C++: float GetElapsedSeconds()
        
        If Ready() returns true, get the elapsed time in the requested
        units.
        """
        ...
    
    def GetReusableElapsedSeconds(self):
        """
        V.GetReusableElapsedSeconds() -> float
        C++: float GetReusableElapsedSeconds()
        
        This class can also be used in a reusable manner where the start
        and stop events stay in flight until they are both completed.
        Calling ReusableStart while they are in flight is ignored. The
        Elapsed time is always the result from the most recently
        completed flight. Typical usage is
        
        render loop
          timer->ReusableStart();
          // do some rendering
          timer->ReusableStop();
          time = timer->GetReusableElapsedSeconds();
        
        the elapsed seconds will return zero until a flight has
        completed.
        
        The idea being that with OpenGL render commands are asynchronous.
        You might render multiple times before the first render on the
        GPU is completed. These reusable methods provide a method for
        provinding a constant measure of the time required for a command
        with the efficiency of only having one timing in process/flight
        at a time. Making this a lightweight timer in terms of OpenGL API
        calls.
        
        These reusable methods are not meant to be mixed with other
        methods in this class.
        """
        ...
    
    def GetStartTime(self):
        """
        V.GetStartTime() -> int
        C++: vtkTypeUInt64 GetStartTime()
        """
        ...
    
    def GetStopTime(self):
        """
        V.GetStopTime() -> int
        C++: vtkTypeUInt64 GetStopTime()
        """
        ...
    
    def IsSupported(self):
        """
        V.IsSupported() -> bool
        C++: static bool IsSupported()
        
        Returns true if timer events are supported by the current OpenGL
        implementation.
        """
        ...
    
    def Ready(self):
        """
        V.Ready() -> bool
        C++: bool Ready()
        
        Returns true when the timing results are available.
        """
        ...
    
    def ReleaseGraphicsResources(self):
        """
        V.ReleaseGraphicsResources()
        C++: void ReleaseGraphicsResources()
        
        Simply calls Reset() to ensure that query ids are freed. All
        stored timing information will be lost.
        """
        ...
    
    def Reset(self):
        """
        V.Reset()
        C++: void Reset()
        
        Clear out any previous results and prepare for a new query.
        """
        ...
    
    def ReusableStart(self):
        """
        V.ReusableStart()
        C++: void ReusableStart()
        
        This class can also be used in a reusable manner where the start
        and stop events stay in flight until they are both completed.
        Calling ReusableStart while they are in flight is ignored. The
        Elapsed time is always the result from the most recently
        completed flight. Typical usage is
        
        render loop
          timer->ReusableStart();
          // do some rendering
          timer->ReusableStop();
          time = timer->GetReusableElapsedSeconds();
        
        the elapsed seconds will return zero until a flight has
        completed.
        
        The idea being that with OpenGL render commands are asynchronous.
        You might render multiple times before the first render on the
        GPU is completed. These reusable methods provide a method for
        provinding a constant measure of the time required for a command
        with the efficiency of only having one timing in process/flight
        at a time. Making this a lightweight timer in terms of OpenGL API
        calls.
        
        These reusable methods are not meant to be mixed with other
        methods in this class.
        """
        ...
    
    def ReusableStop(self):
        """
        V.ReusableStop()
        C++: void ReusableStop()
        
        This class can also be used in a reusable manner where the start
        and stop events stay in flight until they are both completed.
        Calling ReusableStart while they are in flight is ignored. The
        Elapsed time is always the result from the most recently
        completed flight. Typical usage is
        
        render loop
          timer->ReusableStart();
          // do some rendering
          timer->ReusableStop();
          time = timer->GetReusableElapsedSeconds();
        
        the elapsed seconds will return zero until a flight has
        completed.
        
        The idea being that with OpenGL render commands are asynchronous.
        You might render multiple times before the first render on the
        GPU is completed. These reusable methods provide a method for
        provinding a constant measure of the time required for a command
        with the efficiency of only having one timing in process/flight
        at a time. Making this a lightweight timer in terms of OpenGL API
        calls.
        
        These reusable methods are not meant to be mixed with other
        methods in this class.
        """
        ...
    
    def Start(self):
        """
        V.Start()
        C++: void Start()
        
        Mark the start of a timed event.
        """
        ...
    
    def Started(self):
        """
        V.Started() -> bool
        C++: bool Started()
        
        Returns true if the timer has been started. The query may not be
        ready yet.
        """
        ...
    
    def Stop(self):
        """
        V.Stop()
        C++: void Stop()
        
        Mark the end of a timed event.
        """
        ...
    
    def Stopped(self):
        """
        V.Stopped() -> bool
        C++: bool Stopped()
        
        Returns true if the timer has been stopped. The query may not be
        ready yet.
        """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __hash__(self, *args, **kwargs) -> int:
        """ Return hash(self). """
        ...
    
    def __init__(self) -> 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). """
        ...
    


