Add files using upload-large-folder tool

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

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

vllm/lib/python3.10/site-packages/OpenGL/GL/GREMEDY/frame_terminator.py

@@ -0,0 +1,47 @@
+'''OpenGL extension GREMEDY.frame_terminator
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.GREMEDY.frame_terminator to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines a mechanism that enables marking the end 
+	of render frames within the OpenGL stream.
+	
+	When debugging or profiling an OpenGL application, the debuggers
+	and profilers needs to know when a render frame is ended. This
+	is important for frame per second measurements, statistical analysis, 
+	marking and clearing stream loggers logs, performance counters 
+	sampling and more.
+	
+	When an application uses off screen buffers, the debugger / profiler
+	cannot be guaranteed that the application will call a certain function at
+	the end of each off-screen frame (e.g: SwapBuffers / glClear / etc). 
+	This extension enables the application to notify the debugger / profiler 
+	whenever a render frame is ended.
+	
+	This extension is mainly useful for debuggers and profilers. It is not 
+	expected that standard drivers would implement this extension. The main
+	point of having this extension is to allow applications to have a clean 
+	way of accessing this functionality only when they are run under the 
+	control of a debugger / profiler, without having to recompile or change 
+	the application source code.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/GREMEDY/frame_terminator.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.GREMEDY.frame_terminator import *
+from OpenGL.raw.GL.GREMEDY.frame_terminator import _EXTENSION_NAME
+
+def glInitFrameTerminatorGREMEDY():
+    '''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/GREMEDY/string_marker.py

