Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async.py

@@ -0,0 +1,72 @@
+'''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
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.async import *
+from OpenGL.raw.GL.SGIX.async import _EXTENSION_NAME
+
+def glInitAsyncSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glFinishAsyncSGIX=wrapper.wrapper(glFinishAsyncSGIX).setOutput(
+    'markerp',size=(1,),orPassIn=True
+)
+glPollAsyncSGIX=wrapper.wrapper(glPollAsyncSGIX).setOutput(
+    'markerp',size=(1,),orPassIn=True
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_histogram.py

@@ -0,0 +1,30 @@
+'''OpenGL extension SGIX.async_histogram
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.async_histogram to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension introduces a new asynchronous mode for histogram
+	and minmax readbacks.  It allows programs to get the contents of a
+	histogram or minmax table without blocking and to continue issuing
+	graphics commands during the readback.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/async_histogram.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.async_histogram import *
+from OpenGL.raw.GL.SGIX.async_histogram import _EXTENSION_NAME
+
+def glInitAsyncHistogramSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_pixel.py

@@ -0,0 +1,35 @@
+'''OpenGL extension SGIX.async_pixel
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.async_pixel to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension introduces a new asynchronous mode for texture
+	download, pixel download and pixel readback commands.  It allows
+	programs to transfer textures or images between the host and the
+	graphics accelerator in parallel with the execution of other
+	graphics commands (possibly taking advantage of a secondary path
+	to the graphics accelerator).  It also allows programs to issue
+	non-blocking pixel readback commands that return immediately after
+	they are issued so that the program can issue other commands while
+	the readback takes place.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/async_pixel.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.async_pixel import *
+from OpenGL.raw.GL.SGIX.async_pixel import _EXTENSION_NAME
+
+def glInitAsyncPixelSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/clipmap.py

@@ -0,0 +1,31 @@
+'''OpenGL extension SGIX.clipmap
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.clipmap to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Mipmaps provide a general but expensive solution when the texture image
+	is very large.  This extension defines clipmaps, which occupy a small
+	subset of the memory required by equivalent mipmaps, but provide much
+	of the mipmap rendering capabilities.  Clipmaps are especially useful
+	for rendering terrain.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/clipmap.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.clipmap import *
+from OpenGL.raw.GL.SGIX.clipmap import _EXTENSION_NAME
+
+def glInitClipmapSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py

@@ -0,0 +1,28 @@
+'''OpenGL extension SGIX.convolution_accuracy
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.convolution_accuracy to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds an accuracy hint for convolution.  It
+	allows the program to trade off precision for speed.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/convolution_accuracy.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.convolution_accuracy import *
+from OpenGL.raw.GL.SGIX.convolution_accuracy import _EXTENSION_NAME
+
+def glInitConvolutionAccuracySGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/depth_texture.py

@@ -0,0 +1,34 @@
+'''OpenGL extension SGIX.depth_texture
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.depth_texture to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines a new depth texture format.  An important
+	application of depth texture images is shadow casting, but separating
+	this from the shadow extension allows for the potential use of depth
+	textures in other applications such as image-based rendering or
+	displacement mapping.  This extension does not define new depth-texture
+	environment functions, such as filtering or applying the depth values
+	computed from a texture, but leaves this to other extensions, such as
+	the shadow extension.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/depth_texture.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.depth_texture import *
+from OpenGL.raw.GL.SGIX.depth_texture import _EXTENSION_NAME
+
+def glInitDepthTextureSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/flush_raster.py

@@ -0,0 +1,38 @@
+'''OpenGL extension SGIX.flush_raster
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.flush_raster to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extensions provides a way to ensure that all raster operations 
+	currently in the pipeline will be completed before the next 
+	raster operation begins. We define a raster operation as an operation
+	that involves the rasterization stage of the OpenGL pipeline.
+	The implementation is free to decide what consitutes flushing the
+	raster subsystem.
+	
+	The motivation is to allow accurate instrumentation by 
+	including this call before stopping rasterization measurements.
+	There are cases where Finish() is used, but a FlushRaster()
+	would suffice, so this extension is deliberately kept independent 
+	of the instruments extension.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/flush_raster.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.flush_raster import *
+from OpenGL.raw.GL.SGIX.flush_raster import _EXTENSION_NAME
+
+def glInitFlushRasterSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/framezoom.py

@@ -0,0 +1,47 @@
+'''OpenGL extension SGIX.framezoom
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.framezoom to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a additional way to rasterize geometric
+	primitives and pixel rectangles.  The techique is to reduce the
+	number of pixels rasterized  and (possibly) the number of depth and
+	stencil operations performed per primitive.  Each pixel is zoomed
+	up and used to render an N x N block of screen pixels.  The
+	implementation is free to choose the number of stencil and z pixels
+	that will correspond to each N x N block.
+	
+	This extension provides an opportunity to the implementation to
+	perform expensive raster operations at a reduced resolution,
+	increasing performance.  Such operations may include
+	texture-mapping, depth & stencil tests, etc.  The hardware should
+	be allowed to perform operations that it accelerates at full
+	hardware speed.
+	
+	The visual result will be the same as if a scene were rendered into
+	a small window, and then that buffer was copied and zoomed up into
+	a large window.
+	
+	All OpenGL parameters that effect rasterization size will implicitly
+	be multipled by N (this includes point size, line width, etc).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/framezoom.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.framezoom import *
+from OpenGL.raw.GL.SGIX.framezoom import _EXTENSION_NAME
+
+def glInitFramezoomSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/resample.py

