# 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


from .object import object

class vtkOpenGLRenderTimer(object):
    """
    vtkOpenGLRenderTimer() -> vtkOpenGLRenderTimer
    C++: vtkOpenGLRenderTimer()
    
    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.
    """
    def GetElapsedMilliseconds(self): # real signature unknown; restored from __doc__
        """
        GetElapsedMilliseconds(self) -> float
        C++: float GetElapsedMilliseconds()
        """
        return 0.0

    def GetElapsedNanoseconds(self): # real signature unknown; restored from __doc__
        """
        GetElapsedNanoseconds(self) -> int
        C++: vtkTypeUInt64 GetElapsedNanoseconds()
        """
        return 0

    def GetElapsedSeconds(self): # real signature unknown; restored from __doc__
        """
        GetElapsedSeconds(self) -> float
        C++: float GetElapsedSeconds()
        
        If Ready() returns true, get the elapsed time in the requested
        units.
        """
        return 0.0

    def GetReusableElapsedSeconds(self): # real signature unknown; restored from __doc__
        """
        GetReusableElapsedSeconds(self) -> float
        C++: float GetReusableElapsedSeconds()
        """
        return 0.0

    def GetStartTime(self): # real signature unknown; restored from __doc__
        """
        GetStartTime(self) -> int
        C++: vtkTypeUInt64 GetStartTime()
        """
        return 0

    def GetStopTime(self): # real signature unknown; restored from __doc__
        """
        GetStopTime(self) -> int
        C++: vtkTypeUInt64 GetStopTime()
        """
        return 0

    def IsSupported(self): # real signature unknown; restored from __doc__
        """
        IsSupported() -> bool
        C++: static bool IsSupported()
        
        Returns true if timer events are supported by the current OpenGL
        implementation.
        """
        return False

    def Ready(self): # real signature unknown; restored from __doc__
        """
        Ready(self) -> bool
        C++: bool Ready()
        
        Returns true when the timing results are available.
        """
        return False

    def ReleaseGraphicsResources(self): # real signature unknown; restored from __doc__
        """
        ReleaseGraphicsResources(self) -> None
        C++: void ReleaseGraphicsResources()
        
        Simply calls Reset() to ensure that query ids are freed. All
        stored timing information will be lost.
        """
        pass

    def Reset(self): # real signature unknown; restored from __doc__
        """
        Reset(self) -> None
        C++: void Reset()
        
        Clear out any previous results and prepare for a new query.
        """
        pass

    def ReusableStart(self): # real signature unknown; restored from __doc__
        """
        ReusableStart(self) -> None
        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.
        """
        pass

    def ReusableStop(self): # real signature unknown; restored from __doc__
        """
        ReusableStop(self) -> None
        C++: void ReusableStop()
        """
        pass

    def Start(self): # real signature unknown; restored from __doc__
        """
        Start(self) -> None
        C++: void Start()
        
        Mark the start of a timed event.
        """
        pass

    def Started(self): # real signature unknown; restored from __doc__
        """
        Started(self) -> bool
        C++: bool Started()
        
        Returns true if the timer has been started. The query may not be
        ready yet.
        """
        return False

    def Stop(self): # real signature unknown; restored from __doc__
        """
        Stop(self) -> None
        C++: void Stop()
        
        Mark the end of a timed event.
        """
        pass

    def Stopped(self): # real signature unknown; restored from __doc__
        """
        Stopped(self) -> bool
        C++: bool Stopped()
        
        Returns true if the timer has been stopped. The query may not be
        ready yet.
        """
        return False

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self): # real signature unknown; restored from __doc__
        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