@@ -0,0 +1,54 @@
+'''OpenGL extension GREMEDY.string_marker
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.GREMEDY.string_marker to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines a mechanism to insert textual markers into
+	the OpenGL stream. 
+	
+	When debugging or profiling an OpenGL application some of the most
+	important tools are stream loggers, which just output a list of the
+	called OpenGL commands, and profilers, which show at which points
+	the pipeline is bottlenecked for a given part of the frame. The
+	problem in using these is that there is a definite loss of
+	information between the application and the used debugger/profiler.
+	The application generally has a pretty good idea what is rendered
+	when (e.g. rendering background, landscape, building, players,
+	particle effects, bullets etc.), but the debugger/profiler only
+	sees the OpenGL stream. To analyze the stream developers have to
+	guess what is done when by following the program code and the log
+	output in parallel, which can get difficult for systems that
+	restructure their internal pipeline or do lazy changes.
+	
+	This extension is really only useful for these debuggers and
+	profilers, and not for actual drivers. In fact, it is not expected
+	that any standard driver would ever implement this extension. The
+	main point of having this extension is to allow applications to have a
+	clean way of accessing this functionality only when they are run
+	under the control of a debugger/profiler, without having to
+	recompile or change the application source code.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/GREMEDY/string_marker.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.GREMEDY.string_marker import *
+from OpenGL.raw.GL.GREMEDY.string_marker import _EXTENSION_NAME
+
+def glInitStringMarkerGREMEDY():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glStringMarkerGREMEDY.string size not checked against len
+glStringMarkerGREMEDY=wrapper.wrapper(glStringMarkerGREMEDY).setInputArraySize(
+    'string', None
+)
+### END AUTOGENERATED SECTION

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

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

vllm/lib/python3.10/site-packages/OpenGL/GL/INTEL/fragment_shader_ordering.py

@@ -0,0 +1,51 @@
+'''OpenGL extension INTEL.fragment_shader_ordering
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.INTEL.fragment_shader_ordering to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Graphics devices may execute in parallel fragment shaders referring to the
+	same window xy coordinates. Framebuffer writes are guaranteed to be
+	processed in primitive rasterization order, but there is no order guarantee
+	for other instructions and image or buffer object accesses in
+	particular.
+	
+	The extension introduces a new GLSL built-in function, 
+	beginFragmentShaderOrderingINTEL(), which blocks execution of a fragment 
+	shader invocation until invocations from previous primitives that map to 
+	the same xy window coordinates (and same sample when per-sample shading
+	is active) complete their execution. All memory transactions from previous 
+	fragment shader invocations are made visible to the fragment shader 
+	invocation that called beginFragmentShaderOrderingINTEL() when the function 
+	returns. 
+	
+	Including the following line in a shader can be used to control the
+	language features described in this extension:
+	
+	  #extension GL_INTEL_fragment_shader_ordering : <behavior>
+	
+	where <behavior> is as specified in section 3.3.
+	
+	New preprocessor #defines are added to the OpenGL Shading Language:
+	
+	  #define GL_INTEL_fragment_shader_ordering 1
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/INTEL/fragment_shader_ordering.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.INTEL.fragment_shader_ordering import *
+from OpenGL.raw.GL.INTEL.fragment_shader_ordering import _EXTENSION_NAME
+
+def glInitFragmentShaderOrderingINTEL():
+    '''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/INTEL/map_texture.py

@@ -0,0 +1,43 @@
+'''OpenGL extension INTEL.map_texture
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.INTEL.map_texture to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	Systems with integrated GPUs can share the same physical memory between CPU
+	and GPU. This feature, if exposed by API, can bring significant performance
+	benefits for graphics applications by reducing the complexity of
+	uploading/accessing texture contents. This extension enables CPU direct
+	access to the GPU memory holding textures.
+	
+	The problem with texture memory directly exposed to clients is that
+	textures are often 'tiled'. Texels are kept in specific layout to improve
+	locality of reference and thus performance of texturing. This 'tiling'
+	is specific to particular hardware and would be thus difficult to use.
+	
+	This extension allows to create textures with 'linear' layout which allows
+	for simplified access on user side (potentially sacrificing some
+	performance during texture sampling).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/INTEL/map_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.INTEL.map_texture import *
+from OpenGL.raw.GL.INTEL.map_texture import _EXTENSION_NAME
+
+def glInitMapTextureINTEL():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glMapTexture2DINTEL=wrapper.wrapper(glMapTexture2DINTEL).setInputArraySize(
+    'stride', 1
+).setInputArraySize(
+    'layout', 1
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/INTEL/parallel_arrays.py

@@ -0,0 +1,38 @@
+'''OpenGL extension INTEL.parallel_arrays
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.INTEL.parallel_arrays to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds the ability to format vertex arrays in a way that's 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/INTEL/parallel_arrays.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.INTEL.parallel_arrays import *
+from OpenGL.raw.GL.INTEL.parallel_arrays import _EXTENSION_NAME
+
+def glInitParallelArraysINTEL():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glVertexPointervINTEL=wrapper.wrapper(glVertexPointervINTEL).setInputArraySize(
+    'pointer', 4
+)
+glNormalPointervINTEL=wrapper.wrapper(glNormalPointervINTEL).setInputArraySize(
+    'pointer', 4
+)
+glColorPointervINTEL=wrapper.wrapper(glColorPointervINTEL).setInputArraySize(
+    'pointer', 4
+)
+glTexCoordPointervINTEL=wrapper.wrapper(glTexCoordPointervINTEL).setInputArraySize(
+    'pointer', 4
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/INTEL/performance_query.py

@@ -0,0 +1,23 @@
+'''OpenGL extension INTEL.performance_query
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.INTEL.performance_query to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/INTEL/performance_query.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.INTEL.performance_query import *
+from OpenGL.raw.GL.INTEL.performance_query import _EXTENSION_NAME
+
+def glInitPerformanceQueryINTEL():
+    '''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/blend_alpha_minmax.py

@@ -0,0 +1,32 @@
+'''OpenGL extension SGIX.blend_alpha_minmax
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.blend_alpha_minmax to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Two additional blending equations are specified using the interface
+	defined by EXT_blend_minmax.  These equations are similar to the
+	MIN_EXT and MAX_EXT blending equations, but the outcome for all four
+	color components is determined by a comparison of just the alpha
+	component's source and destination values.  These equations are useful
+	in image processing and advanced shading algorithms.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/blend_alpha_minmax.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.blend_alpha_minmax import *
+from OpenGL.raw.GL.SGIX.blend_alpha_minmax import _EXTENSION_NAME
+
+def glInitBlendAlphaMinmaxSGIX():
+    '''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/calligraphic_fragment.py

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.calligraphic_fragment
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.calligraphic_fragment to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/calligraphic_fragment.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.calligraphic_fragment import *
+from OpenGL.raw.GL.SGIX.calligraphic_fragment import _EXTENSION_NAME
+
+def glInitCalligraphicFragmentSGIX():
+    '''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_pass_instrument.py

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.depth_pass_instrument
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.depth_pass_instrument to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/depth_pass_instrument.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_pass_instrument import *
+from OpenGL.raw.GL.SGIX.depth_pass_instrument import _EXTENSION_NAME
+
+def glInitDepthPassInstrumentSGIX():
+    '''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/fog_offset.py

@@ -0,0 +1,40 @@
+'''OpenGL extension SGIX.fog_offset
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.fog_offset to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows fragments to look brighter in a foggy
+	environment, by biasing the fragment eye-coordinate distance prior
+	to fog computation. A reference point in eye space (rx ry rz) and an offset
+	amount toward the viewpoint (f_o) are specified. When fog offset is
+	enabled, the offset amount will be subtracted from the fragment
+	distance, making objects appear less foggy.
+	
+	If fog computation is done in screen-space coordinates under
+	perspective projection, the reference point is used in adjusting the
+	fog offset to be correct for fragments whose depth is close to that
+	point. The reference point should be redefined when it becomes too
+	far away from the primitives being drawn. Under orthographic
+	projection, or if fog computation is done in eye-space coordinates,
+	the reference point is ignored.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/fog_offset.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.fog_offset import *
+from OpenGL.raw.GL.SGIX.fog_offset import _EXTENSION_NAME
+
+def glInitFogOffsetSGIX():
+    '''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/fragment_lighting.py

@@ -0,0 +1,58 @@
+'''OpenGL extension SGIX.fragment_lighting
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.fragment_lighting to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/fragment_lighting.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.fragment_lighting import *
+from OpenGL.raw.GL.SGIX.fragment_lighting import _EXTENSION_NAME
+
+def glInitFragmentLightingSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glFragmentLightfvSGIX.params size not checked against 'pname'
+glFragmentLightfvSGIX=wrapper.wrapper(glFragmentLightfvSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glFragmentLightivSGIX.params size not checked against 'pname'
+glFragmentLightivSGIX=wrapper.wrapper(glFragmentLightivSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glFragmentLightModelfvSGIX.params size not checked against 'pname'
+glFragmentLightModelfvSGIX=wrapper.wrapper(glFragmentLightModelfvSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glFragmentLightModelivSGIX.params size not checked against 'pname'
+glFragmentLightModelivSGIX=wrapper.wrapper(glFragmentLightModelivSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glFragmentMaterialfvSGIX.params size not checked against 'pname'
+glFragmentMaterialfvSGIX=wrapper.wrapper(glFragmentMaterialfvSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glFragmentMaterialivSGIX.params size not checked against 'pname'
+glFragmentMaterialivSGIX=wrapper.wrapper(glFragmentMaterialivSGIX).setInputArraySize(
+    'params', None
+)
+glGetFragmentLightfvSGIX=wrapper.wrapper(glGetFragmentLightfvSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetFragmentLightivSGIX=wrapper.wrapper(glGetFragmentLightivSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetFragmentMaterialfvSGIX=wrapper.wrapper(glGetFragmentMaterialfvSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetFragmentMaterialivSGIX=wrapper.wrapper(glGetFragmentMaterialivSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,26 @@
+'''OpenGL extension SGIX.igloo_interface
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.igloo_interface to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/igloo_interface.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.igloo_interface import *
+from OpenGL.raw.GL.SGIX.igloo_interface import _EXTENSION_NAME
+
+def glInitIglooInterfaceSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glIglooInterfaceSGIX.params size not checked against 'pname'
+glIglooInterfaceSGIX=wrapper.wrapper(glIglooInterfaceSGIX).setInputArraySize(
+    'params', None
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,64 @@
+'''OpenGL extension SGIX.instruments
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.instruments to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows the gathering and return of performance
+	measurements from within the graphics pipeline by adding
+	instrumentation.
+	
+	There are two reasons to do this.  The first is as a part of some
+	type of fixed-frame-rate load management scheme.  If we know that
+	the pipeline is stalled or struggling to process the amount of
+	data we have given it so far, we can reduce the level of detail of
+	the remaining objects in the current frame or the next frame, or
+	adjust the framebuffer resolution for the next frame if we have a
+	video-zoom capability available.  We can call this type of
+	instrumentation Load Monitoring.
+	
+	The second is for performance tuning and debugging of an
+	application. It might tell us how many triangles were culled or
+	clipped before being rasterized.  We can call this simply Tuning.
+	
+	Load Monitoring requires that the instrumentation and the access
+	of the measurements be efficient, otherwise the instrumentation
+	itself will reduce performance more than any load-management
+	scheme could hope to offset.  Tuning does not have the same
+	requirements.
+	
+	The proposed extension adds a call to setup a measurements return
+	buffer, similar to FeedbackBuffer but with an asynchrounous
+	behavior to prevent filling the pipeline with NOP's while waiting
+	for the data to be returned.
+	
+	Note that although the extension has been specified without any
+	particular instruments, defining either a device dependent or
+	device independent instrument should be as simple as introducing
+	an extension consisting primarily of a new enumerant to identify
+	the instrument.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/instruments.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.instruments import *
+from OpenGL.raw.GL.SGIX.instruments import _EXTENSION_NAME
+
+def glInitInstrumentsSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glInstrumentsBufferSGIX=wrapper.wrapper(glInstrumentsBufferSGIX).setOutput(
+    'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True
+)
+glPollInstrumentsSGIX=wrapper.wrapper(glPollInstrumentsSGIX).setOutput(
+    'marker_p',size=(1,),orPassIn=True
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,33 @@
+'''OpenGL extension SGIX.interlace
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.interlace to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a way to interlace rows of pixels when
+	rasterizing pixel rectangles, and loading texture images.  In this
+	context, interlacing means skiping over rows of pixels or texels
+	in the destination.  This is useful for dealing with video data
+	since a single frame of video is typically composed from two images
+	or fields: one image specifying the data for even rows of the frame
+	and the other image specifying the data for odd rows of the frame.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/interlace.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.interlace import *
+from OpenGL.raw.GL.SGIX.interlace import _EXTENSION_NAME
+
+def glInitInterlaceSGIX():
+    '''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/ir_instrument1.py

@@ -0,0 +1,26 @@
+'''OpenGL extension SGIX.ir_instrument1
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.ir_instrument1 to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/ir_instrument1.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.ir_instrument1 import *
+from OpenGL.raw.GL.SGIX.ir_instrument1 import _EXTENSION_NAME
+
+def glInitIrInstrument1SGIX():
+    '''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/list_priority.py

@@ -0,0 +1,43 @@
+'''OpenGL extension SGIX.list_priority
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.list_priority to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a mechanism for specifying the relative
+	importance of display lists.  This information can be used by
+	an OpenGL implementation to guide the placement of display
+	list data in a storage hierarchy.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/list_priority.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.list_priority import *
+from OpenGL.raw.GL.SGIX.list_priority import _EXTENSION_NAME
+
+def glInitListPrioritySGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glGetListParameterfvSGIX=wrapper.wrapper(glGetListParameterfvSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetListParameterivSGIX=wrapper.wrapper(glGetListParameterivSGIX).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+# INPUT glListParameterfvSGIX.params size not checked against 'pname'
+glListParameterfvSGIX=wrapper.wrapper(glListParameterfvSGIX).setInputArraySize(
+    'params', None
+)
+# INPUT glListParameterivSGIX.params size not checked against 'pname'
+glListParameterivSGIX=wrapper.wrapper(glListParameterivSGIX).setInputArraySize(
+    'params', None
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.pixel_texture
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.pixel_texture to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/pixel_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.pixel_texture import *
+from OpenGL.raw.GL.SGIX.pixel_texture import _EXTENSION_NAME
+
+def glInitPixelTextureSGIX():
+    '''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/pixel_tiles.py

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.pixel_tiles
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.pixel_tiles to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/pixel_tiles.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.pixel_tiles import *
+from OpenGL.raw.GL.SGIX.pixel_tiles import _EXTENSION_NAME
+
+def glInitPixelTilesSGIX():
+    '''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/polynomial_ffd.py

@@ -0,0 +1,30 @@
+'''OpenGL extension SGIX.polynomial_ffd
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.polynomial_ffd to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/polynomial_ffd.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.polynomial_ffd import *
+from OpenGL.raw.GL.SGIX.polynomial_ffd import _EXTENSION_NAME
+
+def glInitPolynomialFfdSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glDeformationMap3dSGIX.points size not checked against 'target,ustride,uorder,vstride,vorder,wstride,worder'
+glDeformationMap3dSGIX=wrapper.wrapper(glDeformationMap3dSGIX).setInputArraySize(
+    'points', None
+)
+# INPUT glDeformationMap3fSGIX.points size not checked against 'target,ustride,uorder,vstride,vorder,wstride,worder'
+glDeformationMap3fSGIX=wrapper.wrapper(glDeformationMap3fSGIX).setInputArraySize(
+    'points', None
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,49 @@
+'''OpenGL extension SGIX.reference_plane
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.reference_plane to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows a group of coplanar primitives to be rendered
+	without depth-buffering artifacts.  This is accomplished by generating
+	the depth values for all the primitives from a single ``reference plane''
+	rather than from the primitives themselves.  This ensures that all the
+	primitives in the group have exactly the same depth value at any given
+	sample point, no matter what imprecision may exist in the original
+	specifications of the primitives or in the GL's coordinate transformation
+	process.
+	
+	The reference plane is defined by a four-component plane equation.
+	When glReferencePlaneSGIX is called, equation is transformed by the
+	transpose-adjoint of a matrix that is the complete object-coordinate
+	to clip-coordinate transformation.  The resulting clip-coordinate
+	coefficients are transformed by the current viewport when the reference
+	plane is enabled.
+	
+	The reference plane is enabled and disabled with glEnable and glDisable.
+	
+	If the reference plane is enabled, a fragment (xf,yf,zf) will have a
+	new z coordinate generated from (xf,yf) by giving it the same z value
+	that the reference plane would have at (xf,yf).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/reference_plane.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.reference_plane import *
+from OpenGL.raw.GL.SGIX.reference_plane import _EXTENSION_NAME
+
+def glInitReferencePlaneSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glReferencePlaneSGIX=wrapper.wrapper(glReferencePlaneSGIX).setInputArraySize(
+    'equation', 4
+)
+### END AUTOGENERATED SECTION

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

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.scalebias_hint
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.scalebias_hint to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/scalebias_hint.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.scalebias_hint import *
+from OpenGL.raw.GL.SGIX.scalebias_hint import _EXTENSION_NAME
+
+def glInitScalebiasHintSGIX():
+    '''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.py

@@ -0,0 +1,31 @@
+'''OpenGL extension SGIX.shadow
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.shadow to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines two new operations to be performed on texture
+	values before they are passed on to the filtering subsystem.  These
+	operations perform either a <= or >= test on the value from texture
+	memory and the iterated R value, and return 1.0 or 0.0 if the test
+	passes or fails, respectively.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/shadow.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 import *
+from OpenGL.raw.GL.SGIX.shadow import _EXTENSION_NAME
+
+def glInitShadowSGIX():
+    '''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/subsample.py

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.subsample
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.subsample to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/subsample.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.subsample import *
+from OpenGL.raw.GL.SGIX.subsample import _EXTENSION_NAME
+
+def glInitSubsampleSGIX():
+    '''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/tag_sample_buffer.py

@@ -0,0 +1,32 @@
+'''OpenGL extension SGIX.tag_sample_buffer
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.tag_sample_buffer to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The extensions defines a special purpose fast multisample clear.
+	This clear can be used with some restrictions as a significantly
+	faster alternative to Clear(DEPTH_BUFFER_BIT).
+	
+	The extension is based on the RealityEngine architecture and will
+	probably never be supported by any other architecture.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/tag_sample_buffer.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.tag_sample_buffer import *
+from OpenGL.raw.GL.SGIX.tag_sample_buffer import _EXTENSION_NAME
+
+def glInitTagSampleBufferSGIX():
+    '''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/texture_coordinate_clamp.py

@@ -0,0 +1,31 @@
+'''OpenGL extension SGIX.texture_coordinate_clamp
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.texture_coordinate_clamp to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a mechanism to specify the maximum texture coordinate
+	clamping values. Standard OpenGL always clamps the upper bound to 1.0 when
+	the wrap mode is set to CLAMP. This mechanism can be used to  guarantee 
+	that non-existent texel data will not be accessed when the texture image has 
+	dimensions that are not a power of 2.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/texture_coordinate_clamp.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_coordinate_clamp import *
+from OpenGL.raw.GL.SGIX.texture_coordinate_clamp import _EXTENSION_NAME
+
+def glInitTextureCoordinateClampSGIX():
+    '''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/texture_scale_bias.py

@@ -0,0 +1,38 @@
+'''OpenGL extension SGIX.texture_scale_bias
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.texture_scale_bias to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds scale, bias, and clamp to [0, 1] operations to the 
+	texture pipeline.
+	These operations are applied to the filtered result of a texture lookup,
+	before that result is used in the texture environment equations and
+	before the texture color lookup table of SGI_texture_color_table, 
+	if that extension exists.
+	These operations are distinct from the scale, bias, and clamp operations
+	that appear in the SGI_color_table extension, which are used to
+	define a color lookup table.
+	
+	Scale and bias operations on texels can be used to better utilize the
+	color resolution of a particular texture internal format (see EXT_texture).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/texture_scale_bias.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_scale_bias import *
+from OpenGL.raw.GL.SGIX.texture_scale_bias import _EXTENSION_NAME
+
+def glInitTextureScaleBiasSGIX():
+    '''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/vertex_preclip.py

@@ -0,0 +1,39 @@
+'''OpenGL extension SGIX.vertex_preclip
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.vertex_preclip to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Certain graphics subsystems are capable of performing fast
+	2D viewport or, in some cases, 3D volume "scissoring" operations
+	within some coordinate range much faster that the host CPU could
+	re-tesselate clipped primitives.
+	
+	This extension introduces the notion of an extended rasterizable view
+	volume that is an expansion of the clip-space view volume.	This volume
+	is the space within which a particular graphics system is much more
+	efficient at rejecting fragments that lie outside the view volume than
+	it is at performing strict view volume clipping.
+	
+	Clip-checking can be turned on or off through the glEnable/glDisable
+	mechanism, and can be further controlled by using glHint.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/vertex_preclip.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.vertex_preclip import *
+from OpenGL.raw.GL.SGIX.vertex_preclip import _EXTENSION_NAME
+
+def glInitVertexPreclipSGIX():
+    '''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/ycrcb.py

@@ -0,0 +1,52 @@
+'''OpenGL extension SGIX.ycrcb
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.ycrcb to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a method for OpenGL to read and store 
+	images that are defined in standard YCRCB 422 and 444 video formats.
+	As with the CYMK extension, conversion to RGBA takes place immediately 
+	following the unpack pixel store, and preceding the pack pixel store 
+	operations, and is only available on transfers to and from memory.  
+	The algorithms that convert between YCRCB and RGBA are "black-box"
+	in nature, and left undefined by the extension.
+	
+	Two new formats are added, YCRCB_422_SGIX and YCRCB_444_SGIX.
+	
+	To handle the difference in sampling rate for 422 video, the pixel 
+	storage operations treat YCRCB_422_SGIX as a 2 component format,
+	where the first component represents chroma, and the second luma.
+	The chroma component alternates between Cb and Cr values on
+	a per pixel basis.  If the specified image <width> parameter is not
+	a multiple of 2, then fragments or texels that result from processing 
+	the <width>th column of pixels will have undefined color value.
+	
+	YCRCB_444_SGIX is defined as a 3 component format representing 
+	the Cb, Y, and Cr values per pixel.
+	
+	As with the CMYK extension, this extension doesn't preclude the 
+	possiblity of other higher quality conversion methods.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/ycrcb.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.ycrcb import *
+from OpenGL.raw.GL.SGIX.ycrcb import _EXTENSION_NAME
+
+def glInitYcrcbSGIX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION
+from OpenGL import images as _i
+_i.COMPONENT_COUNTS[ GL_YCRCB_422_SGIX ] = 1 # must be GL_UNSIGNED_BYTE
+_i.COMPONENT_COUNTS[ GL_YCRCB_444_SGIX ] = 1 # must be GL_UNSIGNED_SHORT

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

@@ -0,0 +1,23 @@
+'''OpenGL extension SGIX.ycrcb_subsample
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.SGIX.ycrcb_subsample to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/SGIX/ycrcb_subsample.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.ycrcb_subsample import *
+from OpenGL.raw.GL.SGIX.ycrcb_subsample import _EXTENSION_NAME
+
+def glInitYcrcbSubsampleSGIX():
+    '''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/__init__.py

@@ -0,0 +1,47 @@
+"""OpenGL.GL, the core GL library and extensions to it"""
+# early import of our modules to prevent import loops...
+from OpenGL import error as _error
+from OpenGL.GL.VERSION.GL_1_1 import *
+from OpenGL.GL.pointers import *
+from OpenGL.GL.images import *
+
+from OpenGL.GL.exceptional import *
+
+from OpenGL.GL.glget import *
+
+from OpenGL.GL.VERSION.GL_1_2 import *
+from OpenGL.GL.VERSION.GL_1_3 import *
+from OpenGL.GL.VERSION.GL_1_4 import *
+from OpenGL.GL.VERSION.GL_1_5 import *
+from OpenGL.GL.VERSION.GL_2_0 import *
+from OpenGL.GL.VERSION.GL_2_1 import *
+from OpenGL.GL.VERSION.GL_3_0 import *
+from OpenGL.GL.VERSION.GL_3_1 import *
+from OpenGL.GL.VERSION.GL_3_2 import *
+from OpenGL.GL.VERSION.GL_3_3 import *
+from OpenGL.GL.VERSION.GL_4_0 import *
+from OpenGL.GL.VERSION.GL_4_1 import *
+from OpenGL.GL.VERSION.GL_4_2 import *
+from OpenGL.GL.VERSION.GL_4_3 import *
+from OpenGL.GL.VERSION.GL_4_4 import *
+
+from OpenGL.error import *
+GLerror = GLError
+
+# Now the aliases...
+glRotate = glRotated
+glTranslate = glTranslated
+glLight = glLightfv
+glTexCoord = glTexCoord2d
+glScale = glScaled
+#glColor = glColor3f
+glNormal = glNormal3d
+
+glGetBoolean = glGetBooleanv
+glGetDouble = glGetDoublev
+glGetFloat = glGetFloatv
+glGetInteger = glGetIntegerv 
+glGetPolygonStippleub = glGetPolygonStipple
+
+from OpenGL.GL import vboimplementation as _core_implementation
+from OpenGL.GL.ARB import vboimplementation as _arb_implementation

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

@@ -0,0 +1,278 @@
+"""Exceptional cases that need some extra wrapping"""
+from OpenGL import arrays
+from OpenGL.arrays.arraydatatype import GLfloatArray, GLdoubleArray
+from OpenGL.lazywrapper import lazy as _lazy
+from OpenGL.GL.VERSION import GL_1_1 as full
+from OpenGL.raw.GL import _types, _errors
+from OpenGL._bytes import bytes
+from OpenGL import _configflags
+import ctypes
+
+__all__ = [
+    'glBegin',
+    'glCallLists',
+    'glColor',
+    #'glColorTableParameterfv',
+    'glDeleteTextures',
+    'glEnd',
+    'glGenTextures',
+    'glMap1d',
+    'glMap1f',
+    'glMap2d',
+    'glMap2f',
+    'glMaterial',
+    'glRasterPos',
+    'glTexParameter',
+    'glVertex',
+    'glAreTexturesResident',
+]
+
+glRasterPosDispatch = {
+    2: full.glRasterPos2d,
+    3: full.glRasterPos3d,
+    4: full.glRasterPos4d,
+}
+
+if _configflags.ERROR_CHECKING:
+    @_lazy( full.glBegin )
+    def glBegin( baseFunction, mode ):
+        """Begin GL geometry-definition mode, disable automatic error checking"""
+        _errors._error_checker.onBegin( )
+        return baseFunction( mode )
+    @_lazy( full.glEnd )
+    def glEnd( baseFunction ):
+        """Finish GL geometry-definition mode, re-enable automatic error checking"""
+        _errors._error_checker.onEnd( )
+        return baseFunction( )
+else:
+    glBegin = full.glBegin
+    glEnd = full.glEnd
+
+@_lazy( full.glDeleteTextures )
+def glDeleteTextures( baseFunction, array ):
+    """Delete specified set of textures"""
+    ptr = arrays.GLuintArray.asArray( array )
+    size = arrays.GLuintArray.arraySize( ptr )
+    return baseFunction( size, ptr )
+
+
+def glMap2( baseFunction, arrayType ):
+    def glMap2( target, u1, u2, v1, v2, points):
+        """glMap2(target, u1, u2, v1, v2, points[][][]) -> None
+
+        This is a completely non-standard signature which doesn't allow for most
+        of the funky uses with strides and the like, but it has been like this for
+        a very long time...
+        """
+        ptr = arrayType.asArray( points )
+        uorder,vorder,vstride = arrayType.dimensions( ptr )
+        ustride = vstride*vorder
+        return baseFunction(
+            target,
+            u1, u2,
+            ustride, uorder,
+            v1, v2,
+            vstride, vorder,
+            ptr
+        )
+    glMap2.__name__ = baseFunction.__name__
+    glMap2.baseFunction = baseFunction
+    return glMap2
+glMap2d = glMap2( full.glMap2d, arrays.GLdoubleArray )
+glMap2f = glMap2( full.glMap2f, arrays.GLfloatArray )
+try:
+    del glMap2
+except NameError as err:
+    pass
+
+def glMap1( baseFunction, arrayType ):
+    def glMap1(target,u1,u2,points):
+        """glMap1(target, u1, u2, points[][][]) -> None
+
+        This is a completely non-standard signature which doesn't allow for most
+        of the funky uses with strides and the like, but it has been like this for
+        a very long time...
+        """
+        ptr = arrayType.asArray( points )
+        dims = arrayType.dimensions( ptr )
+        uorder = dims[0]
+        ustride = dims[1]
+        return baseFunction( target, u1,u2,ustride,uorder, ptr )
+    glMap1.__name__ == baseFunction.__name__
+    glMap1.baseFunction = baseFunction
+    return glMap1
+glMap1d = glMap1( full.glMap1d, arrays.GLdoubleArray )
+glMap1f = glMap1( full.glMap1f, arrays.GLfloatArray )
+try:
+    del glMap1
+except NameError as err:
+    pass
+
+def glRasterPos( *args ):
+    """Choose glRasterPosX based on number of args"""
+    if len(args) == 1:
+        # v form...
+        args = args[0]
+    function = glRasterPosDispatch[ len(args) ]
+    return function( *args )
+
+glVertexDispatch = {
+    2: full.glVertex2d,
+    3: full.glVertex3d,
+    4: full.glVertex4d,
+}
+def glVertex( *args ):
+    """Choose glVertexX based on number of args"""
+    if len(args) == 1:
+        # v form...
+        args = args[0]
+    return glVertexDispatch[ len(args) ]( *args )
+
+@_lazy( full.glCallLists )
+def glCallLists( baseFunction, lists, *args ):
+    """glCallLists( bytes( lists ) or lists[] ) -> None
+
+    Restricted version of glCallLists, takes a string or a GLuint compatible
+    array data-type and passes into the base function.
+    """
+    if not len(args):
+        if isinstance( lists, bytes ):
+            return baseFunction(
+                len(lists),
+                full.GL_UNSIGNED_BYTE,
+                ctypes.c_void_p(arrays.GLubyteArray.dataPointer( lists )),
+            )
+        ptr = arrays.GLuintArray.asArray( lists )
+        size = arrays.GLuintArray.arraySize( ptr )
+        return baseFunction(
+            size,
+            full.GL_UNSIGNED_INT,
+            ctypes.c_void_p( arrays.GLuintArray.dataPointer(ptr))
+        )
+    return baseFunction( lists, *args )
+
+def glTexParameter( target, pname, parameter ):
+    """Set a texture parameter, choose underlying call based on pname and parameter"""
+    if isinstance( parameter, float ):
+        return full.glTexParameterf( target, pname, parameter )
+    elif isinstance( parameter, int ):
+        return full.glTexParameteri( target, pname, parameter )
+    else:
+        value = GLfloatArray.asArray( parameter, full.GL_FLOAT )
+        return full.glTexParameterfv( target, pname, value )
+
+@_lazy( full.glGenTextures )
+def glGenTextures( baseFunction, count, textures=None ):
+    """Generate count new texture names
+
+    Note: for compatibility with PyOpenGL 2.x and below,
+    a count of 1 will return a single integer, rather than
+    an array of integers.
+    """
+    if count <= 0:
+        raise ValueError( """Can't generate 0 or fewer textures""" )
+    elif count == 1 and _configflags.SIZE_1_ARRAY_UNPACK:
+        # this traditionally returned a single int/long, so we'll continue to
+        # do so, even though it would be easier not to bother.
+        textures = _types.GLuint( 0 )
+        baseFunction( count, textures)
+        return textures.value
+    else:
+        textures = arrays.GLuintArray.zeros( (count,))
+        baseFunction( count, textures)
+        return textures
+
+def glMaterial( faces, constant, *args ):
+    """glMaterial -- convenience function to dispatch on argument type
+
+    If passed a single argument in args, calls:
+        glMaterialfv( faces, constant, args[0] )
+    else calls:
+        glMaterialf( faces, constant, *args )
+    """
+    if len(args) == 1:
+        arg = GLfloatArray.asArray( args[0] )
+        if arg is None:
+            raise ValueError( """Null value in glMaterial: %s"""%(args,) )
+        return full.glMaterialfv( faces, constant, arg )
+    else:
+        return full.glMaterialf( faces, constant, *args )
+
+glColorDispatch = {
+    3: full.glColor3fv,
+    4: full.glColor4fv,
+}
+
+def glColor( *args ):
+    """glColor*f* -- convenience function to dispatch on argument type
+
+    dispatches to glColor3f, glColor2f, glColor4f, glColor3f, glColor2f, glColor4f
+    depending on the arguments passed...
+    """
+    arglen = len(args)
+    if arglen == 1:
+        arg = arrays.GLfloatArray.asArray( args[0] )
+        function = glColorDispatch[arrays.GLfloatArray.arraySize( arg )]
+        return function( arg )
+    elif arglen == 2:
+        return full.glColor2d( *args )
+    elif arglen == 3:
+        return full.glColor3d( *args )
+    elif arglen == 4:
+        return full.glColor4d( *args )
+    else:
+        raise ValueError( """Don't know how to handle arguments: %s"""%(args,))
+
+
+# Rectagle coordinates,
+@_lazy( full.glAreTexturesResident )
+def glAreTexturesResident( baseFunction, *args ):
+    """Allow both Pythonic and C-style calls to glAreTexturesResident
+
+        glAreTexturesResident( arrays.GLuintArray( textures) )
+
+    or
+
+        glAreTexturesResident( int(n), arrays.GLuintArray( textures), arrays.GLuboolean( output) )
+
+    or
+
+        glAreTexturesResident( int(n), arrays.GLuintArray( textures) )
+
+    returns the output arrays.GLubooleanArray
+    """
+    if len(args) == 1:
+        # Pythonic form...
+        textures = args[0]
+        textures = arrays.GLuintArray.asArray( textures )
+        n = arrays.GLuintArray.arraySize(textures)
+        output = arrays.GLbooleanArray.zeros( (n,))
+    elif len(args) == 2:
+        try:
+            n = int( args[0] )
+        except TypeError as err:
+            textures = args[0]
+            textures = arrays.GLuintArray.asArray( textures )
+
+            n = arrays.GLuintArray.arraySize(textures)
+            output = args[1]
+            output = arrays.GLbooleanArray.asArray( output )
+        else:
+            textures = args[1]
+            textures = arrays.GLuintArray.asArray( textures )
+
+            output = arrays.GLbooleanArray.zeros( (n,))
+    elif len(args) == 3:
+        n,textures,output = args
+        textures = arrays.GLuintArray.asArray( textures )
+        output = arrays.GLbooleanArray.asArray( output )
+    else:
+        raise TypeError( """Expected 1 to 3 arguments to glAreTexturesResident""" )
+    texturePtr = arrays.GLuintArray.typedPointer( textures )
+    outputPtr = arrays.GLbooleanArray.typedPointer( output )
+    result = baseFunction( n, texturePtr, outputPtr )
+    if result:
+        # weirdness of the C api, doesn't produce values if all are true
+        for i in range(len(output)):
+            output[i] = 1
+    return output

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

@@ -0,0 +1,86 @@
+"""Utility module to parse a Feedback buffer"""
+from OpenGL import contextdata
+from OpenGL.GL.VERSION import GL_1_1 as _simple
+
+def parseFeedback( buffer, entryCount ):
+    """Parse the feedback buffer into Python object records"""
+    bufferIndex = 0
+    result = []
+    getVertex = createGetVertex( )
+    while bufferIndex < entryCount:
+        token = int(buffer[bufferIndex])
+        bufferIndex += 1
+        if token in SINGLE_VERTEX_TOKENS:
+            vData, bufferIndex = getVertex( buffer, bufferIndex )
+            result.append( (SINGLE_VERTEX_TOKENS.get(token), Vertex(*vData)) )
+        elif token in DOUBLE_VERTEX_TOKENS:
+            vData, bufferIndex = getVertex( buffer, bufferIndex )
+            vData2, bufferIndex = getVertex( buffer, bufferIndex )
+            result.append( (
+                DOUBLE_VERTEX_TOKENS.get(token), 
+                Vertex(*vData),
+                Vertex(*vData2),
+            ) )
+        elif token == _simple.GL_PASS_THROUGH_TOKEN:
+            result.append( (_simple.GL_PASS_THROUGH_TOKEN, buffer[bufferIndex]))
+            bufferIndex += 1
+        elif token == _simple.GL_POLYGON_TOKEN:
+            temp = [_simple.GL_POLYGON_TOKEN]
+            count = int(buffer[bufferIndex])
+            bufferIndex += 1
+            for item in range(count):
+                vData,bufferIndex = getVertex( buffer, bufferIndex )
+                temp.append( Vertex(*vData))
+            result.append( tuple(temp))
+        else:
+            raise ValueError( 
+                """Unrecognised token %r in feedback stream"""%(token,)
+            )
+    return result
+
+SINGLE_VERTEX_TOKENS = {
+    _simple.GL_BITMAP_TOKEN: _simple.GL_BITMAP_TOKEN,
+    _simple.GL_COPY_PIXEL_TOKEN: _simple.GL_COPY_PIXEL_TOKEN,
+    _simple.GL_DRAW_PIXEL_TOKEN: _simple.GL_DRAW_PIXEL_TOKEN,
+    _simple.GL_POINT_TOKEN: _simple.GL_POINT_TOKEN,
+}
+DOUBLE_VERTEX_TOKENS = {
+    _simple.GL_LINE_TOKEN: _simple.GL_LINE_TOKEN,
+    _simple.GL_LINE_RESET_TOKEN: _simple.GL_LINE_RESET_TOKEN,
+}
+class Vertex( object ):
+    """Simplistic holder for vertex data from a feedback buffer"""
+    __slots__ = ('vertex','color','texture')
+    def __init__( self, vertex,color=None,texture=None):
+        """Store values for access"""
+        self.vertex = vertex 
+        self.color = color 
+        self.texture = texture 
+def createGetVertex( ):
+    mode = contextdata.getValue( "GL_FEEDBACK_BUFFER_TYPE" )
+    indexMode = _simple.glGetBooleanv( _simple.GL_INDEX_MODE )
+    colorSize = [ 4,1 ][ int(indexMode) ]
+    if mode in (_simple.GL_2D,_simple.GL_3D):
+        if mode == _simple.GL_2D:
+            size = 2
+        else:
+            size = 3
+        def getVertex( buffer, bufferIndex ):
+            end = bufferIndex+size
+            return (buffer[bufferIndex:end],None,None),end 
+    elif mode == _simple.GL_3D_COLOR:
+        def getVertex( buffer, bufferIndex ):
+            end = bufferIndex+3
+            colorEnd = end + colorSize
+            return (buffer[bufferIndex:end],buffer[end:colorEnd],None),colorEnd 
+    else:
+        if mode == _simple.GL_3D_COLOR_TEXTURE:
+            size = 3
+        else:
+            size = 4
+        def getVertex( buffer, bufferIndex ):
+            end = bufferIndex+size
+            colorEnd = end + colorSize
+            textureEnd = colorEnd + 4
+            return (buffer[bufferIndex:end],buffer[end:colorEnd],buffer[colorEnd:textureEnd]),textureEnd
+    return getVertex

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

@@ -0,0 +1,57 @@
+"""Convenience API for using Frame Buffer Objects"""
+from OpenGL.extensions import alternate
+from OpenGL.GL.ARB.framebuffer_object import *
+from OpenGL.GL.EXT.framebuffer_object import *
+from OpenGL.GL.EXT.framebuffer_multisample import *
+from OpenGL.GL.EXT.framebuffer_blit import *
+
+glBindFramebuffer = alternate(glBindFramebuffer,glBindFramebufferEXT)
+glBindRenderbuffer = alternate( glBindRenderbuffer, glBindRenderbufferEXT )
+glCheckFramebufferStatus = alternate( glCheckFramebufferStatus, glCheckFramebufferStatusEXT )
+glDeleteFramebuffers = alternate( glDeleteFramebuffers, glDeleteFramebuffersEXT )
+glDeleteRenderbuffers = alternate( glDeleteRenderbuffers, glDeleteRenderbuffersEXT )
+glFramebufferRenderbuffer = alternate( glFramebufferRenderbuffer, glFramebufferRenderbufferEXT )
+glFramebufferTexture1D = alternate( glFramebufferTexture1D, glFramebufferTexture1DEXT )
+glFramebufferTexture2D = alternate( glFramebufferTexture2D, glFramebufferTexture2DEXT )
+glFramebufferTexture3D = alternate( glFramebufferTexture3D, glFramebufferTexture3DEXT )
+glGenFramebuffers = alternate( glGenFramebuffers, glGenFramebuffersEXT )
+glGenRenderbuffers = alternate( glGenRenderbuffers, glGenRenderbuffersEXT )
+glGenerateMipmap = alternate( glGenerateMipmap, glGenerateMipmapEXT )
+glGetFramebufferAttachmentParameteriv = alternate( glGetFramebufferAttachmentParameteriv, glGetFramebufferAttachmentParameterivEXT )
+glGetRenderbufferParameteriv = alternate( glGetRenderbufferParameteriv, glGetRenderbufferParameterivEXT )
+glIsFramebuffer = alternate( glIsFramebuffer, glIsFramebufferEXT )
+glIsRenderbuffer = alternate( glIsRenderbuffer, glIsRenderbufferEXT )
+glRenderbufferStorage = alternate( glRenderbufferStorage, glRenderbufferStorageEXT )
+
+glBlitFramebuffer = alternate( glBlitFramebuffer, glBlitFramebufferEXT )  
+glRenderbufferStorageMultisample = alternate( glRenderbufferStorageMultisample, glRenderbufferStorageMultisampleEXT )
+
+# this entry point is new to the ARB version of the extensions
+#glFramebufferTextureLayer = alternate( glFramebufferTextureLayer, glFramebufferTextureLayerEXT )
+
+
+def checkFramebufferStatus():
+    """Utility method to check status and raise errors"""
+    status = glCheckFramebufferStatus( GL_FRAMEBUFFER )
+    if status == GL_FRAMEBUFFER_COMPLETE:
+        return True 
+    from OpenGL.error import GLError
+    description = None
+    for error_constant in [
+        GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
+        GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT,
+        GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS,
+        GL_FRAMEBUFFER_INCOMPLETE_FORMATS,
+        GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER,
+        GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER,
+        GL_FRAMEBUFFER_UNSUPPORTED,
+    ]:
+        if status == error_constant:
+            status = error_constant
+            description = str(status)
+    raise GLError( 
+        err=status, 
+        result=status, 
+        baseOperation=glCheckFramebufferStatus, 
+        description=description,
+    )

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

@@ -0,0 +1,24 @@
+"""Implementation of the special "glGet" functions
+
+For comparison, here's what a straightforward implementation looks like:
+
+    def glGetDoublev( pname ):
+        "Natural writing of glGetDoublev using standard ctypes"
+        output = c_double*sizes.get( pname )
+        result = output()
+        result = platform.PLATFORM.GL.glGetDoublev( pname, byref(result) )
+        return Numeric.array( result )
+"""
+from OpenGL import wrapper
+from OpenGL.GL.VERSION import GL_1_1 as _simple
+import ctypes
+GLenum = ctypes.c_uint
+GLsize = GLsizei = ctypes.c_int
+
+__all__ = (
+    'glGetString',
+)
+
+glGetString = _simple.glGetString
+glGetString.restype = ctypes.c_char_p
+glGetString.__doc__ = """glGetString( constant ) -> Current string value"""

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

@@ -0,0 +1,639 @@
+"""Image-handling routines
+
+### Unresolved:
+
+    Following methods are not yet resolved due to my not being sure how the
+    function should be wrapped:
+
+        glCompressedTexImage3D
+        glCompressedTexImage2D
+        glCompressedTexImage1D
+        glCompressedTexSubImage3D
+        glCompressedTexSubImage2D
+        glCompressedTexSubImage1D
+"""
+from OpenGL.raw.GL.VERSION import GL_1_1,GL_1_2, GL_3_0
+from OpenGL import images, arrays, wrapper
+from OpenGL._bytes import bytes,integer_types
+from OpenGL.raw.GL import _types
+import ctypes
+
+def asInt( value ):
+    if isinstance( value, float ):
+        return int(round(value,0))
+    return value
+
+## update the image tables with standard image types...
+images.COMPONENT_COUNTS.update( {
+    GL_1_1.GL_BITMAP : 1, # must be GL_UNSIGNED_BYTE
+
+    GL_1_1.GL_RED : 1,
+    GL_1_1.GL_GREEN : 1,
+    GL_1_1.GL_BLUE : 1,
+    GL_1_1.GL_ALPHA : 1,
+    GL_3_0.GL_RED_INTEGER : 1,
+    GL_3_0.GL_GREEN_INTEGER : 1,
+    GL_3_0.GL_BLUE_INTEGER : 1,
+    GL_3_0.GL_ALPHA_INTEGER : 1,
+    GL_1_1.GL_LUMINANCE : 1,
+    GL_1_1.GL_LUMINANCE_ALPHA : 2,
+    GL_1_1.GL_COLOR_INDEX : 1,
+    GL_1_1.GL_STENCIL_INDEX : 1,
+    GL_1_1.GL_DEPTH_COMPONENT : 1,
+
+    GL_1_1.GL_RGB : 3,
+    GL_1_2.GL_BGR : 3,
+    GL_3_0.GL_RGB16F : 3,
+    GL_3_0.GL_RGB16I : 3,
+    GL_3_0.GL_RGB16UI : 3,
+    GL_3_0.GL_RGB32F : 3,
+    GL_3_0.GL_RGB32I : 3,
+    GL_3_0.GL_RGB32UI : 3,
+    GL_3_0.GL_RGB8I : 3,
+    GL_3_0.GL_RGB8UI : 3,
+    GL_3_0.GL_RGB9_E5 : 3,
+    GL_3_0.GL_RGB_INTEGER : 3,
+
+    GL_1_1.GL_RGBA : 4,
+    GL_1_2.GL_BGRA : 4,
+    GL_3_0.GL_RGBA16F : 4,
+    GL_3_0.GL_RGBA16I : 4,
+    GL_3_0.GL_RGBA16UI : 4,
+    GL_3_0.GL_RGBA32F : 4,
+    GL_3_0.GL_RGBA32I : 4,
+    GL_3_0.GL_RGBA32UI : 4,
+    GL_3_0.GL_RGBA8I : 4,
+    GL_3_0.GL_RGBA8UI : 4,
+    GL_3_0.GL_RGBA_INTEGER : 4,
+} )
+
+images.TYPE_TO_ARRAYTYPE.update( {
+    GL_1_2.GL_UNSIGNED_BYTE_3_3_2 : GL_1_1.GL_UNSIGNED_BYTE,
+    GL_1_2.GL_UNSIGNED_BYTE_2_3_3_REV : GL_1_1.GL_UNSIGNED_BYTE,
+    GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4 : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4_REV : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_SHORT_5_5_5_1 : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_SHORT_1_5_5_5_REV : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_SHORT_5_6_5 : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_SHORT_5_6_5_REV : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_2.GL_UNSIGNED_INT_8_8_8_8 : GL_1_1.GL_UNSIGNED_INT,
+    GL_1_2.GL_UNSIGNED_INT_8_8_8_8_REV : GL_1_1.GL_UNSIGNED_INT,
+    GL_1_2.GL_UNSIGNED_INT_10_10_10_2 : GL_1_1.GL_UNSIGNED_INT,
+    GL_1_2.GL_UNSIGNED_INT_2_10_10_10_REV : GL_1_1.GL_UNSIGNED_INT,
+    GL_1_1.GL_UNSIGNED_BYTE : GL_1_1.GL_UNSIGNED_BYTE,
+    GL_1_1.GL_BYTE: GL_1_1.GL_BYTE,
+    GL_1_1.GL_UNSIGNED_SHORT : GL_1_1.GL_UNSIGNED_SHORT,
+    GL_1_1.GL_SHORT :  GL_1_1.GL_SHORT,
+    GL_1_1.GL_UNSIGNED_INT : GL_1_1.GL_UNSIGNED_INT,
+    GL_1_1.GL_INT : GL_1_1.GL_INT,
+    GL_1_1.GL_FLOAT : GL_1_1.GL_FLOAT,
+    GL_1_1.GL_DOUBLE : GL_1_1.GL_DOUBLE,
+    GL_1_1.GL_BITMAP : GL_1_1.GL_UNSIGNED_BYTE,
+} )
+images.TIGHT_PACK_FORMATS.update({
+    GL_1_2.GL_UNSIGNED_BYTE_3_3_2 : 3,
+    GL_1_2.GL_UNSIGNED_BYTE_2_3_3_REV : 3,
+    GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4 : 4,
+    GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4_REV : 4,
+    GL_1_2.GL_UNSIGNED_SHORT_5_5_5_1 : 4,
+    GL_1_2.GL_UNSIGNED_SHORT_1_5_5_5_REV : 4,
+    GL_1_2.GL_UNSIGNED_SHORT_5_6_5 : 3,
+    GL_1_2.GL_UNSIGNED_SHORT_5_6_5_REV : 3,
+    GL_1_2.GL_UNSIGNED_INT_8_8_8_8 : 4,
+    GL_1_2.GL_UNSIGNED_INT_8_8_8_8_REV : 4,
+    GL_1_2.GL_UNSIGNED_INT_10_10_10_2 : 4,
+    GL_1_2.GL_UNSIGNED_INT_2_10_10_10_REV : 4,
+    GL_1_1.GL_BITMAP: 8, # single bits, 8 of them...
+})
+
+images.RANK_PACKINGS.update( {
+    4: [
+        # Note the sgis parameters are skipped here unless you import 
+        # the sgis texture4D extension...
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1),
+    ],
+    3: [
+        (GL_1_1.glPixelStorei,GL_1_2.GL_PACK_SKIP_IMAGES, 0),
+        (GL_1_1.glPixelStorei,GL_1_2.GL_PACK_IMAGE_HEIGHT, 0),
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1),
+    ],
+    2: [
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ROW_LENGTH, 0),
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_SKIP_ROWS, 0),
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1),
+    ],
+    1: [
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_SKIP_PIXELS, 0),
+        (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1),
+    ],
+} )
+
+
+__all__ = (
+    'glReadPixels',
+    'glReadPixelsb',
+    'glReadPixelsd',
+    'glReadPixelsf',
+    'glReadPixelsi',
+    'glReadPixelss',
+    'glReadPixelsub',
+    'glReadPixelsui',
+    'glReadPixelsus',
+
+    'glGetTexImage',
+
+    'glDrawPixels',
+    'glDrawPixelsb',
+    'glDrawPixelsf',
+    'glDrawPixelsi',
+    'glDrawPixelss',
+    'glDrawPixelsub',
+    'glDrawPixelsui',
+    'glDrawPixelsus',
+
+
+    'glTexSubImage2D',
+    'glTexSubImage1D',
+    #'glTexSubImage3D',
+
+    'glTexImage1D',
+    'glTexImage2D',
+    #'glTexImage3D',
+
+    'glGetTexImageb',
+    'glGetTexImaged',
+    'glGetTexImagef',
+    'glGetTexImagei',
+    'glGetTexImages',
+    'glGetTexImageub',
+    'glGetTexImageui',
+    'glGetTexImageus',
+    'glTexImage1Db',
+    'glTexImage2Db',
+    #'glTexImage3Db',
+    'glTexSubImage1Db',
+    'glTexSubImage2Db',
+    #'glTexSubImage3Db',
+    'glTexImage1Df',
+    'glTexImage2Df',
+    #'glTexImage3Df',
+    'glTexSubImage1Df',
+    'glTexSubImage2Df',
+    #'glTexSubImage3Df',
+    'glTexImage1Di',
+    'glTexImage2Di',
+    #'glTexImage3Di',
+    'glTexSubImage1Di',
+    'glTexSubImage2Di',
+    #'glTexSubImage3Di',
+    'glTexImage1Ds',
+    'glTexImage2Ds',
+    #'glTexImage3Ds',
+    'glTexSubImage1Ds',
+    'glTexSubImage2Ds',
+    #'glTexSubImage3Ds',
+    'glTexImage1Dub',
+    'glTexImage2Dub',
+    #'glTexImage3Dub',
+    'glTexSubImage1Dub',
+    'glTexSubImage2Dub',
+    #'glTexSubImage3Dub',
+    'glTexImage1Dui',
+    'glTexImage2Dui',
+    #'glTexImage3Dui',
+    'glTexSubImage1Dui',
+    'glTexSubImage2Dui',
+    #'glTexSubImage3Dui',
+    'glTexImage1Dus',
+    'glTexImage2Dus',
+    #'glTexImage3Dus',
+    'glTexSubImage1Dus',
+    'glTexSubImage2Dus',
+    #'glTexSubImage3Dus',
+
+    #'glColorTable',
+    #'glGetColorTable',
+    #'glColorSubTable',
+
+    #'glConvolutionFilter1D',
+    #'glConvolutionFilter2D',
+    #'glGetConvolutionFilter',
+    #'glSeparableFilter2D',
+    #'glGetSeparableFilter',
+
+    #'glGetMinmax',
+)
+
+def _get_texture_level_dims(target,level):
+    """Retrieve texture dims for given level and target"""
+    dims = []
+    dim = _types.GLuint()
+    GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_WIDTH, dim )
+    dims = [dim.value]
+    if target != GL_1_1.GL_TEXTURE_1D:
+        GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_HEIGHT, dim )
+        dims.append( dim.value )
+        if target != GL_1_1.GL_TEXTURE_2D:
+            GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_DEPTH, dim )
+            dims.append( dim.value )
+    return dims
+
+for suffix,type in [
+    ('b',GL_1_1.GL_BYTE),
+    ('d',GL_1_1.GL_DOUBLE),
+    ('f',GL_1_1.GL_FLOAT),
+    ('i',GL_1_1.GL_INT),
+    ('s',GL_1_1.GL_SHORT),
+    ('ub',GL_1_1.GL_UNSIGNED_BYTE),
+    ('ui',GL_1_1.GL_UNSIGNED_INT),
+    ('us',GL_1_1.GL_UNSIGNED_SHORT),
+]:
+    def glReadPixels( x,y,width,height,format,type=type, array=None, outputType=bytes ):
+        """Read specified pixels from the current display buffer
+
+        This typed version returns data in your specified default
+        array data-type format, or in the passed array, which will
+        be converted to the array-type required by the format.
+        """
+        x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height)
+        arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ]
+        
+        if array is None:
+            array = imageData = images.SetupPixelRead( format, (width,height), type )
+            owned = True
+        else:
+            if isinstance( array, integer_types):
+                imageData = ctypes.c_void_p( array )
+            else:
+                array = arrayType.asArray( array )
+                imageData = arrayType.voidDataPointer( array )
+            owned = False
+        GL_1_1.glReadPixels(
+            x,y,
+            width, height,
+            format,type,
+            imageData
+        )
+        if owned and outputType is bytes:
+            return images.returnFormat( array, type )
+        else:
+            return array
+    globals()["glReadPixels%s"%(suffix,)] = glReadPixels
+    def glGetTexImage( target, level,format,type=type, array=None, outputType=bytes ):
+        """Get a texture-level as an image
+        
+        target -- enum constant for the texture engine to be read
+        level -- the mip-map level to read
+        format -- image format to read out the data
+        type -- data-type into which to read the data
+        array -- optional array/offset into which to store the value
+
+        outputType -- default (bytes) provides string output of the
+            results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True
+            and type == GL_UNSIGNED_BYTE.  Any other value will cause
+            output in the default array output format.
+
+        returns the pixel data array in the format defined by the
+        format, type and outputType
+        """
+        arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ]
+        if array is None:
+            dims = _get_texture_level_dims(target,level)
+            array = imageData = images.SetupPixelRead( format, tuple(dims), type )
+            owned = True
+        else:
+            if isinstance( array, integer_types):
+                imageData = ctypes.c_void_p( array )
+            else:
+                array = arrayType.asArray( array )
+                imageData = arrayType.voidDataPointer( array )
+            owned = False
+        GL_1_1.glGetTexImage(
+            target, level, format, type, imageData
+        )
+        if owned and outputType is bytes:
+            return images.returnFormat( array, type )
+        else:
+            return array
+    globals()["glGetTexImage%s"%(suffix,)] = glGetTexImage
+##	def glGetTexSubImage( target, level,format,type ):
+##		"""Get a texture-level as an image"""
+##		dims = [GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_WIDTH )]
+##		if target != GL_1_1.GL_TEXTURE_1D:
+##			dims.append( GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_HEIGHT ) )
+##			if target != GL_1_1.GL_TEXTURE_2D:
+##				dims.append( GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_2.GL_TEXTURE_DEPTH ) )
+##		array = images.SetupPixelRead( format, tuple(dims), type )
+##		arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ]
+##		GL_1_1.glGetTexImage(
+##			target, level, format, type, ctypes.c_void_p( arrayType.dataPointer(array))
+##		)
+##		return array
+##	"%s = glGetTexImage"%(suffix)
+    try:
+        del suffix,type
+    except NameError as err:
+        pass
+# Now the real glReadPixels...
+def glReadPixels( x,y,width,height,format,type, array=None, outputType=bytes ):
+    """Read specified pixels from the current display buffer
+
+    x,y,width,height -- location and dimensions of the image to read
+        from the buffer
+    format -- pixel format for the resulting data
+    type -- data-format for the resulting data
+    array -- optional array/offset into which to store the value
+    outputType -- default (bytes) provides string output of the
+        results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True
+        and type == GL_UNSIGNED_BYTE.  Any other value will cause
+        output in the default array output format.
+
+    returns the pixel data array in the format defined by the
+    format, type and outputType
+    """
+    x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height)
+
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ]
+    if array is None:
+        array = imageData = images.SetupPixelRead( format, (width,height), type )
+        owned = True
+    else:
+        if isinstance( array, integer_types):
+            imageData = ctypes.c_void_p( array )
+        else:
+            array = arrayType.asArray( array )
+            imageData = arrayType.voidDataPointer( array )
+        owned = False
+
+    GL_1_1.glReadPixels(
+        x,y,width,height,
+        format,type,
+        imageData
+    )
+    if owned and outputType is bytes:
+        return images.returnFormat( array, type )
+    else:
+        return array
+
+def glGetTexImage( target, level,format,type, array=None, outputType=bytes ):
+    """Get a texture-level as an image
+
+    target -- enum constant for the texture engine to be read
+    level -- the mip-map level to read
+    format -- image format to read out the data
+    type -- data-type into which to read the data
+    array -- optional array/offset into which to store the value
+
+    outputType -- default (bytes) provides string output of the
+        results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True
+        and type == GL_UNSIGNED_BYTE.  Any other value will cause
+        output in the default array output format.
+
+    returns the pixel data array in the format defined by the
+    format, type and outputType
+    """
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ]
+    if array is None:
+        dims = _get_texture_level_dims(target,level)
+        array = imageData = images.SetupPixelRead( format, tuple(dims), type )
+        owned = True
+    else:
+        if isinstance( array, integer_types):
+            imageData = ctypes.c_void_p( array )
+        else:
+            array = arrayType.asArray( array )
+            imageData = arrayType.voidDataPointer( array )
+        owned = False
+    GL_1_1.glGetTexImage(
+        target, level, format, type, imageData
+    )
+    if outputType is bytes:
+        return images.returnFormat( array, type )
+    else:
+        return array
+
+
+INT_DIMENSION_NAMES = [
+    'width','height','depth','x','y','z',
+    'xoffset','yoffset','zoffset',
+    'start', 'count',
+]
+def asWrapper( value ):
+    if not isinstance( value, wrapper.Wrapper ):
+        return wrapper.wrapper( value )
+    return value
+
+def asIntConverter( value, *args ):
+    if isinstance( value, float ):
+        return int(round(value,0))
+    return value
+
+def setDimensionsAsInts( baseOperation ):
+    """Set arguments with names in INT_DIMENSION_NAMES to asInt processing"""
+    baseOperation = asWrapper( baseOperation )
+    argNames = getattr( baseOperation, 'pyConverterNames', baseOperation.argNames )
+    for i,argName in enumerate(argNames):
+        if argName in INT_DIMENSION_NAMES:
+            baseOperation.setPyConverter( argName, asIntConverter )
+    return baseOperation
+
+
+
+class ImageInputConverter( object ):
+    def __init__( self, rank, pixelsName=None, typeName='type' ):
+        self.rank = rank
+        self.typeName = typeName
+        self.pixelsName = pixelsName
+    def finalise( self, wrapper ):
+        """Get our pixel index from the wrapper"""
+        self.typeIndex = wrapper.pyArgIndex( self.typeName )
+        self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName )
+    def __call__( self, arg, baseOperation, pyArgs ):
+        """pyConverter for the pixels argument"""
+        images.setupDefaultTransferMode()
+        images.rankPacking( self.rank )
+        type = pyArgs[ self.typeIndex ]
+        arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE[ type ] ]
+        return arrayType.asArray( arg )
+#	def cResolver( self, array ):
+#		return array
+#		return ctypes.c_void_p( arrays.ArrayDatatype.dataPointer( array ) )
+
+class TypedImageInputConverter( ImageInputConverter ):
+    def __init__( self, rank, pixelsName, arrayType, typeName=None ):
+        self.rank = rank
+        self.arrayType = arrayType
+        self.pixelsName = pixelsName
+        self.typeName = typeName
+    def __call__( self, arg, baseOperation, pyArgs ):
+        """The pyConverter for the pixels"""
+        images.setupDefaultTransferMode()
+        images.rankPacking( self.rank )
+        return self.arrayType.asArray( arg )
+    def finalise( self, wrapper ):
+        """Get our pixel index from the wrapper"""
+        self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName )
+    def width( self, pyArgs, index, wrappedOperation ):
+        """Extract the width from the pixels argument"""
+        return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[0]
+    def height( self, pyArgs, index, wrappedOperation ):
+        """Extract the height from the pixels argument"""
+        return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[1]
+    def depth( self, pyArgs, index, wrappedOperation ):
+        """Extract the depth from the pixels argument"""
+        return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[2]
+    def type( self, pyArgs, index, wrappedOperation ):
+        """Provide the item-type argument from our stored value
+
+        This is used for pre-bound processing where we want to provide
+        the type by implication...
+        """
+        return self.typeName
+
+class CompressedImageConverter( object ):
+    def finalise( self, wrapper ):
+        """Get our pixel index from the wrapper"""
+        self.dataIndex = wrapper.pyArgIndex( 'data' )
+    def __call__( self, pyArgs, index, wrappedOperation ):
+        """Create a data-size measurement for our image"""
+        arg = pyArgs[ self.dataIndex ]
+        return arrays.ArrayType.arrayByteCount( arg )
+
+
+
+DIMENSION_NAMES = (
+    'width','height','depth'
+)
+PIXEL_NAMES = (
+    'pixels', 'row', 'column',
+)
+DATA_SIZE_NAMES = (
+    'imageSize',
+)
+
+def setImageInput(
+    baseOperation, arrayType=None, dimNames=DIMENSION_NAMES,
+    pixelName="pixels", typeName=None
+):
+    """Determine how to convert "pixels" into an image-compatible argument"""
+    baseOperation = asWrapper( baseOperation )
+    # rank is the count of width,height,depth arguments...
+    rank = len([
+        # rank is the number of dims we want, not the number we give...
+        argName for argName in baseOperation.argNames
+        if argName in dimNames
+    ]) + 1
+    if arrayType:
+        converter = TypedImageInputConverter( rank, pixelName, arrayType, typeName=typeName )
+        for i,argName in enumerate(baseOperation.argNames):
+            if argName in dimNames:
+                baseOperation.setPyConverter( argName )
+                baseOperation.setCConverter( argName, getattr(converter,argName) )
+            elif argName == 'type' and typeName is not None:
+                baseOperation.setPyConverter( argName )
+                baseOperation.setCConverter( argName, converter.type )
+    else:
+        converter = ImageInputConverter( rank, pixelsName=pixelName, typeName=typeName or 'type' )
+    for argName in baseOperation.argNames:
+        if argName in DATA_SIZE_NAMES:
+            baseOperation.setPyConverter( argName )
+            baseOperation.setCConverter( argName, converter.imageDataSize )
+    baseOperation.setPyConverter(
+        pixelName, converter,
+    )
+#	baseOperation.setCResolver(
+#		pixelName, converter.cResolver
+#	)
+    return baseOperation
+
+glDrawPixels = setDimensionsAsInts(
+    setImageInput(
+        GL_1_1.glDrawPixels
+    )
+)
+glTexSubImage2D = setDimensionsAsInts(
+    setImageInput(
+        GL_1_1.glTexSubImage2D
+    )
+)
+glTexSubImage1D = setDimensionsAsInts(
+    setImageInput(
+        GL_1_1.glTexSubImage1D
+    )
+)
+glTexImage2D = setDimensionsAsInts(
+    setImageInput(
+        GL_1_1.glTexImage2D
+    )
+)
+glTexImage1D = setDimensionsAsInts(
+    setImageInput(
+        GL_1_1.glTexImage1D
+    )
+)
+
+def typedImageFunction( suffix, arrayConstant,  baseFunction ):
+    """Produce a typed version of the given image function"""
+    functionName = baseFunction.__name__
+    functionName = '%(functionName)s%(suffix)s'%locals()
+    if baseFunction:
+        arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ arrayConstant ]
+        function = setDimensionsAsInts(
+            setImageInput(
+                baseFunction,
+                arrayType,
+                typeName = arrayConstant,
+            )
+        )
+        return functionName, function
+    else:
+        return functionName, baseFunction
+
+def _setDataSize( baseFunction, argument='imageSize' ):
+    """Set the data-size value to come from the data field"""
+    if baseFunction:
+        converter = CompressedImageConverter()
+        return asWrapper( baseFunction ).setPyConverter(
+            argument
+        ).setCConverter( argument, converter )
+    else:
+        return baseFunction
+
+def compressedImageFunction( baseFunction ):
+    """Set the imageSize and dimensions-as-ints converters for baseFunction"""
+    if baseFunction:
+        return setDimensionsAsInts(
+            _setDataSize(
+                baseFunction, argument='imageSize'
+            )
+        )
+    else:
+        return baseFunction
+
+for suffix,arrayConstant in [
+    ('b', GL_1_1.GL_BYTE),
+    ('f', GL_1_1.GL_FLOAT),
+    ('i', GL_1_1.GL_INT),
+    ('s', GL_1_1.GL_SHORT),
+    ('ub', GL_1_1.GL_UNSIGNED_BYTE),
+    ('ui', GL_1_1.GL_UNSIGNED_INT),
+    ('us', GL_1_1.GL_UNSIGNED_SHORT),
+]:
+    for functionName in (
+        'glTexImage1D','glTexImage2D',
+        'glTexSubImage1D','glTexSubImage2D',
+        'glDrawPixels',
+        #'glTexSubImage3D','glTexImage3D', # extension/1.2 standard
+    ):
+        functionName, function = typedImageFunction(
+            suffix, arrayConstant, getattr(GL_1_1,functionName),
+        )
+        globals()[functionName] = function
+        try:
+            del function, functionName
+        except NameError as err:
+            pass
+    try:
+        del suffix,arrayConstant
+    except NameError as err:
+        pass

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

@@ -0,0 +1,308 @@
+"""Implementations for "held-pointers" of various types
+
+This argument type is special because it is stored, that is, it
+needs to be cached on our side so that the memory address does not
+go out-of-scope
+
+storedPointers = {}
+def glVertexPointerd( array ):
+    "Natural writing of glVertexPointerd using standard ctypes"
+    arg2 = GL_DOUBLE
+    arg3 = 0 # stride
+    arg4 = arrays.asArray(array, GL_DOUBLE)
+    arg1 = arrays.arraySize( arg4, 'd' )
+    platform.PLATFORM.GL.glVertexPointer( arg1, arg2, arg3, arrays.ArrayDatatype.dataPointer(arg4) )
+    # only store if we successfully set the value...
+    storedPointers[ GL_VERTEX_ARRAY ] = arg4
+    return arg4
+"""
+from OpenGL import platform, error, wrapper, contextdata, converters, constant
+from OpenGL.arrays import arrayhelpers, arraydatatype
+from OpenGL.raw.GL.VERSION import GL_1_1 as _simple
+import ctypes
+
+GLsizei = ctypes.c_int
+GLenum = ctypes.c_uint
+GLint = ctypes.c_int
+# OpenGL-ctypes variables that mimic OpenGL constant operation...
+GL_INTERLEAVED_ARRAY_POINTER = constant.Constant( 'GL_INTERLEAVED_ARRAY_POINTER', -32910 )
+
+__all__ = (
+    'glColorPointer',
+    'glColorPointerb','glColorPointerd','glColorPointerf','glColorPointeri',
+    'glColorPointers','glColorPointerub','glColorPointerui','glColorPointerus',
+    'glEdgeFlagPointer',
+    'glEdgeFlagPointerb',
+    'glIndexPointer',
+    'glIndexPointerb','glIndexPointerd','glIndexPointerf',
+    'glIndexPointeri','glIndexPointers','glIndexPointerub',
+    'glNormalPointer',
+    'glNormalPointerb',
+    'glNormalPointerd','glNormalPointerf','glNormalPointeri','glNormalPointers',
+    'glTexCoordPointer',
+    'glTexCoordPointerb','glTexCoordPointerd','glTexCoordPointerf',
+    'glTexCoordPointeri','glTexCoordPointers',
+    'glVertexPointer',
+    'glVertexPointerb','glVertexPointerd','glVertexPointerf','glVertexPointeri',
+    'glVertexPointers',
+    'glDrawElements','glDrawElementsui','glDrawElementsub','glDrawElementsus',
+    'glFeedbackBuffer',
+    'glSelectBuffer',
+    'glRenderMode',
+    'glGetPointerv',
+    'glInterleavedArrays',
+    'GL_INTERLEAVED_ARRAY_POINTER',
+)
+
+
+# Have to create *new* ctypes wrappers for the platform object!
+# We can't just alter the default one since we have different ways of
+# calling it
+
+POINTER_FUNCTION_DATA = [
+    ('glColorPointerd',  _simple.glColorPointer, _simple.GL_DOUBLE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointerf',  _simple.glColorPointer, _simple.GL_FLOAT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointeri',  _simple.glColorPointer, _simple.GL_INT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointers',  _simple.glColorPointer, _simple.GL_SHORT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointerub', _simple.glColorPointer, _simple.GL_UNSIGNED_BYTE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    # these data-types are mapped from diff Numeric types
+    ('glColorPointerb',  _simple.glColorPointer, _simple.GL_BYTE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointerui', _simple.glColorPointer, _simple.GL_UNSIGNED_INT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+    ('glColorPointerus', _simple.glColorPointer, _simple.GL_UNSIGNED_SHORT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3),
+
+    ('glEdgeFlagPointerb', _simple.glEdgeFlagPointer, _simple.GL_BYTE, _simple.GL_EDGE_FLAG_ARRAY_POINTER, 2, None),
+
+    ('glIndexPointerd',  _simple.glIndexPointer, _simple.GL_DOUBLE, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+    ('glIndexPointerf',  _simple.glIndexPointer, _simple.GL_FLOAT, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+    ('glIndexPointeri',  _simple.glIndexPointer, _simple.GL_INT, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+    ('glIndexPointerub', _simple.glIndexPointer, _simple.GL_UNSIGNED_BYTE, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+    ('glIndexPointers',  _simple.glIndexPointer, _simple.GL_SHORT, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+    # these data-types are mapped from diff Numeric types
+    ('glIndexPointerb',  _simple.glIndexPointer, _simple.GL_BYTE, _simple.GL_INDEX_ARRAY_POINTER, 1, None),
+
+    ('glNormalPointerd',  _simple.glNormalPointer, _simple.GL_DOUBLE, _simple.GL_NORMAL_ARRAY_POINTER, 1, None),
+    ('glNormalPointerf',  _simple.glNormalPointer, _simple.GL_FLOAT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None),
+    ('glNormalPointeri',  _simple.glNormalPointer, _simple.GL_INT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None),
+    ('glNormalPointerb',  _simple.glNormalPointer, _simple.GL_BYTE, _simple.GL_NORMAL_ARRAY_POINTER, 1, None),
+    ('glNormalPointers',  _simple.glNormalPointer, _simple.GL_SHORT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None),
+
+    ('glTexCoordPointerd',  _simple.glTexCoordPointer, _simple.GL_DOUBLE, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2),
+    ('glTexCoordPointerf',  _simple.glTexCoordPointer, _simple.GL_FLOAT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2),
+    ('glTexCoordPointeri',  _simple.glTexCoordPointer, _simple.GL_INT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2),
+    ('glTexCoordPointerb',  _simple.glTexCoordPointer, _simple.GL_BYTE, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2),
+    ('glTexCoordPointers',  _simple.glTexCoordPointer, _simple.GL_SHORT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2),
+
+    ('glVertexPointerd', _simple.glVertexPointer, _simple.GL_DOUBLE, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3),
+    ('glVertexPointerf', _simple.glVertexPointer, _simple.GL_FLOAT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3),
+    ('glVertexPointeri', _simple.glVertexPointer, _simple.GL_INT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3),
+    ('glVertexPointerb', _simple.glVertexPointer, _simple.GL_INT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3),
+    ('glVertexPointers', _simple.glVertexPointer, _simple.GL_SHORT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3),
+]
+def wrapPointerFunction( name, baseFunction, glType, arrayType,startArgs, defaultSize ):
+    """Wrap the given pointer-setting function"""
+    function= wrapper.wrapper( baseFunction )
+    if 'ptr' in baseFunction.argNames:
+        pointer_name = 'ptr'
+    else:
+        pointer_name = 'pointer'
+    assert not getattr( function, 'pyConverters', None ), """Reusing wrappers?"""
+    if arrayType:
+        arrayModuleType = arraydatatype.GL_CONSTANT_TO_ARRAY_TYPE[ glType ]
+        function.setPyConverter( pointer_name, arrayhelpers.asArrayType(arrayModuleType) )
+    else:
+        function.setPyConverter( pointer_name, arrayhelpers.AsArrayOfType(pointer_name,'type') )
+    function.setCConverter( pointer_name, converters.getPyArgsName( pointer_name ) )
+    if 'size' in function.argNames:
+        function.setPyConverter( 'size' )
+        function.setCConverter( 'size', arrayhelpers.arraySizeOfFirstType(arrayModuleType,defaultSize) )
+    if 'type' in function.argNames:
+        function.setPyConverter( 'type' )
+        function.setCConverter( 'type', glType )
+    if 'stride' in function.argNames:
+        function.setPyConverter( 'stride' )
+        function.setCConverter( 'stride', 0 )
+    function.setStoreValues( arrayhelpers.storePointerType( pointer_name, arrayType ) )
+    function.setReturnValues( wrapper.returnPyArgument( pointer_name ) )
+    return name,function
+
+
+
+for name,function in [
+    wrapPointerFunction( *args )
+    for args in POINTER_FUNCTION_DATA
+]:
+    globals()[name] = function
+try:
+    del name, function
+except NameError as err:
+    pass
+
+glVertexPointer = wrapper.wrapper( _simple.glVertexPointer ).setPyConverter(
+    'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_VERTEX_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glTexCoordPointer = wrapper.wrapper( _simple.glTexCoordPointer ).setPyConverter(
+    'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_TEXTURE_COORD_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glNormalPointer = wrapper.wrapper( _simple.glNormalPointer ).setPyConverter(
+    'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_NORMAL_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glIndexPointer = wrapper.wrapper( _simple.glIndexPointer ).setPyConverter(
+    'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_INDEX_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glEdgeFlagPointer = wrapper.wrapper( _simple.glEdgeFlagPointer ).setPyConverter(
+    # XXX type is wrong!
+    'pointer', arrayhelpers.AsArrayTyped( 'pointer', arraydatatype.GLushortArray ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_EDGE_FLAG_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glColorPointer = wrapper.wrapper( _simple.glColorPointer ).setPyConverter(
+    'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ),
+).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', _simple.GL_COLOR_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+glInterleavedArrays = wrapper.wrapper( _simple.glInterleavedArrays ).setStoreValues(
+    arrayhelpers.storePointerType( 'pointer', GL_INTERLEAVED_ARRAY_POINTER )
+).setReturnValues(
+    wrapper.returnPyArgument( 'pointer' )
+)
+
+
+glDrawElements = wrapper.wrapper( _simple.glDrawElements ).setPyConverter(
+    'indices', arrayhelpers.AsArrayOfType( 'indices', 'type' ),
+).setReturnValues(
+    wrapper.returnPyArgument( 'indices' )
+)
+
+def glDrawElementsTyped( type, suffix ):
+    arrayType = arraydatatype.GL_CONSTANT_TO_ARRAY_TYPE[ type ]
+    function = wrapper.wrapper(
+        _simple.glDrawElements
+    ).setPyConverter('type').setCConverter(
+        'type', type
+    ).setPyConverter('count').setCConverter(
+        'count', arrayhelpers.AsArrayTypedSize( 'indices', arrayType ),
+    ).setPyConverter(
+        'indices', arrayhelpers.AsArrayTyped( 'indices', arrayType ),
+    ).setReturnValues(
+        wrapper.returnPyArgument( 'indices' )
+    )
+    return function
+for type,suffix in ((_simple.GL_UNSIGNED_BYTE,'ub'),(_simple.GL_UNSIGNED_INT,'ui'),(_simple.GL_UNSIGNED_SHORT,'us')):
+    globals()['glDrawElements%(suffix)s'%globals()] = glDrawElementsTyped( type,suffix )
+try:
+    del type,suffix,glDrawElementsTyped
+except NameError as err:
+    pass
+
+# create buffer of given size and return it for future reference
+# keep a per-context weakref around to allow us to return the original
+# array we returned IFF the user has kept a reference as well...
+def glSelectBuffer( size, buffer = None ):
+    """Create a selection buffer of the given size
+    """
+    if buffer is None:
+        buffer = arraydatatype.GLuintArray.zeros( (size,) )
+    _simple.glSelectBuffer( size, buffer )
+    contextdata.setValue( _simple.GL_SELECTION_BUFFER_POINTER, buffer )
+    return buffer
+def glFeedbackBuffer( size, type, buffer = None ):
+    """Create a selection buffer of the given size
+    """
+    if buffer is None:
+        buffer = arraydatatype.GLfloatArray.zeros( (size,) )
+    _simple.glFeedbackBuffer( size, type, buffer )
+    contextdata.setValue( _simple.GL_FEEDBACK_BUFFER_POINTER, buffer )
+    contextdata.setValue( "GL_FEEDBACK_BUFFER_TYPE", type )
+    return buffer
+
+def glRenderMode( newMode ):
+    """Change to the given rendering mode
+
+    If the current mode is GL_FEEDBACK or GL_SELECT, return
+    the current buffer appropriate to the mode
+    """
+    # must get the current mode to determine operation...
+    from OpenGL.GL import glGetIntegerv
+    from OpenGL.GL import selection, feedback
+    currentMode = glGetIntegerv( _simple.GL_RENDER_MODE )
+    try:
+        currentMode = currentMode[0]
+    except (TypeError,ValueError,IndexError) as err:
+        pass
+    if currentMode in (_simple.GL_RENDER,0):
+        # no array needs to be returned...
+        return _simple.glRenderMode( newMode )
+    result = _simple.glRenderMode( newMode )
+    # result is now an integer telling us how many elements were copied...
+
+    if result < 0:
+        if currentMode == _simple.GL_SELECT:
+            raise error.GLError(
+                _simple.GL_STACK_OVERFLOW,
+                "glSelectBuffer too small to hold selection results",
+            )
+        elif currentMode == _simple.GL_FEEDBACK:
+            raise error.GLError(
+                _simple.GL_STACK_OVERFLOW,
+                "glFeedbackBuffer too small to hold selection results",
+            )
+        else:
+            raise error.GLError(
+                _simple.GL_STACK_OVERFLOW,
+                "Unknown glRenderMode buffer (%s) too small to hold selection results"%(
+                    currentMode,
+                ),
+            )
+    # Okay, now that the easy cases are out of the way...
+    #  Do we have a pre-stored pointer about which the user already knows?
+    context = platform.GetCurrentContext()
+    if context == 0:
+        raise error.Error(
+            """Returning from glRenderMode without a valid context!"""
+        )
+    arrayConstant, wrapperFunction = {
+        _simple.GL_FEEDBACK: (_simple.GL_FEEDBACK_BUFFER_POINTER,feedback.parseFeedback),
+        _simple.GL_SELECT: (_simple.GL_SELECTION_BUFFER_POINTER, selection.GLSelectRecord.fromArray),
+    }[ currentMode ]
+    current = contextdata.getValue( arrayConstant )
+    # XXX check to see if it's the *same* array we set currently!
+    if current is None:
+        current = glGetPointerv( arrayConstant )
+    # XXX now, can turn the array into the appropriate wrapper type...
+    if wrapperFunction:
+        current = wrapperFunction( current, result )
+    return current
+
+# XXX this belongs in the GL module, not here!
+def glGetPointerv( constant ):
+    """Retrieve a stored pointer constant"""
+    # do we have a cached version of the pointer?
+    # get the base pointer from the underlying operation
+    vp = ctypes.voidp()
+    _simple.glGetPointerv( constant, ctypes.byref(vp) )
+    current = contextdata.getValue( constant )
+    if current is not None:
+        if arraydatatype.ArrayDatatype.dataPointer( current ) == vp.value:
+            return current
+    # XXX should be coercing to the proper type and converting to an array
+    return vp

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

@@ -0,0 +1,64 @@
+"""Selection-buffer handling code
+
+This code is resonsible for turning gluint *
+arrays into structured representations for use
+by Python-level code.
+"""
+from OpenGL._bytes import integer_types
+
+def uintToLong( value ):
+    if value < 0:
+        # array type without a uint, so represented as an int 
+        value = (value & 0x7fffffff) + 0x80000000
+    return value
+
+class GLSelectRecord( object ):
+    """Minimalist object for storing an OpenGL selection-buffer record
+    
+    Provides near and far as *float* values by dividing by 
+    self.DISTANCE_DIVISOR (2**32-1)
+    From the spec:
+        Depth values (which are in the range [0,1]) are multiplied by 
+        2^32 - 1, before being placed in the hit record.
+    
+    Names are unmodified, so normally are slices of the array passed in 
+    to GLSelectRecord.fromArray( array )
+    """
+    DISTANCE_DIVISOR = float((2**32)-1)
+    __slots__ = ('near','far','names')
+    def fromArray( cls, array, total ):
+        """Produce list with all records from the array"""
+        result = []
+        index = 0
+        arrayLength = len(array)
+        for item in range( total ):
+            if index + 2 >= arrayLength:
+                break
+            count = array[index]
+            near = array[index+1]
+            far = array[index+2]
+            names = [ uintToLong(v) for v in array[index+3:index+3+count]]
+            result.append(  cls( near, far, names ) )
+            index += 3+count
+        return result
+    fromArray = classmethod( fromArray )
+    
+    def __init__( self, near, far, names ):
+        """Initialise/store the values"""
+        self.near = self.convertDistance( near )
+        self.far = self.convertDistance( far )
+        self.names = names 
+    def convertDistance( self, value ):
+        """Convert a distance value from array uint to 0.0-1.0 range float"""
+        return uintToLong( value ) / self.DISTANCE_DIVISOR
+    def __getitem__( self, key ):
+        """Allow for treating the record as a three-tuple"""
+        if isinstance( key, integer_types):
+            return (self.near,self.far,self.names)[key]
+        elif key in self.__slots__:
+            try:
+                return getattr( self, key )
+            except AttributeError as err:
+                raise KeyError( """Don't have an index/key %r for %s instant"""%(
+                    key, self.__class__,
+                ))

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

@@ -0,0 +1,228 @@
+"""Convenience module providing common shader entry points
+
+The point of this module is to allow client code to use
+OpenGL Core names to reference shader-related operations
+even if the local hardware only supports ARB extension-based
+shader rendering.
+
+There are also two utility methods compileProgram and compileShader
+which make it easy to create demos which are shader-using.
+"""
+import logging
+log = logging.getLogger( __name__ )
+from OpenGL import GL
+from OpenGL.GL.ARB import (
+    shader_objects, fragment_shader, vertex_shader, vertex_program,
+    geometry_shader4, separate_shader_objects, get_program_binary,
+)
+from OpenGL.extensions import alternate
+from OpenGL._bytes import bytes,unicode,as_8_bit
+
+__all__ = [
+    'glAttachShader',
+    'glDeleteShader',
+    'glGetProgramInfoLog',
+    'glGetShaderInfoLog',
+    'glGetProgramiv',
+    'glGetShaderiv',
+    'compileProgram',
+    'compileShader',
+    'GL_VALIDATE_STATUS',
+    'GL_LINK_STATUS',
+    # automatically added stuff here...
+]
+
+def _alt( base, name ):
+    if hasattr( GL, base ):
+        root = getattr( GL, base )
+        if hasattr(root,'__call__'):
+            globals()[base] = alternate(
+                getattr(GL,base),
+                getattr(module,name)
+            )
+            __all__.append( base )
+        else:
+            globals()[base] = root
+            __all__.append( base )
+        return True
+    return False
+_excludes = ['glGetProgramiv']
+for module in (
+    shader_objects,fragment_shader,vertex_shader,vertex_program,
+   geometry_shader4,
+):
+    for name in dir(module):
+        found = None
+        for suffix in ('ObjectARB','_ARB','ARB'):
+            if name.endswith( suffix ):
+                found = False
+                base = name[:-(len(suffix))]
+                if base not in _excludes:
+                    if _alt( base, name ):
+                        found = True
+                        break
+        if found is False:
+            log.debug( '''Found no alternate for: %s.%s''',
+                module.__name__,name,
+            )
+
+glAttachShader = alternate( GL.glAttachShader,shader_objects.glAttachObjectARB )
+glDetachShader = alternate( GL.glDetachShader,shader_objects.glDetachObjectARB )
+glDeleteShader = alternate( GL.glDeleteShader,shader_objects.glDeleteObjectARB )
+glGetAttachedShaders = alternate( GL.glGetAttachedShaders, shader_objects.glGetAttachedObjectsARB )
+
+glGetProgramInfoLog = alternate( GL.glGetProgramInfoLog, shader_objects.glGetInfoLogARB )
+glGetShaderInfoLog = alternate( GL.glGetShaderInfoLog, shader_objects.glGetInfoLogARB )
+
+glGetShaderiv = alternate( GL.glGetShaderiv, shader_objects.glGetObjectParameterivARB )
+glGetProgramiv = alternate( GL.glGetProgramiv, shader_objects.glGetObjectParameterivARB )
+
+GL_VALIDATE_STATUS = GL.GL_VALIDATE_STATUS
+GL_COMPILE_STATUS = GL.GL_COMPILE_STATUS
+GL_LINK_STATUS = GL.GL_LINK_STATUS
+GL_FALSE = GL.GL_FALSE
+GL_TRUE = GL.GL_TRUE
+
+class ShaderProgram( int ):
+    """Integer sub-class with context-manager operation"""
+    def __enter__( self ):
+        """Start use of the program"""
+        glUseProgram( self )
+    def __exit__( self, typ, val, tb ):
+        """Stop use of the program"""
+        glUseProgram( 0 )
+    
+    def check_validate( self ):
+        """Check that the program validates
+        
+        Validation has to occur *after* linking/loading
+        
+        raises RuntimeError on failures
+        """
+        glValidateProgram( self )
+        validation = glGetProgramiv( self, GL_VALIDATE_STATUS )
+        if validation == GL_FALSE:
+            raise RuntimeError(
+                """Validation failure (%r): %s"""%(
+                validation,
+                glGetProgramInfoLog( self ),
+            ))
+        return self
+
+    def check_linked( self ):
+        """Check link status for this program
+        
+        raises RuntimeError on failures
+        """
+        link_status = glGetProgramiv( self, GL_LINK_STATUS )
+        if link_status == GL_FALSE:
+            raise RuntimeError(
+                """Link failure (%s): %s"""%(
+                link_status,
+                glGetProgramInfoLog( self ),
+            ))
+        return self
+
+    def retrieve( self ):
+        """Attempt to retrieve binary for this compiled shader
+        
+        Note that binaries for a program are *not* generally portable,
+        they should be used solely for caching compiled programs for 
+        local use; i.e. to reduce compilation overhead.
+        
+        returns (format,binaryData) for the shader program
+        """
+        from OpenGL.raw.GL._types import GLint,GLenum 
+        from OpenGL.arrays import GLbyteArray
+        size = GLint()
+        glGetProgramiv( self, get_program_binary.GL_PROGRAM_BINARY_LENGTH, size )
+        result = GLbyteArray.zeros( (size.value,))
+        size2 = GLint()
+        format = GLenum()
+        get_program_binary.glGetProgramBinary( self, size.value, size2, format, result )
+        return format.value, result 
+    def load( self, format, binary ):
+        """Attempt to load binary-format for a pre-compiled shader
+        
+        See notes in retrieve
+        """
+        get_program_binary.glProgramBinary( self, format, binary, len(binary))
+        self.check_validate() # On AMD Linux we see this fail, despite logging "validation successful"
+        self.check_linked()
+        return self
+
+def compileProgram(*shaders, **named):
+    """Create a new program, attach shaders and validate
+
+    shaders -- arbitrary number of shaders to attach to the
+        generated program.
+    separable (keyword only) -- set the separable flag to allow 
+        for partial installation of shader into the pipeline (see 
+        glUseProgramStages)
+    retrievable (keyword only) -- set the retrievable flag to 
+        allow retrieval of the program binary representation, (see 
+        glProgramBinary, glGetProgramBinary)
+
+    This convenience function is *not* standard OpenGL,
+    but it does wind up being fairly useful for demos
+    and the like.  You may wish to copy it to your code
+    base to guard against PyOpenGL changes.
+
+    Usage:
+
+        shader = compileProgram(
+            compileShader( source, GL_VERTEX_SHADER ),
+            compileShader( source2, GL_FRAGMENT_SHADER ),
+        )
+        glUseProgram( shader )
+
+    Note:
+        If (and only if) validation of the linked program
+        *passes* then the passed-in shader objects will be
+        deleted from the GL.
+
+    returns ShaderProgram() (GLuint) program reference
+    raises RuntimeError when a link/validation failure occurs
+    """
+    program = glCreateProgram()
+    if named.get('separable'):
+        glProgramParameteri( program, separate_shader_objects.GL_PROGRAM_SEPARABLE, GL_TRUE )
+    if named.get('retrievable'):
+        glProgramParameteri( program, get_program_binary.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE )
+    for shader in shaders:
+        glAttachShader(program, shader)
+    program = ShaderProgram( program )
+    glLinkProgram(program)
+    program.check_validate()
+    program.check_linked()
+    for shader in shaders:
+        glDeleteShader(shader)
+    return program
+def compileShader( source, shaderType ):
+    """Compile shader source of given type
+
+    source -- GLSL source-code for the shader
+    shaderType -- GLenum GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, etc,
+
+    returns GLuint compiled shader reference
+    raises RuntimeError when a compilation failure occurs
+    """
+    if isinstance( source, (bytes,unicode)):
+        source = [ source ]
+    source = [ as_8_bit(s) for s in source ]
+    shader = glCreateShader(shaderType)
+    glShaderSource( shader, source )
+    glCompileShader( shader )
+    result = glGetShaderiv( shader, GL_COMPILE_STATUS )
+    if not(result):
+        # TODO: this will be wrong if the user has
+        # disabled traditional unpacking array support.
+        raise RuntimeError(
+            """Shader compile failure (%s): %s"""%(
+                result,
+                glGetShaderInfoLog( shader ),
+            ),
+            source,
+            shaderType,
+        )
+    return shader

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

@@ -0,0 +1,21 @@
+from OpenGL.arrays import vbo
+from OpenGL.GL.VERSION import GL_1_5, GL_3_0, GL_3_1
+
+class Implementation( vbo.Implementation ):
+    """OpenGL-based implementation of VBO interfaces"""
+    def __init__( self ):
+        for name in self.EXPORTED_NAMES:
+            found = False
+            for source in (GL_1_5,GL_3_0, GL_3_1):
+                try:
+                    setattr( self, name, getattr( source, name ))
+                except AttributeError as err:
+                    pass 
+                else:
+                    found = True 
+                    break 
+            assert found, name
+        if GL_1_5.glBufferData:
+            self.available = True
+
+Implementation.register()