OpenGL.GL.SGIX.async
index
/home/mcfletch/pylive/OpenGL/GL/SGIX/async.py

OpenGL extension SGIX.async
 
This module customises the behaviour of the 
OpenGL.raw.GL.SGIX.async to provide a more 
Python-friendly API
 
Overview (from the spec)
        
        This extension provides a framework for asynchronous OpenGL
        commands.  It also provides commands allowing a program to wait
        for the completion of asynchronous commands.
        
        Asynchronous commands have two properties:
        
        1) Asynchronous commands are non-blocking.  For example, an
        asynchronous ReadPixels command returns control to the program
        immediately rather than blocking until the command completes.
        This property allows the program to issue other OpenGL commands in
        parallel with the execution of commands that normally block.
        
        2) Asynchronous commands may complete out-of-order with respect to
        other OpenGL commands.  For example, an asynchronous TexImage
        command may complete after subsequent OpenGL commands issued by
        the program rather than maintaining the normal serial order of the
        OpenGL command stream.  This property allows the graphics
        accelerator to execute asynchronous commands in parallel with the
        normal command stream, for instance using a secondary path to
        transfer data from or to the host, without doing any dependency
        checking.
        
        Programs that issue asynchronous commands must also be able to
        determine when the commands have completed.  The completion status
        may be needed so that results can be retrieved (e.g. the image
        data from a ReadPixels command) or so that dependent commands can
        be issued (e.g. drawing commands that use texture data downloaded
        by an earlier asynchronous command).  This extension provides
        fine-grain control over asynchronous commands by introducing a
        mechanism for determining the status of individual commands.
        
        Each invocation of an asynchronous command is associated with an
        integer called a "marker."  A program specifies a marker before it
        issues an asynchronous command.  The program may later issue a
        command to query if any asynchronous commands have completed.  The
        query commands return a marker to identify the command that
        completed.  This extension provides both blocking and non-blocking
        query commands.
        
        This extension does not define any asynchronous commands.
        See SGIX_async_pixel for the asynchronous pixel commands.
 
The official definition of this extension is available here:
http://www.opengl.org/registry/specs/SGIX/async.txt

 
Modules
       
OpenGL.arrays
OpenGL.constant
OpenGL.constants
ctypes
OpenGL.extensions
OpenGL.GL.glget
OpenGL.platform
OpenGL.wrapper

 
Data
        EXTENSION_NAME = 'GL_SGIX_async'
GL_ASYNC_MARKER_SGIX = GL_ASYNC_MARKER_SGIX
__file__ = '/home/mcfletch/pylive/OpenGL/GL/SGIX/async.pyc'
__name__ = 'OpenGL.GL.SGIX.async'
__package__ = 'OpenGL.GL.SGIX'
glAsyncMarkerSGIX = <OpenGL.platform.baseplatform.glAsyncMarkerSGIX object at 0x7a6c250>
glDeleteAsyncMarkersSGIX = <OpenGL.platform.baseplatform.glDeleteAsyncMarkersSGIX object at 0x7a6f610>
glFinishAsyncSGIX = <OpenGL.platform.baseplatform.glFinishAsyncSGIX object at 0x7a6f3d0>
glGenAsyncMarkersSGIX = <OpenGL.platform.baseplatform.glGenAsyncMarkersSGIX object at 0x7a6f5d0>
glIsAsyncMarkerSGIX = <OpenGL.platform.baseplatform.glIsAsyncMarkerSGIX object at 0x7a6f750>
glPollAsyncSGIX = <OpenGL.platform.baseplatform.glPollAsyncSGIX object at 0x7a6f4d0>