@@ -0,0 +1,43 @@
+'''OpenGL extension SGIX.resample
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.resample to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension enhances the unpacking resampling capabilities
+	of the SGIX_subsample extension.
+	
+	When pixel data is received from the client and an unpacking
+	upsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX is
+	specified, the upsampling is performed via one of two methods:
+	RESAMPLE_REPLICATE_SGIX, RESAMPLE_ZERO_FILL_SGIX.
+	Replicate and zero fill are provided to
+	give the application greatest performance and control over the
+	filtering process.
+	
+	However, when pixel data is read back to the client and a
+	packing downsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX
+	is specified, downsampling is
+	performed via simple component decimation (point sampling). That is,
+	only the RESAMPLE_DECIMATE_SGIX is valid.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/resample.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.resample import *
+from OpenGL.raw.GL.SGIX.resample import _EXTENSION_NAME
+
+def glInitResampleSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/shadow_ambient.py

@@ -0,0 +1,33 @@
+'''OpenGL extension SGIX.shadow_ambient
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.shadow_ambient to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows a value other than 0.0 to be returned by the
+	SGIX_shadow operation in the case when the shadow test passes.
+	With this extension any floating point value in the range [0.0,
+	1.0] can be returned as the texture value when an object is in
+	shadow.  This allows the (untextured) ambient lighting and direct
+	shadowed lighting from a single light source to be computed in a
+	single pass.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/shadow_ambient.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.shadow_ambient import *
+from OpenGL.raw.GL.SGIX.shadow_ambient import _EXTENSION_NAME
+
+def glInitShadowAmbientSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/sprite.py

@@ -0,0 +1,79 @@
+'''OpenGL extension SGIX.sprite
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.sprite to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	    This extension provides support for viewpoint dependent alignment
+	    of geometry, in particular geometry that rotates about a point or
+	    a specified axis to face the eye point.  The primary use is for
+	    quickly rendering roughly cylindrically or spherically symmetric
+	    objects, e.g. trees, smoke, clouds, etc. using geometry textured
+	    with a partially transparent texture map.
+	
+	    Rendering sprite geometry requires applying a transformation to
+	    primitives before the current model view. This matrix includes a
+	    rotation which is computed based on the current model view matrix
+	    and a translation which is specified explicitly
+	    (SPRITE_TRANSLATION_SGIX). The current model view matrix itself
+	    is not modified.
+	
+	    Primitives are first transformed by a rotation, depending on the
+	    sprite mode:
+	
+		SPRITE_AXIAL_SGIX: The front of the object is rotated about
+		an axis so that it faces the eye as much as the axis
+		constraint allows.  This is used for roughly rendering cylindrical
+		objects such as trees in visual simulation. 
+	
+		SPRITE_OBJECT_ALIGNED_SGIX: The front of the object is
+		rotated about a point to face the eye with the remaining
+		rotational degree of freedom specified by aligning the top
+		of the object with a specified axis in object coordinates.
+		This is used for spherical objects and special effects such
+		as smoke which must maintain an alignment in object
+		coordinates for realism.
+	
+		SPRITE_EYE_ALIGNED_SGIX: The front of the object is rotated
+		about a point to face the eye with the remaining rotational
+		degree of freedom specified by aligning the top of the object
+		with a specified axis in eye coordinates. This is used for
+		rendering sprites which must maintain an alignment on the
+		screen, such as 3D annotations.
+	
+	    The axis of rotation or alignment, SPRITE_AXIS_SGIX, can be 
+	    an arbitrary direction to support geocentric coordinate frames
+	    in which "up" is not along X, Y or Z.
+	
+	    Sprite geometry is modeled in a canonical frame: +Z is the up
+	    vector. -Y is the front vector which is rotated to point towards
+	    the eye. In the discussion below, the eye vector is the vector to
+	    the eye from the origin of the model view frame translated by the
+	    sprite position.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/sprite.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.sprite import *
+from OpenGL.raw.GL.SGIX.sprite import _EXTENSION_NAME
+
+def glInitSpriteSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glSpriteParameterfvSGIX.params size not checked against 'pname'
+glSpriteParameterfvSGIX=wrapper.wrapper(glSpriteParameterfvSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glSpriteParameterivSGIX.params size not checked against 'pname'
+glSpriteParameterivSGIX=wrapper.wrapper(glSpriteParameterivSGIX).setInputArraySize(
+    'params', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_add_env.py

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.texture_add_env
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.texture_add_env to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/texture_add_env.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.SGIX.texture_add_env import *
+from OpenGL.raw.GL.SGIX.texture_add_env import _EXTENSION_NAME
+
+def glInitTextureAddEnvSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION