diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7d1d4d4162da3195cbfcd87c7935a74ad7fc103 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5471b52b6193300c1834935e8ee3a4755b813a7d Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2369b65f54b717cae271eed925f88f03f158df7c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15b024300ab4321d16fb2d818caf5bba2b5662a9 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e0c4e5fb7f498dc0d398e6af8f9a16807ea5a5e Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecf5b807000270dd5336f803a30a77a931695bf4 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0a74541914ef678c5674d49951e880b4ffedc11 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb37fac285e5a8f151b6c1bc221b445c6961a36d Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b00b580f5f58662b0c15eaf05aae6f17971422c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd1c56c08ad5e0e23a32b21caa13025ff5fed5c8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..312510ecbddd644da2b043adf909aa2df85ed37b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82f51e3a2e25da290d530482f8898a6a0408582a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9e87685bdd01cb766a51a1b22e5c958ef74c358 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8f43ff4dfb6e1da2bfe2957d8c1f20588e93a6f Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dab36cebd391f0b6f77c660e39e2b28927c25be4 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..788e92049b8ea0515ee65b9a962fd04084e438dc Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae63eeb15a3332bf284693036670c278384d27d7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fdf96863de0026558bc93039c6dcc1e412a6dc1 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2399a51c5c0858c8f2ac99815101fb1762c72b5c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..096c2c57c2a5befd763412ba93a99206a517c224 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0baa91086b16d519cae932c11f45daa0f070a00 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c21b28a8ff9e2e5d77a2505a04e440454bb03b0 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dabed193c7229ee31faa70776496124172d487d3 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7152a6af04298fff1fab3d26be119c139f4e76c8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..acce1a6d0455235a34e51b56e19d5e936ef31377 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..594e2cc0829635cf295ed1c9668843d4050846ad Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d929cf83f8ac702b4a978085d27963ae56c854d2 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb8f2f641f97863e6467754fedfa29ccb41c3c81 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4db3ad58044e4f6bfdab140b7e60eaee13b1cb5c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03fde460db39b38d250f189872d97bc4f1a21d59 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ece2a999c4c3357d455b99f4a74e86420e05cfba Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba13f6085e06a1dfc2a413d6ea247e0e1a9269b3 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2507e745f74c5cfa0d757e067d8c3a8f37dd784 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..849bdb7f3ac399a67540c8d05e8ab44cffd80dee Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35728cbc4be21dc05f0365c590395d1955aa25d9 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f708be05497cea4d51f70f5db4f5dbbf3f60d75a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3422982ef3ced2f87e8afdb315648e69321c4161 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async.py new file mode 100644 index 0000000000000000000000000000000000000000..eeadbdd520622b1f4245b404bc8bd0f3d3f6f7c9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async.py @@ -0,0 +1,72 @@ +'''OpenGL extension SGIX.async + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a framework for asynchronous OpenGL + commands. It also provides commands allowing a program to wait + for the completion of asynchronous commands. + + Asynchronous commands have two properties: + + 1) Asynchronous commands are non-blocking. For example, an + asynchronous ReadPixels command returns control to the program + immediately rather than blocking until the command completes. + This property allows the program to issue other OpenGL commands in + parallel with the execution of commands that normally block. + + 2) Asynchronous commands may complete out-of-order with respect to + other OpenGL commands. For example, an asynchronous TexImage + command may complete after subsequent OpenGL commands issued by + the program rather than maintaining the normal serial order of the + OpenGL command stream. This property allows the graphics + accelerator to execute asynchronous commands in parallel with the + normal command stream, for instance using a secondary path to + transfer data from or to the host, without doing any dependency + checking. + + Programs that issue asynchronous commands must also be able to + determine when the commands have completed. The completion status + may be needed so that results can be retrieved (e.g. the image + data from a ReadPixels command) or so that dependent commands can + be issued (e.g. drawing commands that use texture data downloaded + by an earlier asynchronous command). This extension provides + fine-grain control over asynchronous commands by introducing a + mechanism for determining the status of individual commands. + + Each invocation of an asynchronous command is associated with an + integer called a "marker." A program specifies a marker before it + issues an asynchronous command. The program may later issue a + command to query if any asynchronous commands have completed. The + query commands return a marker to identify the command that + completed. This extension provides both blocking and non-blocking + query commands. + + This extension does not define any asynchronous commands. + See SGIX_async_pixel for the asynchronous pixel commands. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async import * +from OpenGL.raw.GL.SGIX.async import _EXTENSION_NAME + +def glInitAsyncSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glFinishAsyncSGIX=wrapper.wrapper(glFinishAsyncSGIX).setOutput( + 'markerp',size=(1,),orPassIn=True +) +glPollAsyncSGIX=wrapper.wrapper(glPollAsyncSGIX).setOutput( + 'markerp',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_histogram.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_histogram.py new file mode 100644 index 0000000000000000000000000000000000000000..53063a4e6e0e362464c61030b7041f2dd0942713 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_histogram.py @@ -0,0 +1,30 @@ +'''OpenGL extension SGIX.async_histogram + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async_histogram to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new asynchronous mode for histogram + and minmax readbacks. It allows programs to get the contents of a + histogram or minmax table without blocking and to continue issuing + graphics commands during the readback. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async_histogram.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async_histogram import * +from OpenGL.raw.GL.SGIX.async_histogram import _EXTENSION_NAME + +def glInitAsyncHistogramSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_pixel.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_pixel.py new file mode 100644 index 0000000000000000000000000000000000000000..9517e3944632e2905edf29e0e5f941f74d8f75d1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/async_pixel.py @@ -0,0 +1,35 @@ +'''OpenGL extension SGIX.async_pixel + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async_pixel to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new asynchronous mode for texture + download, pixel download and pixel readback commands. It allows + programs to transfer textures or images between the host and the + graphics accelerator in parallel with the execution of other + graphics commands (possibly taking advantage of a secondary path + to the graphics accelerator). It also allows programs to issue + non-blocking pixel readback commands that return immediately after + they are issued so that the program can issue other commands while + the readback takes place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async_pixel.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async_pixel import * +from OpenGL.raw.GL.SGIX.async_pixel import _EXTENSION_NAME + +def glInitAsyncPixelSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/clipmap.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/clipmap.py new file mode 100644 index 0000000000000000000000000000000000000000..d693a892c858cf7a74e681a9c6b3edfb9114f33a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/clipmap.py @@ -0,0 +1,31 @@ +'''OpenGL extension SGIX.clipmap + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.clipmap to provide a more +Python-friendly API + +Overview (from the spec) + + Mipmaps provide a general but expensive solution when the texture image + is very large. This extension defines clipmaps, which occupy a small + subset of the memory required by equivalent mipmaps, but provide much + of the mipmap rendering capabilities. Clipmaps are especially useful + for rendering terrain. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/clipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.clipmap import * +from OpenGL.raw.GL.SGIX.clipmap import _EXTENSION_NAME + +def glInitClipmapSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py new file mode 100644 index 0000000000000000000000000000000000000000..23d21059e352e3c2c7fb166ed663344b8aa54fe8 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py @@ -0,0 +1,28 @@ +'''OpenGL extension SGIX.convolution_accuracy + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.convolution_accuracy to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds an accuracy hint for convolution. It + allows the program to trade off precision for speed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/convolution_accuracy.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.convolution_accuracy import * +from OpenGL.raw.GL.SGIX.convolution_accuracy import _EXTENSION_NAME + +def glInitConvolutionAccuracySGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/depth_texture.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/depth_texture.py new file mode 100644 index 0000000000000000000000000000000000000000..3406d1430de9f715c644d3ac3f0cd3a7b52eb397 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/depth_texture.py @@ -0,0 +1,34 @@ +'''OpenGL extension SGIX.depth_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.depth_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new depth texture format. An important + application of depth texture images is shadow casting, but separating + this from the shadow extension allows for the potential use of depth + textures in other applications such as image-based rendering or + displacement mapping. This extension does not define new depth-texture + environment functions, such as filtering or applying the depth values + computed from a texture, but leaves this to other extensions, such as + the shadow extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.depth_texture import * +from OpenGL.raw.GL.SGIX.depth_texture import _EXTENSION_NAME + +def glInitDepthTextureSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/flush_raster.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/flush_raster.py new file mode 100644 index 0000000000000000000000000000000000000000..7dd6c3039929569425e09e761811da1970101b0a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/flush_raster.py @@ -0,0 +1,38 @@ +'''OpenGL extension SGIX.flush_raster + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.flush_raster to provide a more +Python-friendly API + +Overview (from the spec) + + This extensions provides a way to ensure that all raster operations + currently in the pipeline will be completed before the next + raster operation begins. We define a raster operation as an operation + that involves the rasterization stage of the OpenGL pipeline. + The implementation is free to decide what consitutes flushing the + raster subsystem. + + The motivation is to allow accurate instrumentation by + including this call before stopping rasterization measurements. + There are cases where Finish() is used, but a FlushRaster() + would suffice, so this extension is deliberately kept independent + of the instruments extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/flush_raster.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.flush_raster import * +from OpenGL.raw.GL.SGIX.flush_raster import _EXTENSION_NAME + +def glInitFlushRasterSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/framezoom.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/framezoom.py new file mode 100644 index 0000000000000000000000000000000000000000..b1dac4e752179255ed7e2e3ace6ee1b569c48759 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/framezoom.py @@ -0,0 +1,47 @@ +'''OpenGL extension SGIX.framezoom + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.framezoom to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a additional way to rasterize geometric + primitives and pixel rectangles. The techique is to reduce the + number of pixels rasterized and (possibly) the number of depth and + stencil operations performed per primitive. Each pixel is zoomed + up and used to render an N x N block of screen pixels. The + implementation is free to choose the number of stencil and z pixels + that will correspond to each N x N block. + + This extension provides an opportunity to the implementation to + perform expensive raster operations at a reduced resolution, + increasing performance. Such operations may include + texture-mapping, depth & stencil tests, etc. The hardware should + be allowed to perform operations that it accelerates at full + hardware speed. + + The visual result will be the same as if a scene were rendered into + a small window, and then that buffer was copied and zoomed up into + a large window. + + All OpenGL parameters that effect rasterization size will implicitly + be multipled by N (this includes point size, line width, etc). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/framezoom.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.framezoom import * +from OpenGL.raw.GL.SGIX.framezoom import _EXTENSION_NAME + +def glInitFramezoomSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/resample.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/resample.py new file mode 100644 index 0000000000000000000000000000000000000000..0ebc2f2211511d9eb2b39c118522ab9d0afa829b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/resample.py @@ -0,0 +1,43 @@ +'''OpenGL extension SGIX.resample + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.resample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enhances the unpacking resampling capabilities + of the SGIX_subsample extension. + + When pixel data is received from the client and an unpacking + upsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX is + specified, the upsampling is performed via one of two methods: + RESAMPLE_REPLICATE_SGIX, RESAMPLE_ZERO_FILL_SGIX. + Replicate and zero fill are provided to + give the application greatest performance and control over the + filtering process. + + However, when pixel data is read back to the client and a + packing downsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX + is specified, downsampling is + performed via simple component decimation (point sampling). That is, + only the RESAMPLE_DECIMATE_SGIX is valid. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/resample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.resample import * +from OpenGL.raw.GL.SGIX.resample import _EXTENSION_NAME + +def glInitResampleSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/shadow_ambient.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/shadow_ambient.py new file mode 100644 index 0000000000000000000000000000000000000000..5afc3d1a4ebb42132f8af2e63eba77d382efc1d6 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/shadow_ambient.py @@ -0,0 +1,33 @@ +'''OpenGL extension SGIX.shadow_ambient + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.shadow_ambient to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a value other than 0.0 to be returned by the + SGIX_shadow operation in the case when the shadow test passes. + With this extension any floating point value in the range [0.0, + 1.0] can be returned as the texture value when an object is in + shadow. This allows the (untextured) ambient lighting and direct + shadowed lighting from a single light source to be computed in a + single pass. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/shadow_ambient.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.shadow_ambient import * +from OpenGL.raw.GL.SGIX.shadow_ambient import _EXTENSION_NAME + +def glInitShadowAmbientSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/sprite.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/sprite.py new file mode 100644 index 0000000000000000000000000000000000000000..dd3cded90cec5a7db2a18c661cbe95324ed97d17 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/sprite.py @@ -0,0 +1,79 @@ +'''OpenGL extension SGIX.sprite + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.sprite to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for viewpoint dependent alignment + of geometry, in particular geometry that rotates about a point or + a specified axis to face the eye point. The primary use is for + quickly rendering roughly cylindrically or spherically symmetric + objects, e.g. trees, smoke, clouds, etc. using geometry textured + with a partially transparent texture map. + + Rendering sprite geometry requires applying a transformation to + primitives before the current model view. This matrix includes a + rotation which is computed based on the current model view matrix + and a translation which is specified explicitly + (SPRITE_TRANSLATION_SGIX). The current model view matrix itself + is not modified. + + Primitives are first transformed by a rotation, depending on the + sprite mode: + + SPRITE_AXIAL_SGIX: The front of the object is rotated about + an axis so that it faces the eye as much as the axis + constraint allows. This is used for roughly rendering cylindrical + objects such as trees in visual simulation. + + SPRITE_OBJECT_ALIGNED_SGIX: The front of the object is + rotated about a point to face the eye with the remaining + rotational degree of freedom specified by aligning the top + of the object with a specified axis in object coordinates. + This is used for spherical objects and special effects such + as smoke which must maintain an alignment in object + coordinates for realism. + + SPRITE_EYE_ALIGNED_SGIX: The front of the object is rotated + about a point to face the eye with the remaining rotational + degree of freedom specified by aligning the top of the object + with a specified axis in eye coordinates. This is used for + rendering sprites which must maintain an alignment on the + screen, such as 3D annotations. + + The axis of rotation or alignment, SPRITE_AXIS_SGIX, can be + an arbitrary direction to support geocentric coordinate frames + in which "up" is not along X, Y or Z. + + Sprite geometry is modeled in a canonical frame: +Z is the up + vector. -Y is the front vector which is rotated to point towards + the eye. In the discussion below, the eye vector is the vector to + the eye from the origin of the model view frame translated by the + sprite position. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/sprite.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.sprite import * +from OpenGL.raw.GL.SGIX.sprite import _EXTENSION_NAME + +def glInitSpriteSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glSpriteParameterfvSGIX.params size not checked against 'pname' +glSpriteParameterfvSGIX=wrapper.wrapper(glSpriteParameterfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glSpriteParameterivSGIX.params size not checked against 'pname' +glSpriteParameterivSGIX=wrapper.wrapper(glSpriteParameterivSGIX).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_add_env.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_add_env.py new file mode 100644 index 0000000000000000000000000000000000000000..6250dfdfdcb0c95a107e9df2fa7c92986efeca0d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_add_env.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.texture_add_env + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_add_env to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_add_env.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_add_env import * +from OpenGL.raw.GL.SGIX.texture_add_env import _EXTENSION_NAME + +def glInitTextureAddEnvSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py new file mode 100644 index 0000000000000000000000000000000000000000..ddb7b74d77786d55a24f36a97406f26f91c740bf --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py @@ -0,0 +1,43 @@ +'''OpenGL extension SGIX.texture_lod_bias + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_lod_bias to provide a more +Python-friendly API + +Overview (from the spec) + + This extension modifies the calculation of texture level of detail + parameter LOD, which is represented by the Greek character lambda + in the GL Specification. The LOD equation assumes that a 2^n x 2^m x 2^l + texture is band limited at 2^(n-1), 2^(m-1), 2^(l-1). Often a texture is + oversampled or filtered such that the texture is band limited at lower + frequencies in one or more dimensions. The result is that texture-mapped + primitives appear excessively blurry. This extension provides biases + for n, m, and l in the LOD calculation to to compensate for under or over + sampled texture images. Mipmapped textures can be made to appear sharper or + blurrier by supplying a negative or positive bias respectively. + + Examples of textures which can benefit from this LOD control include + video-capture images which are filtered differently horizontally and + vertically; a texture which appears blurry because it is mapped with + a nonuniform scale, such as a road texture which is repeated hundreds of + times in one dimension and only once in the other; and textures which + had to be magnified to a power-of-two for mipmapping. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_lod_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_lod_bias import * +from OpenGL.raw.GL.SGIX.texture_lod_bias import _EXTENSION_NAME + +def glInitTextureLodBiasSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py new file mode 100644 index 0000000000000000000000000000000000000000..ce56994d2f180ca1803af9683d6021a78a128bfb --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py @@ -0,0 +1,53 @@ +'''OpenGL extension SGIX.texture_multi_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_multi_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an API for the application to specify that + the OpenGL should handle multiple textures in such a way that, + wherever possible, a texture definition or redefinition can occur + in parallel with rendering that uses a different texture. + + The texture_object extension allows the simultaneous definition + of multiple textures; any texture that is not being used for + rendering can, in principle, have its definition or operations + in its definition (e.g. downloading to hardware) occur in parallel + with the use of another texture. This is true as long as all + redefinitions strictly follow any use of the previous definition. + + Conceptually this is similar to frame buffer double-buffering, + except that the intent here is to simply provide a hint to the + OpenGL to promote such double-buffering if and wherever possible. + The effect of such a hint is to speed up operations without + affecting the result. The user on any particular system must be + knowledgable and prepared to accept any trade-offs which follow + from such a hint. + + GL_FASTEST in this context means that texture multi-buffering + is being used whenever possible to improve performance. + Generally, textures that are adjacent in a sequence of multiple + texture definitions have the greatest chance of being in + different buffers. The number of buffers available at any time + depends on various factors, such as the machine being used and + the textures' internal formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_multi_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.texture_multi_buffer import * +from OpenGL.raw.GL.SGIX.texture_multi_buffer import _EXTENSION_NAME + +def glInitTextureMultiBufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/ycrcba.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/ycrcba.py new file mode 100644 index 0000000000000000000000000000000000000000..acb43b26a23e9fb612d5d714decd28cdc9320775 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/SGIX/ycrcba.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.ycrcba + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.ycrcba to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/ycrcba.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.ycrcba import * +from OpenGL.raw.GL.SGIX.ycrcba import _EXTENSION_NAME + +def glInitYcrcbaSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_0.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_0.py new file mode 100644 index 0000000000000000000000000000000000000000..d622dab113145e33427a0dc0b3387bc9768fd8b7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_0.py @@ -0,0 +1,456 @@ +'''OpenGL extension VERSION.GL_1_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_0.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.VERSION.GL_1_0 import * +from OpenGL.raw.GL.VERSION.GL_1_0 import _EXTENSION_NAME + +def glInitGl10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexParameterfv.params size not checked against 'pname' +glTexParameterfv=wrapper.wrapper(glTexParameterfv).setInputArraySize( + 'params', None +) +# INPUT glTexParameteriv.params size not checked against 'pname' +glTexParameteriv=wrapper.wrapper(glTexParameteriv).setInputArraySize( + 'params', None +) +# INPUT glTexImage1D.pixels size not checked against 'format,type,width' +glTexImage1D=wrapper.wrapper(glTexImage1D).setInputArraySize( + 'pixels', None +) +# INPUT glTexImage2D.pixels size not checked against 'format,type,width,height' +glTexImage2D=wrapper.wrapper(glTexImage2D).setInputArraySize( + 'pixels', None +) +# OUTPUT glReadPixels.pixels COMPSIZE(format,type,width,height) +glGetBooleanv=wrapper.wrapper(glGetBooleanv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetDoublev=wrapper.wrapper(glGetDoublev).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFloatv=wrapper.wrapper(glGetFloatv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetIntegerv=wrapper.wrapper(glGetIntegerv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetTexImage.pixels COMPSIZE(target,level,format,type) +glGetTexParameterfv=wrapper.wrapper(glGetTexParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameteriv=wrapper.wrapper(glGetTexParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameterfv=wrapper.wrapper(glGetTexLevelParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameteriv=wrapper.wrapper(glGetTexLevelParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glCallLists.lists size not checked against 'n,type' +glCallLists=wrapper.wrapper(glCallLists).setInputArraySize( + 'lists', None +) +# INPUT glBitmap.bitmap size not checked against 'width,height' +glBitmap=wrapper.wrapper(glBitmap).setInputArraySize( + 'bitmap', None +) +glColor3bv=wrapper.wrapper(glColor3bv).setInputArraySize( + 'v', 3 +) +glColor3dv=wrapper.wrapper(glColor3dv).setInputArraySize( + 'v', 3 +) +glColor3fv=wrapper.wrapper(glColor3fv).setInputArraySize( + 'v', 3 +) +glColor3iv=wrapper.wrapper(glColor3iv).setInputArraySize( + 'v', 3 +) +glColor3sv=wrapper.wrapper(glColor3sv).setInputArraySize( + 'v', 3 +) +glColor3ubv=wrapper.wrapper(glColor3ubv).setInputArraySize( + 'v', 3 +) +glColor3uiv=wrapper.wrapper(glColor3uiv).setInputArraySize( + 'v', 3 +) +glColor3usv=wrapper.wrapper(glColor3usv).setInputArraySize( + 'v', 3 +) +glColor4bv=wrapper.wrapper(glColor4bv).setInputArraySize( + 'v', 4 +) +glColor4dv=wrapper.wrapper(glColor4dv).setInputArraySize( + 'v', 4 +) +glColor4fv=wrapper.wrapper(glColor4fv).setInputArraySize( + 'v', 4 +) +glColor4iv=wrapper.wrapper(glColor4iv).setInputArraySize( + 'v', 4 +) +glColor4sv=wrapper.wrapper(glColor4sv).setInputArraySize( + 'v', 4 +) +glColor4ubv=wrapper.wrapper(glColor4ubv).setInputArraySize( + 'v', 4 +) +glColor4uiv=wrapper.wrapper(glColor4uiv).setInputArraySize( + 'v', 4 +) +glColor4usv=wrapper.wrapper(glColor4usv).setInputArraySize( + 'v', 4 +) +glEdgeFlagv=wrapper.wrapper(glEdgeFlagv).setInputArraySize( + 'flag', 1 +) +glIndexdv=wrapper.wrapper(glIndexdv).setInputArraySize( + 'c', 1 +) +glIndexfv=wrapper.wrapper(glIndexfv).setInputArraySize( + 'c', 1 +) +glIndexiv=wrapper.wrapper(glIndexiv).setInputArraySize( + 'c', 1 +) +glIndexsv=wrapper.wrapper(glIndexsv).setInputArraySize( + 'c', 1 +) +glNormal3bv=wrapper.wrapper(glNormal3bv).setInputArraySize( + 'v', 3 +) +glNormal3dv=wrapper.wrapper(glNormal3dv).setInputArraySize( + 'v', 3 +) +glNormal3fv=wrapper.wrapper(glNormal3fv).setInputArraySize( + 'v', 3 +) +glNormal3iv=wrapper.wrapper(glNormal3iv).setInputArraySize( + 'v', 3 +) +glNormal3sv=wrapper.wrapper(glNormal3sv).setInputArraySize( + 'v', 3 +) +glRasterPos2dv=wrapper.wrapper(glRasterPos2dv).setInputArraySize( + 'v', 2 +) +glRasterPos2fv=wrapper.wrapper(glRasterPos2fv).setInputArraySize( + 'v', 2 +) +glRasterPos2iv=wrapper.wrapper(glRasterPos2iv).setInputArraySize( + 'v', 2 +) +glRasterPos2sv=wrapper.wrapper(glRasterPos2sv).setInputArraySize( + 'v', 2 +) +glRasterPos3dv=wrapper.wrapper(glRasterPos3dv).setInputArraySize( + 'v', 3 +) +glRasterPos3fv=wrapper.wrapper(glRasterPos3fv).setInputArraySize( + 'v', 3 +) +glRasterPos3iv=wrapper.wrapper(glRasterPos3iv).setInputArraySize( + 'v', 3 +) +glRasterPos3sv=wrapper.wrapper(glRasterPos3sv).setInputArraySize( + 'v', 3 +) +glRasterPos4dv=wrapper.wrapper(glRasterPos4dv).setInputArraySize( + 'v', 4 +) +glRasterPos4fv=wrapper.wrapper(glRasterPos4fv).setInputArraySize( + 'v', 4 +) +glRasterPos4iv=wrapper.wrapper(glRasterPos4iv).setInputArraySize( + 'v', 4 +) +glRasterPos4sv=wrapper.wrapper(glRasterPos4sv).setInputArraySize( + 'v', 4 +) +glRectdv=wrapper.wrapper(glRectdv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectfv=wrapper.wrapper(glRectfv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectiv=wrapper.wrapper(glRectiv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectsv=wrapper.wrapper(glRectsv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glTexCoord1dv=wrapper.wrapper(glTexCoord1dv).setInputArraySize( + 'v', 1 +) +glTexCoord1fv=wrapper.wrapper(glTexCoord1fv).setInputArraySize( + 'v', 1 +) +glTexCoord1iv=wrapper.wrapper(glTexCoord1iv).setInputArraySize( + 'v', 1 +) +glTexCoord1sv=wrapper.wrapper(glTexCoord1sv).setInputArraySize( + 'v', 1 +) +glTexCoord2dv=wrapper.wrapper(glTexCoord2dv).setInputArraySize( + 'v', 2 +) +glTexCoord2fv=wrapper.wrapper(glTexCoord2fv).setInputArraySize( + 'v', 2 +) +glTexCoord2iv=wrapper.wrapper(glTexCoord2iv).setInputArraySize( + 'v', 2 +) +glTexCoord2sv=wrapper.wrapper(glTexCoord2sv).setInputArraySize( + 'v', 2 +) +glTexCoord3dv=wrapper.wrapper(glTexCoord3dv).setInputArraySize( + 'v', 3 +) +glTexCoord3fv=wrapper.wrapper(glTexCoord3fv).setInputArraySize( + 'v', 3 +) +glTexCoord3iv=wrapper.wrapper(glTexCoord3iv).setInputArraySize( + 'v', 3 +) +glTexCoord3sv=wrapper.wrapper(glTexCoord3sv).setInputArraySize( + 'v', 3 +) +glTexCoord4dv=wrapper.wrapper(glTexCoord4dv).setInputArraySize( + 'v', 4 +) +glTexCoord4fv=wrapper.wrapper(glTexCoord4fv).setInputArraySize( + 'v', 4 +) +glTexCoord4iv=wrapper.wrapper(glTexCoord4iv).setInputArraySize( + 'v', 4 +) +glTexCoord4sv=wrapper.wrapper(glTexCoord4sv).setInputArraySize( + 'v', 4 +) +glVertex2dv=wrapper.wrapper(glVertex2dv).setInputArraySize( + 'v', 2 +) +glVertex2fv=wrapper.wrapper(glVertex2fv).setInputArraySize( + 'v', 2 +) +glVertex2iv=wrapper.wrapper(glVertex2iv).setInputArraySize( + 'v', 2 +) +glVertex2sv=wrapper.wrapper(glVertex2sv).setInputArraySize( + 'v', 2 +) +glVertex3dv=wrapper.wrapper(glVertex3dv).setInputArraySize( + 'v', 3 +) +glVertex3fv=wrapper.wrapper(glVertex3fv).setInputArraySize( + 'v', 3 +) +glVertex3iv=wrapper.wrapper(glVertex3iv).setInputArraySize( + 'v', 3 +) +glVertex3sv=wrapper.wrapper(glVertex3sv).setInputArraySize( + 'v', 3 +) +glVertex4dv=wrapper.wrapper(glVertex4dv).setInputArraySize( + 'v', 4 +) +glVertex4fv=wrapper.wrapper(glVertex4fv).setInputArraySize( + 'v', 4 +) +glVertex4iv=wrapper.wrapper(glVertex4iv).setInputArraySize( + 'v', 4 +) +glVertex4sv=wrapper.wrapper(glVertex4sv).setInputArraySize( + 'v', 4 +) +glClipPlane=wrapper.wrapper(glClipPlane).setInputArraySize( + 'equation', 4 +) +# INPUT glFogfv.params size not checked against 'pname' +glFogfv=wrapper.wrapper(glFogfv).setInputArraySize( + 'params', None +) +# INPUT glFogiv.params size not checked against 'pname' +glFogiv=wrapper.wrapper(glFogiv).setInputArraySize( + 'params', None +) +# INPUT glLightfv.params size not checked against 'pname' +glLightfv=wrapper.wrapper(glLightfv).setInputArraySize( + 'params', None +) +# INPUT glLightiv.params size not checked against 'pname' +glLightiv=wrapper.wrapper(glLightiv).setInputArraySize( + 'params', None +) +# INPUT glLightModelfv.params size not checked against 'pname' +glLightModelfv=wrapper.wrapper(glLightModelfv).setInputArraySize( + 'params', None +) +# INPUT glLightModeliv.params size not checked against 'pname' +glLightModeliv=wrapper.wrapper(glLightModeliv).setInputArraySize( + 'params', None +) +# INPUT glMaterialfv.params size not checked against 'pname' +glMaterialfv=wrapper.wrapper(glMaterialfv).setInputArraySize( + 'params', None +) +# INPUT glMaterialiv.params size not checked against 'pname' +glMaterialiv=wrapper.wrapper(glMaterialiv).setInputArraySize( + 'params', None +) +# INPUT glPolygonStipple.mask size not checked against '' +glPolygonStipple=wrapper.wrapper(glPolygonStipple).setInputArraySize( + 'mask', None +) +# INPUT glTexEnvfv.params size not checked against 'pname' +glTexEnvfv=wrapper.wrapper(glTexEnvfv).setInputArraySize( + 'params', None +) +# INPUT glTexEnviv.params size not checked against 'pname' +glTexEnviv=wrapper.wrapper(glTexEnviv).setInputArraySize( + 'params', None +) +# INPUT glTexGendv.params size not checked against 'pname' +glTexGendv=wrapper.wrapper(glTexGendv).setInputArraySize( + 'params', None +) +# INPUT glTexGenfv.params size not checked against 'pname' +glTexGenfv=wrapper.wrapper(glTexGenfv).setInputArraySize( + 'params', None +) +# INPUT glTexGeniv.params size not checked against 'pname' +glTexGeniv=wrapper.wrapper(glTexGeniv).setInputArraySize( + 'params', None +) +glFeedbackBuffer=wrapper.wrapper(glFeedbackBuffer).setOutput( + 'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glSelectBuffer=wrapper.wrapper(glSelectBuffer).setOutput( + 'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +# INPUT glMap1d.points size not checked against 'target,stride,order' +glMap1d=wrapper.wrapper(glMap1d).setInputArraySize( + 'points', None +) +# INPUT glMap1f.points size not checked against 'target,stride,order' +glMap1f=wrapper.wrapper(glMap1f).setInputArraySize( + 'points', None +) +# INPUT glMap2d.points size not checked against 'target,ustride,uorder,vstride,vorder' +glMap2d=wrapper.wrapper(glMap2d).setInputArraySize( + 'points', None +) +# INPUT glMap2f.points size not checked against 'target,ustride,uorder,vstride,vorder' +glMap2f=wrapper.wrapper(glMap2f).setInputArraySize( + 'points', None +) +glEvalCoord1dv=wrapper.wrapper(glEvalCoord1dv).setInputArraySize( + 'u', 1 +) +glEvalCoord1fv=wrapper.wrapper(glEvalCoord1fv).setInputArraySize( + 'u', 1 +) +glEvalCoord2dv=wrapper.wrapper(glEvalCoord2dv).setInputArraySize( + 'u', 2 +) +glEvalCoord2fv=wrapper.wrapper(glEvalCoord2fv).setInputArraySize( + 'u', 2 +) +# INPUT glPixelMapfv.values size not checked against mapsize +glPixelMapfv=wrapper.wrapper(glPixelMapfv).setInputArraySize( + 'values', None +) +# INPUT glPixelMapuiv.values size not checked against mapsize +glPixelMapuiv=wrapper.wrapper(glPixelMapuiv).setInputArraySize( + 'values', None +) +# INPUT glPixelMapusv.values size not checked against mapsize +glPixelMapusv=wrapper.wrapper(glPixelMapusv).setInputArraySize( + 'values', None +) +# INPUT glDrawPixels.pixels size not checked against 'format,type,width,height' +glDrawPixels=wrapper.wrapper(glDrawPixels).setInputArraySize( + 'pixels', None +) +glGetClipPlane=wrapper.wrapper(glGetClipPlane).setOutput( + 'equation',size=(4,),orPassIn=True +) +glGetLightfv=wrapper.wrapper(glGetLightfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetLightiv=wrapper.wrapper(glGetLightiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetMapdv.v COMPSIZE(target,query) +# OUTPUT glGetMapfv.v COMPSIZE(target,query) +# OUTPUT glGetMapiv.v COMPSIZE(target,query) +glGetMaterialfv=wrapper.wrapper(glGetMaterialfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMaterialiv=wrapper.wrapper(glGetMaterialiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPixelMapfv=wrapper.wrapper(glGetPixelMapfv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPixelMapuiv=wrapper.wrapper(glGetPixelMapuiv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPixelMapusv=wrapper.wrapper(glGetPixelMapusv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPolygonStipple=wrapper.wrapper(glGetPolygonStipple).setOutput( + 'mask',size=(128,),orPassIn=True +) +glGetTexEnvfv=wrapper.wrapper(glGetTexEnvfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexEnviv=wrapper.wrapper(glGetTexEnviv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGendv=wrapper.wrapper(glGetTexGendv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGenfv=wrapper.wrapper(glGetTexGenfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGeniv=wrapper.wrapper(glGetTexGeniv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glLoadMatrixf=wrapper.wrapper(glLoadMatrixf).setInputArraySize( + 'm', 16 +) +glLoadMatrixd=wrapper.wrapper(glLoadMatrixd).setInputArraySize( + 'm', 16 +) +glMultMatrixf=wrapper.wrapper(glMultMatrixf).setInputArraySize( + 'm', 16 +) +glMultMatrixd=wrapper.wrapper(glMultMatrixd).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_2.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_2.py new file mode 100644 index 0000000000000000000000000000000000000000..bfe23e18418fbaf380a11b11fe8f2c2927633ebf --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_2.py @@ -0,0 +1,49 @@ +'''OpenGL extension VERSION.GL_1_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_2.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.VERSION.GL_1_2 import * +from OpenGL.raw.GL.VERSION.GL_1_2 import _EXTENSION_NAME + +def glInitGl12VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawRangeElements.indices size not checked against 'count,type' +glDrawRangeElements=wrapper.wrapper(glDrawRangeElements).setInputArraySize( + 'indices', None +) +# INPUT glTexImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexImage3D=wrapper.wrapper(glTexImage3D).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexSubImage3D=wrapper.wrapper(glTexSubImage3D).setInputArraySize( + 'pixels', None +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.imaging import * +from OpenGL.GL.VERSION.GL_1_2_images import * + +GL_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY # alias +GL_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE # alias +GL_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY # alias +GL_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE # alias + +glDrawRangeElements = wrapper.wrapper( glDrawRangeElements ).setPyConverter( + 'indices', arrays.AsArrayOfType( 'indices', 'type' ), +).setReturnValues( + wrapper.returnPyArgument( 'indices' ) +) + + diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_3.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_3.py new file mode 100644 index 0000000000000000000000000000000000000000..6fb726f84da38de126458600578e47ee780a253e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_3.py @@ -0,0 +1,143 @@ +'''OpenGL extension VERSION.GL_1_3 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_3.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.VERSION.GL_1_3 import * +from OpenGL.raw.GL.VERSION.GL_1_3 import _EXTENSION_NAME + +def glInitGl13VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCompressedTexImage3D.data size not checked against imageSize +glCompressedTexImage3D=wrapper.wrapper(glCompressedTexImage3D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage2D.data size not checked against imageSize +glCompressedTexImage2D=wrapper.wrapper(glCompressedTexImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage1D.data size not checked against imageSize +glCompressedTexImage1D=wrapper.wrapper(glCompressedTexImage1D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage3D.data size not checked against imageSize +glCompressedTexSubImage3D=wrapper.wrapper(glCompressedTexSubImage3D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage2D.data size not checked against imageSize +glCompressedTexSubImage2D=wrapper.wrapper(glCompressedTexSubImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage1D.data size not checked against imageSize +glCompressedTexSubImage1D=wrapper.wrapper(glCompressedTexSubImage1D).setInputArraySize( + 'data', None +) +# OUTPUT glGetCompressedTexImage.img COMPSIZE(target,level) +glMultiTexCoord1dv=wrapper.wrapper(glMultiTexCoord1dv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1fv=wrapper.wrapper(glMultiTexCoord1fv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1iv=wrapper.wrapper(glMultiTexCoord1iv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1sv=wrapper.wrapper(glMultiTexCoord1sv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord2dv=wrapper.wrapper(glMultiTexCoord2dv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2fv=wrapper.wrapper(glMultiTexCoord2fv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2iv=wrapper.wrapper(glMultiTexCoord2iv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2sv=wrapper.wrapper(glMultiTexCoord2sv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord3dv=wrapper.wrapper(glMultiTexCoord3dv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3fv=wrapper.wrapper(glMultiTexCoord3fv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3iv=wrapper.wrapper(glMultiTexCoord3iv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3sv=wrapper.wrapper(glMultiTexCoord3sv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord4dv=wrapper.wrapper(glMultiTexCoord4dv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4fv=wrapper.wrapper(glMultiTexCoord4fv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4iv=wrapper.wrapper(glMultiTexCoord4iv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4sv=wrapper.wrapper(glMultiTexCoord4sv).setInputArraySize( + 'v', 4 +) +glLoadTransposeMatrixf=wrapper.wrapper(glLoadTransposeMatrixf).setInputArraySize( + 'm', 16 +) +glLoadTransposeMatrixd=wrapper.wrapper(glLoadTransposeMatrixd).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixf=wrapper.wrapper(glMultTransposeMatrixf).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixd=wrapper.wrapper(glMultTransposeMatrixd).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION +GL_SRC0_ALPHA = GL_SOURCE0_ALPHA # alias +GL_SRC0_RGB = GL_SOURCE0_RGB # alias +GL_SRC1_ALPHA = GL_SOURCE1_ALPHA # alias +GL_SRC1_RGB = GL_SOURCE1_RGB # alias +GL_SRC2_ALPHA = GL_SOURCE2_ALPHA # alias +GL_SRC2_RGB = GL_SOURCE2_RGB # alias + +from OpenGL import wrapper +from OpenGL.raw.GL.VERSION import GL_1_3 as _simple +from OpenGL.GL import images, glget + +for dimensions in (1,2,3): + for function in ('glCompressedTexImage%sD','glCompressedTexSubImage%sD'): + name = function%(dimensions,) + globals()[ name ] = images.compressedImageFunction( + getattr( _simple, name ) + ) + try: + del name, function + except NameError as err: + pass + try: + del dimensions + except NameError as err: + pass + +if _simple.glGetCompressedTexImage: + def glGetCompressedTexImage( target, level, img=None ): + """Retrieve a compressed texture image""" + if img is None: + length = glget.glGetTexLevelParameteriv( + target, 0, + _simple.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, + ) + img = arrays.ArrayDataType.zeros( (length,), constants.GL_UNSIGNED_BYTE ) + return _simple.glGetCompressedTexImage(target, 0, img); diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_4.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_4.py new file mode 100644 index 0000000000000000000000000000000000000000..21c70169a1d906830a071e90a7085c7e06ad271f --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_1_4.py @@ -0,0 +1,113 @@ +'''OpenGL extension VERSION.GL_1_4 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_4.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.VERSION.GL_1_4 import * +from OpenGL.raw.GL.VERSION.GL_1_4 import _EXTENSION_NAME + +def glInitGl14VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArrays.count size not checked against 'drawcount' +# INPUT glMultiDrawArrays.first size not checked against 'count' +glMultiDrawArrays=wrapper.wrapper(glMultiDrawArrays).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawElements.count size not checked against 'drawcount' +# INPUT glMultiDrawElements.indices size not checked against 'drawcount' +glMultiDrawElements=wrapper.wrapper(glMultiDrawElements).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +# INPUT glPointParameterfv.params size not checked against 'pname' +glPointParameterfv=wrapper.wrapper(glPointParameterfv).setInputArraySize( + 'params', None +) +# INPUT glPointParameteriv.params size not checked against 'pname' +glPointParameteriv=wrapper.wrapper(glPointParameteriv).setInputArraySize( + 'params', None +) +glFogCoordfv=wrapper.wrapper(glFogCoordfv).setInputArraySize( + 'coord', 1 +) +glFogCoorddv=wrapper.wrapper(glFogCoorddv).setInputArraySize( + 'coord', 1 +) +# INPUT glFogCoordPointer.pointer size not checked against 'type,stride' +glFogCoordPointer=wrapper.wrapper(glFogCoordPointer).setInputArraySize( + 'pointer', None +) +glSecondaryColor3bv=wrapper.wrapper(glSecondaryColor3bv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3dv=wrapper.wrapper(glSecondaryColor3dv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3fv=wrapper.wrapper(glSecondaryColor3fv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3iv=wrapper.wrapper(glSecondaryColor3iv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3sv=wrapper.wrapper(glSecondaryColor3sv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3ubv=wrapper.wrapper(glSecondaryColor3ubv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3uiv=wrapper.wrapper(glSecondaryColor3uiv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3usv=wrapper.wrapper(glSecondaryColor3usv).setInputArraySize( + 'v', 3 +) +# INPUT glSecondaryColorPointer.pointer size not checked against 'size,type,stride' +glSecondaryColorPointer=wrapper.wrapper(glSecondaryColorPointer).setInputArraySize( + 'pointer', None +) +glWindowPos2dv=wrapper.wrapper(glWindowPos2dv).setInputArraySize( + 'v', 2 +) +glWindowPos2fv=wrapper.wrapper(glWindowPos2fv).setInputArraySize( + 'v', 2 +) +glWindowPos2iv=wrapper.wrapper(glWindowPos2iv).setInputArraySize( + 'v', 2 +) +glWindowPos2sv=wrapper.wrapper(glWindowPos2sv).setInputArraySize( + 'v', 2 +) +glWindowPos3dv=wrapper.wrapper(glWindowPos3dv).setInputArraySize( + 'v', 3 +) +glWindowPos3fv=wrapper.wrapper(glWindowPos3fv).setInputArraySize( + 'v', 3 +) +glWindowPos3iv=wrapper.wrapper(glWindowPos3iv).setInputArraySize( + 'v', 3 +) +glWindowPos3sv=wrapper.wrapper(glWindowPos3sv).setInputArraySize( + 'v', 3 +) +### END AUTOGENERATED SECTION +GL_CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE # alias +GL_FOG_COORD = GL_FOG_COORDINATE # alias +GL_FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY # alias +GL_FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER # alias +GL_FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE # alias +GL_FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE # alias +GL_FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE # alias diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_0.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_0.py new file mode 100644 index 0000000000000000000000000000000000000000..350b504f1b4694571cd8ba165a83bbf22b338761 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_0.py @@ -0,0 +1,446 @@ +'''OpenGL extension VERSION.GL_2_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_2_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_2_0.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.VERSION.GL_2_0 import * +from OpenGL.raw.GL.VERSION.GL_2_0 import _EXTENSION_NAME + +def glInitGl20VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffers.bufs size not checked against n +glDrawBuffers=wrapper.wrapper(glDrawBuffers).setInputArraySize( + 'bufs', None +) +glGetActiveAttrib=wrapper.wrapper(glGetActiveAttrib).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +) +glGetActiveUniform=wrapper.wrapper(glGetActiveUniform).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +) +# glGetAttachedShaders.obj is OUTPUT without known output size +# INPUT glGetAttachedShaders.shaders size not checked against maxCount +glGetAttachedShaders=wrapper.wrapper(glGetAttachedShaders).setOutput( + 'count',size=(1,),orPassIn=True +).setInputArraySize( + 'shaders', None +) +glGetProgramiv=wrapper.wrapper(glGetProgramiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetProgramInfoLog=wrapper.wrapper(glGetProgramInfoLog).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetShaderiv=wrapper.wrapper(glGetShaderiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetShaderInfoLog=wrapper.wrapper(glGetShaderInfoLog).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetShaderSource=wrapper.wrapper(glGetShaderSource).setOutput( + 'source',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# glGetUniformfv.params is OUTPUT without known output size +# glGetUniformiv.params is OUTPUT without known output size +glGetVertexAttribdv=wrapper.wrapper(glGetVertexAttribdv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribfv=wrapper.wrapper(glGetVertexAttribfv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribiv=wrapper.wrapper(glGetVertexAttribiv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribPointerv=wrapper.wrapper(glGetVertexAttribPointerv).setOutput( + 'pointer',size=(1,),orPassIn=True +) +# INPUT glShaderSource.length size not checked against count +# INPUT glShaderSource.string size not checked against count +glShaderSource=wrapper.wrapper(glShaderSource).setInputArraySize( + 'length', None +).setInputArraySize( + 'string', None +) +# INPUT glUniform1fv.value size not checked against count +glUniform1fv=wrapper.wrapper(glUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glUniform2fv.value size not checked against count +glUniform2fv=wrapper.wrapper(glUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glUniform3fv.value size not checked against count +glUniform3fv=wrapper.wrapper(glUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glUniform4fv.value size not checked against count +glUniform4fv=wrapper.wrapper(glUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glUniform1iv.value size not checked against count +glUniform1iv=wrapper.wrapper(glUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glUniform2iv.value size not checked against count +glUniform2iv=wrapper.wrapper(glUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glUniform3iv.value size not checked against count +glUniform3iv=wrapper.wrapper(glUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glUniform4iv.value size not checked against count +glUniform4iv=wrapper.wrapper(glUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2fv.value size not checked against count +glUniformMatrix2fv=wrapper.wrapper(glUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3fv.value size not checked against count +glUniformMatrix3fv=wrapper.wrapper(glUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4fv.value size not checked against count +glUniformMatrix4fv=wrapper.wrapper(glUniformMatrix4fv).setInputArraySize( + 'value', None +) +glVertexAttrib1dv=wrapper.wrapper(glVertexAttrib1dv).setInputArraySize( + 'v', 1 +) +glVertexAttrib1fv=wrapper.wrapper(glVertexAttrib1fv).setInputArraySize( + 'v', 1 +) +glVertexAttrib1sv=wrapper.wrapper(glVertexAttrib1sv).setInputArraySize( + 'v', 1 +) +glVertexAttrib2dv=wrapper.wrapper(glVertexAttrib2dv).setInputArraySize( + 'v', 2 +) +glVertexAttrib2fv=wrapper.wrapper(glVertexAttrib2fv).setInputArraySize( + 'v', 2 +) +glVertexAttrib2sv=wrapper.wrapper(glVertexAttrib2sv).setInputArraySize( + 'v', 2 +) +glVertexAttrib3dv=wrapper.wrapper(glVertexAttrib3dv).setInputArraySize( + 'v', 3 +) +glVertexAttrib3fv=wrapper.wrapper(glVertexAttrib3fv).setInputArraySize( + 'v', 3 +) +glVertexAttrib3sv=wrapper.wrapper(glVertexAttrib3sv).setInputArraySize( + 'v', 3 +) +glVertexAttrib4Nbv=wrapper.wrapper(glVertexAttrib4Nbv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Niv=wrapper.wrapper(glVertexAttrib4Niv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nsv=wrapper.wrapper(glVertexAttrib4Nsv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nubv=wrapper.wrapper(glVertexAttrib4Nubv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nuiv=wrapper.wrapper(glVertexAttrib4Nuiv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nusv=wrapper.wrapper(glVertexAttrib4Nusv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4bv=wrapper.wrapper(glVertexAttrib4bv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4dv=wrapper.wrapper(glVertexAttrib4dv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4fv=wrapper.wrapper(glVertexAttrib4fv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4iv=wrapper.wrapper(glVertexAttrib4iv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4sv=wrapper.wrapper(glVertexAttrib4sv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ubv=wrapper.wrapper(glVertexAttrib4ubv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4uiv=wrapper.wrapper(glVertexAttrib4uiv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4usv=wrapper.wrapper(glVertexAttrib4usv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribPointer.pointer size not checked against 'size,type,stride' +glVertexAttribPointer=wrapper.wrapper(glVertexAttribPointer).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION +import OpenGL +from OpenGL import _configflags +from OpenGL._bytes import bytes, _NULL_8_BYTE, as_8_bit +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_COMPILE_STATUS_ARB as GL_OBJECT_COMPILE_STATUS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_LINK_STATUS_ARB as GL_OBJECT_LINK_STATUS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_ACTIVE_UNIFORMS_ARB as GL_OBJECT_ACTIVE_UNIFORMS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB as GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.raw.GL import _errors + +from OpenGL import converters, error, contextdata +from OpenGL.arrays.arraydatatype import ArrayDatatype, GLenumArray +GL_INFO_LOG_LENGTH = constant.Constant( 'GL_INFO_LOG_LENGTH', 0x8B84 ) + +glShaderSource = platform.createExtensionFunction( + 'glShaderSource', dll=platform.PLATFORM.GL, + resultType=None, + argTypes=(_types.GLhandle, _types.GLsizei, ctypes.POINTER(ctypes.c_char_p), arrays.GLintArray,), + doc = 'glShaderSource( GLhandle(shaderObj),[bytes(string),...]) -> None', + argNames = ('shaderObj', 'count', 'string', 'length',), + extension = _EXTENSION_NAME, +) +conv = converters.StringLengths( name='string' ) +glShaderSource = wrapper.wrapper( + glShaderSource +).setPyConverter( + 'count' # number of strings +).setPyConverter( + 'length' # lengths of strings +).setPyConverter( + 'string', conv.stringArray +).setCResolver( + 'string', conv.stringArrayForC, +).setCConverter( + 'length', conv, +).setCConverter( + 'count', conv.totalCount, +) +try: + del conv +except NameError as err: + pass + +@_lazy( glGetShaderiv ) +def glGetShaderiv( baseOperation, shader, pname, status=None ): + """Retrieve the integer parameter for the given shader + + shader -- shader ID to query + pname -- parameter name + status -- pointer to integer to receive status or None to + return the parameter as an integer value + + returns + integer if status parameter is None + status if status parameter is not None + """ + if status is None: + status = arrays.GLintArray.zeros( (1,)) + status[0] = 1 + baseOperation( + shader, pname, status + ) + return status[0] + else: + baseOperation( + shader, pname, status + ) + return status + +def _afterCheck( key ): + """Generate an error-checking function for compilation operations""" + if key == GL_OBJECT_COMPILE_STATUS: + getter = glGetShaderiv + else: + getter = glGetProgramiv + def GLSLCheckError( + result, + baseOperation=None, + cArguments=None, + *args + ): + result = _errors._error_checker.glCheckError( result, baseOperation, cArguments, *args ) + status = ctypes.c_int() + getter( cArguments[0], key, ctypes.byref(status)) + status = status.value + if not status: + raise error.GLError( + result = result, + baseOperation = baseOperation, + cArguments = cArguments, + description= glGetShaderInfoLog( cArguments[0] ) + ) + return result + return GLSLCheckError + +if _configflags.ERROR_CHECKING: + glCompileShader.errcheck = _afterCheck( GL_OBJECT_COMPILE_STATUS ) +if _configflags.ERROR_CHECKING: + glLinkProgram.errcheck = _afterCheck( GL_OBJECT_LINK_STATUS ) +## Not sure why, but these give invalid operation :( +##if glValidateProgram and OpenGL.ERROR_CHECKING: +## glValidateProgram.errcheck = _afterCheck( GL_OBJECT_VALIDATE_STATUS ) + +@_lazy( glGetShaderInfoLog ) +def glGetShaderInfoLog( baseOperation, obj ): + """Retrieve the shader's error messages as a Python string + + returns string which is '' if no message + """ + length = int(glGetShaderiv(obj, GL_INFO_LOG_LENGTH)) + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' +@_lazy( glGetProgramInfoLog ) +def glGetProgramInfoLog( baseOperation, obj ): + """Retrieve the shader program's error messages as a Python string + + returns string which is '' if no message + """ + length = int(glGetProgramiv(obj, GL_INFO_LOG_LENGTH)) + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetAttachedShaders ) +def glGetAttachedShaders( baseOperation, obj ): + """Retrieve the attached objects as an array of GLhandle instances""" + length= glGetProgramiv( obj, GL_ATTACHED_SHADERS ) + if length > 0: + storage = arrays.GLuintArray.zeros( (length,)) + baseOperation( obj, length, None, storage ) + return storage + return arrays.GLuintArray.zeros( (0,)) + + +@_lazy( glGetShaderSource ) +def glGetShaderSource( baseOperation, obj ): + """Retrieve the program/shader's source code as a Python string + + returns string which is '' if no source code + """ + length = int(glGetShaderiv(obj, GL_OBJECT_SHADER_SOURCE_LENGTH)) + if length > 0: + source = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, source) + return source.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetActiveUniform ) +def glGetActiveUniform(baseOperation,program, index): + """Retrieve the name, size and type of the uniform of the index in the program""" + max_index = int(glGetProgramiv( program, GL_OBJECT_ACTIVE_UNIFORMS )) + length = int(glGetProgramiv( program, GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH)) + if index < max_index and index >= 0: + if length > 0: + name = ctypes.create_string_buffer(length) + size = arrays.GLintArray.zeros( (1,)) + gl_type = arrays.GLenumArray.zeros( (1,)) + namelen = arrays.GLsizeiArray.zeros( (1,)) + baseOperation(program, index, length, namelen, size, gl_type, name) + return name.value[:int(namelen[0])], size[0], gl_type[0] + raise ValueError( """No currently specified uniform names""" ) + raise IndexError( 'Index %s out of range 0 to %i' % (index, max_index - 1, ) ) + +@_lazy( glGetUniformLocation ) +def glGetUniformLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) +@_lazy( glGetAttribLocation ) +def glGetAttribLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) + +@_lazy( glVertexAttribPointer ) +def glVertexAttribPointer( + baseOperation, index, size, type, + normalized, stride, pointer, +): + """Set an attribute pointer for a given shader (index) + + index -- the index of the generic vertex to bind, see + glGetAttribLocation for retrieval of the value, + note that index is a global variable, not per-shader + size -- number of basic elements per record, 1,2,3, or 4 + type -- enum constant for data-type + normalized -- whether to perform int to float + normalization on integer-type values + stride -- stride in machine units (bytes) between + consecutive records, normally used to create + "interleaved" arrays + pointer -- data-pointer which provides the data-values, + normally a vertex-buffer-object or offset into the + same. + + This implementation stores a copy of the data-pointer + in the contextdata structure in order to prevent null- + reference errors in the renderer. + """ + array = ArrayDatatype.asArray( pointer, type ) + key = ('vertex-attrib',index) + contextdata.setValue( key, array ) + return baseOperation( + index, size, type, + normalized, stride, + ArrayDatatype.voidDataPointer( array ) + ) + +@_lazy( glDrawBuffers ) +def glDrawBuffers( baseOperation, n=None, bufs=None ): + """glDrawBuffers( bufs ) -> bufs + + Wrapper will calculate n from dims of bufs if only + one argument is provided... + """ + if bufs is None: + bufs = n + n = None + bufs = arrays.GLenumArray.asArray( bufs ) + if n is None: + n = arrays.GLenumArray.arraySize( bufs ) + return baseOperation( n,bufs ) diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_1.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_1.py new file mode 100644 index 0000000000000000000000000000000000000000..f91fb785a5ef5a4969dd20e21fba8ae9df186d1b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_2_1.py @@ -0,0 +1,40 @@ +'''OpenGL extension VERSION.GL_2_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_2_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_2_1.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.VERSION.GL_2_1 import * +from OpenGL.raw.GL.VERSION.GL_2_1 import _EXTENSION_NAME + +def glInitGl21VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glUniformMatrix2x3fv=wrapper.wrapper(glUniformMatrix2x3fv).setInputArraySize( + 'value', 6 +) +glUniformMatrix3x2fv=wrapper.wrapper(glUniformMatrix3x2fv).setInputArraySize( + 'value', 6 +) +glUniformMatrix2x4fv=wrapper.wrapper(glUniformMatrix2x4fv).setInputArraySize( + 'value', 8 +) +glUniformMatrix4x2fv=wrapper.wrapper(glUniformMatrix4x2fv).setInputArraySize( + 'value', 8 +) +glUniformMatrix3x4fv=wrapper.wrapper(glUniformMatrix3x4fv).setInputArraySize( + 'value', 12 +) +glUniformMatrix4x3fv=wrapper.wrapper(glUniformMatrix4x3fv).setInputArraySize( + 'value', 12 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_1.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_1.py new file mode 100644 index 0000000000000000000000000000000000000000..8d27a6b837ca28a056cd31a8add513fc9e02fb58 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_1.py @@ -0,0 +1,57 @@ +'''OpenGL extension VERSION.GL_3_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_1.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.VERSION.GL_3_1 import * +from OpenGL.raw.GL.VERSION.GL_3_1 import _EXTENSION_NAME + +def glInitGl31VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstanced.indices size not checked against 'count,type' +glDrawElementsInstanced=wrapper.wrapper(glDrawElementsInstanced).setInputArraySize( + 'indices', None +) +# INPUT glGetUniformIndices.uniformNames size not checked against 'uniformCount' +glGetUniformIndices=wrapper.wrapper(glGetUniformIndices).setOutput( + 'uniformIndices',size=_glgets._glget_size_mapping,pnameArg='uniformCount',orPassIn=True +).setInputArraySize( + 'uniformNames', None +) +# INPUT glGetActiveUniformsiv.uniformIndices size not checked against 'uniformCount' +glGetActiveUniformsiv=wrapper.wrapper(glGetActiveUniformsiv).setInputArraySize( + 'uniformIndices', None +).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetActiveUniformName=wrapper.wrapper(glGetActiveUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetUniformBlockIndex.uniformBlockName size not checked against '' +glGetUniformBlockIndex=wrapper.wrapper(glGetUniformBlockIndex).setInputArraySize( + 'uniformBlockName', None +) +glGetActiveUniformBlockiv=wrapper.wrapper(glGetActiveUniformBlockiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetActiveUniformBlockName=wrapper.wrapper(glGetActiveUniformBlockName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformBlockName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.copy_buffer import * +from OpenGL.GL.ARB.uniform_buffer_object import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_2.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_2.py new file mode 100644 index 0000000000000000000000000000000000000000..b2d9cfcc6939f2881a16c6c61c45bbb6b3248478 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_3_2.py @@ -0,0 +1,65 @@ +'''OpenGL extension VERSION.GL_3_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_2.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.VERSION.GL_3_2 import * +from OpenGL.raw.GL.VERSION.GL_3_2 import _EXTENSION_NAME + +def glInitGl32VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsBaseVertex.indices size not checked against 'count,type' +glDrawElementsBaseVertex=wrapper.wrapper(glDrawElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertex.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertex=wrapper.wrapper(glDrawRangeElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertex.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertex=wrapper.wrapper(glDrawElementsInstancedBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glMultiDrawElementsBaseVertex.count size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.indices size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.basevertex size not checked against 'drawcount' +glMultiDrawElementsBaseVertex=wrapper.wrapper(glMultiDrawElementsBaseVertex).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +).setInputArraySize( + 'basevertex', None +) +glGetInteger64v=wrapper.wrapper(glGetInteger64v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSynciv=wrapper.wrapper(glGetSynciv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetInteger64i_v=wrapper.wrapper(glGetInteger64i_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetBufferParameteri64v=wrapper.wrapper(glGetBufferParameteri64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultisamplefv=wrapper.wrapper(glGetMultisamplefv).setOutput( + 'val',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.draw_elements_base_vertex import * +from OpenGL.GL.ARB.provoking_vertex import * +from OpenGL.GL.ARB.sync import * +from OpenGL.GL.ARB.texture_multisample import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_0.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_0.py new file mode 100644 index 0000000000000000000000000000000000000000..baffa290e61e9b5c273b28a6da400cd38394b555 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_0.py @@ -0,0 +1,125 @@ +'''OpenGL extension VERSION.GL_4_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_0.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.VERSION.GL_4_0 import * +from OpenGL.raw.GL.VERSION.GL_4_0 import _EXTENSION_NAME + +def glInitGl40VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1dv.value size not checked against count +glUniform1dv=wrapper.wrapper(glUniform1dv).setInputArraySize( + 'value', None +) +# INPUT glUniform2dv.value size not checked against count +glUniform2dv=wrapper.wrapper(glUniform2dv).setInputArraySize( + 'value', None +) +# INPUT glUniform3dv.value size not checked against count +glUniform3dv=wrapper.wrapper(glUniform3dv).setInputArraySize( + 'value', None +) +# INPUT glUniform4dv.value size not checked against count +glUniform4dv=wrapper.wrapper(glUniform4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2dv.value size not checked against count +glUniformMatrix2dv=wrapper.wrapper(glUniformMatrix2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3dv.value size not checked against count +glUniformMatrix3dv=wrapper.wrapper(glUniformMatrix3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4dv.value size not checked against count +glUniformMatrix4dv=wrapper.wrapper(glUniformMatrix4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x3dv.value size not checked against count +glUniformMatrix2x3dv=wrapper.wrapper(glUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4dv.value size not checked against count +glUniformMatrix2x4dv=wrapper.wrapper(glUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2dv.value size not checked against count +glUniformMatrix3x2dv=wrapper.wrapper(glUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4dv.value size not checked against count +glUniformMatrix3x4dv=wrapper.wrapper(glUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2dv.value size not checked against count +glUniformMatrix4x2dv=wrapper.wrapper(glUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3dv.value size not checked against count +glUniformMatrix4x3dv=wrapper.wrapper(glUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +glGetUniformdv=wrapper.wrapper(glGetUniformdv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='location',orPassIn=True +) +glGetActiveSubroutineUniformiv=wrapper.wrapper(glGetActiveSubroutineUniformiv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetActiveSubroutineUniformName=wrapper.wrapper(glGetActiveSubroutineUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +glGetActiveSubroutineName=wrapper.wrapper(glGetActiveSubroutineName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +# INPUT glUniformSubroutinesuiv.indices size not checked against count +glUniformSubroutinesuiv=wrapper.wrapper(glUniformSubroutinesuiv).setInputArraySize( + 'indices', None +) +glGetUniformSubroutineuiv=wrapper.wrapper(glGetUniformSubroutineuiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetProgramStageiv=wrapper.wrapper(glGetProgramStageiv).setOutput( + 'values',size=(1,),orPassIn=True +) +# INPUT glPatchParameterfv.values size not checked against 'pname' +glPatchParameterfv=wrapper.wrapper(glPatchParameterfv).setInputArraySize( + 'values', None +) +# INPUT glDeleteTransformFeedbacks.ids size not checked against n +glDeleteTransformFeedbacks=wrapper.wrapper(glDeleteTransformFeedbacks).setInputArraySize( + 'ids', None +) +glGenTransformFeedbacks=wrapper.wrapper(glGenTransformFeedbacks).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetQueryIndexediv=wrapper.wrapper(glGetQueryIndexediv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.texture_query_lod import * +from OpenGL.GL.ARB.draw_indirect import * +from OpenGL.GL.ARB.gpu_shader5 import * +from OpenGL.GL.ARB.gpu_shader_fp64 import * +from OpenGL.GL.ARB.shader_subroutine import * +from OpenGL.GL.ARB.tessellation_shader import * +from OpenGL.GL.ARB.texture_buffer_object_rgb32 import * +from OpenGL.GL.ARB.texture_cube_map_array import * +from OpenGL.GL.ARB.texture_gather import * +from OpenGL.GL.ARB.transform_feedback2 import * +from OpenGL.GL.ARB.transform_feedback3 import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_1.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_1.py new file mode 100644 index 0000000000000000000000000000000000000000..6759a17566c5f64dc41a4179bb7cecf85bce5009 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_1.py @@ -0,0 +1,227 @@ +'''OpenGL extension VERSION.GL_4_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_1.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.VERSION.GL_4_1 import * +from OpenGL.raw.GL.VERSION.GL_4_1 import _EXTENSION_NAME + +def glInitGl41VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glShaderBinary.binary size not checked against length +# INPUT glShaderBinary.shaders size not checked against count +glShaderBinary=wrapper.wrapper(glShaderBinary).setInputArraySize( + 'binary', None +).setInputArraySize( + 'shaders', None +) +glGetShaderPrecisionFormat=wrapper.wrapper(glGetShaderPrecisionFormat).setOutput( + 'range',size=(2,),orPassIn=True +).setOutput( + 'precision',size=(2,),orPassIn=True +) +glGetProgramBinary=wrapper.wrapper(glGetProgramBinary).setOutput( + 'binary',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'binaryFormat',size=(1,),orPassIn=True +) +# INPUT glProgramBinary.binary size not checked against length +glProgramBinary=wrapper.wrapper(glProgramBinary).setInputArraySize( + 'binary', None +) +# INPUT glCreateShaderProgramv.strings size not checked against count +glCreateShaderProgramv=wrapper.wrapper(glCreateShaderProgramv).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelines.pipelines size not checked against n +glDeleteProgramPipelines=wrapper.wrapper(glDeleteProgramPipelines).setInputArraySize( + 'pipelines', None +) +glGenProgramPipelines=wrapper.wrapper(glGenProgramPipelines).setOutput( + 'pipelines',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramPipelineiv=wrapper.wrapper(glGetProgramPipelineiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glProgramUniform1iv=wrapper.wrapper(glProgramUniform1iv).setInputArraySize( + 'value', 1 +) +glProgramUniform1fv=wrapper.wrapper(glProgramUniform1fv).setInputArraySize( + 'value', 1 +) +glProgramUniform1dv=wrapper.wrapper(glProgramUniform1dv).setInputArraySize( + 'value', 1 +) +glProgramUniform1uiv=wrapper.wrapper(glProgramUniform1uiv).setInputArraySize( + 'value', 1 +) +glProgramUniform2iv=wrapper.wrapper(glProgramUniform2iv).setInputArraySize( + 'value', 2 +) +glProgramUniform2fv=wrapper.wrapper(glProgramUniform2fv).setInputArraySize( + 'value', 2 +) +glProgramUniform2dv=wrapper.wrapper(glProgramUniform2dv).setInputArraySize( + 'value', 2 +) +glProgramUniform2uiv=wrapper.wrapper(glProgramUniform2uiv).setInputArraySize( + 'value', 2 +) +glProgramUniform3iv=wrapper.wrapper(glProgramUniform3iv).setInputArraySize( + 'value', 3 +) +glProgramUniform3fv=wrapper.wrapper(glProgramUniform3fv).setInputArraySize( + 'value', 3 +) +glProgramUniform3dv=wrapper.wrapper(glProgramUniform3dv).setInputArraySize( + 'value', 3 +) +glProgramUniform3uiv=wrapper.wrapper(glProgramUniform3uiv).setInputArraySize( + 'value', 3 +) +glProgramUniform4iv=wrapper.wrapper(glProgramUniform4iv).setInputArraySize( + 'value', 4 +) +glProgramUniform4fv=wrapper.wrapper(glProgramUniform4fv).setInputArraySize( + 'value', 4 +) +glProgramUniform4dv=wrapper.wrapper(glProgramUniform4dv).setInputArraySize( + 'value', 4 +) +glProgramUniform4uiv=wrapper.wrapper(glProgramUniform4uiv).setInputArraySize( + 'value', 4 +) +glProgramUniformMatrix2fv=wrapper.wrapper(glProgramUniformMatrix2fv).setInputArraySize( + 'value', 2 +) +glProgramUniformMatrix3fv=wrapper.wrapper(glProgramUniformMatrix3fv).setInputArraySize( + 'value', 3 +) +glProgramUniformMatrix4fv=wrapper.wrapper(glProgramUniformMatrix4fv).setInputArraySize( + 'value', 4 +) +glProgramUniformMatrix2dv=wrapper.wrapper(glProgramUniformMatrix2dv).setInputArraySize( + 'value', 2 +) +glProgramUniformMatrix3dv=wrapper.wrapper(glProgramUniformMatrix3dv).setInputArraySize( + 'value', 3 +) +glProgramUniformMatrix4dv=wrapper.wrapper(glProgramUniformMatrix4dv).setInputArraySize( + 'value', 4 +) +# INPUT glProgramUniformMatrix2x3fv.value size not checked against count +glProgramUniformMatrix2x3fv=wrapper.wrapper(glProgramUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fv.value size not checked against count +glProgramUniformMatrix3x2fv=wrapper.wrapper(glProgramUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fv.value size not checked against count +glProgramUniformMatrix2x4fv=wrapper.wrapper(glProgramUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fv.value size not checked against count +glProgramUniformMatrix4x2fv=wrapper.wrapper(glProgramUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fv.value size not checked against count +glProgramUniformMatrix3x4fv=wrapper.wrapper(glProgramUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fv.value size not checked against count +glProgramUniformMatrix4x3fv=wrapper.wrapper(glProgramUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3dv.value size not checked against count +glProgramUniformMatrix2x3dv=wrapper.wrapper(glProgramUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2dv.value size not checked against count +glProgramUniformMatrix3x2dv=wrapper.wrapper(glProgramUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4dv.value size not checked against count +glProgramUniformMatrix2x4dv=wrapper.wrapper(glProgramUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2dv.value size not checked against count +glProgramUniformMatrix4x2dv=wrapper.wrapper(glProgramUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4dv.value size not checked against count +glProgramUniformMatrix3x4dv=wrapper.wrapper(glProgramUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3dv.value size not checked against count +glProgramUniformMatrix4x3dv=wrapper.wrapper(glProgramUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +glGetProgramPipelineInfoLog=wrapper.wrapper(glGetProgramPipelineInfoLog).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glVertexAttribL1dv=wrapper.wrapper(glVertexAttribL1dv).setInputArraySize( + 'v', 1 +) +glVertexAttribL2dv=wrapper.wrapper(glVertexAttribL2dv).setInputArraySize( + 'v', 2 +) +glVertexAttribL3dv=wrapper.wrapper(glVertexAttribL3dv).setInputArraySize( + 'v', 3 +) +glVertexAttribL4dv=wrapper.wrapper(glVertexAttribL4dv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribLPointer.pointer size not checked against size +glVertexAttribLPointer=wrapper.wrapper(glVertexAttribLPointer).setInputArraySize( + 'pointer', None +) +glGetVertexAttribLdv=wrapper.wrapper(glGetVertexAttribLdv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glViewportArrayv.v size not checked against 'count' +glViewportArrayv=wrapper.wrapper(glViewportArrayv).setInputArraySize( + 'v', None +) +glViewportIndexedfv=wrapper.wrapper(glViewportIndexedfv).setInputArraySize( + 'v', 4 +) +# INPUT glScissorArrayv.v size not checked against 'count' +glScissorArrayv=wrapper.wrapper(glScissorArrayv).setInputArraySize( + 'v', None +) +glScissorIndexedv=wrapper.wrapper(glScissorIndexedv).setInputArraySize( + 'v', 4 +) +# INPUT glDepthRangeArrayv.v size not checked against 'count' +glDepthRangeArrayv=wrapper.wrapper(glDepthRangeArrayv).setInputArraySize( + 'v', None +) +glGetFloati_v=wrapper.wrapper(glGetFloati_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetDoublei_v=wrapper.wrapper(glGetDoublei_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.ES2_compatibility import * +from OpenGL.GL.ARB.get_program_binary import * +from OpenGL.GL.ARB.separate_shader_objects import * +from OpenGL.GL.ARB.shader_precision import * +from OpenGL.GL.ARB.vertex_attrib_64bit import * +from OpenGL.GL.ARB.viewport_array import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_2.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_2.py new file mode 100644 index 0000000000000000000000000000000000000000..97224a8e54caadcf714d94ad890176ddd8e464c0 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_2.py @@ -0,0 +1,48 @@ +'''OpenGL extension VERSION.GL_4_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_2.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.VERSION.GL_4_2 import * +from OpenGL.raw.GL.VERSION.GL_4_2 import _EXTENSION_NAME + +def glInitGl42VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseInstance).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseVertexBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseVertexBaseInstance).setInputArraySize( + 'indices', None +) +glGetInternalformativ=wrapper.wrapper(glGetInternalformativ).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetActiveAtomicCounterBufferiv=wrapper.wrapper(glGetActiveAtomicCounterBufferiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION + +from OpenGL.GL.ARB.base_instance import * +from OpenGL.GL.ARB.shading_language_420pack import * +from OpenGL.GL.ARB.transform_feedback_instanced import * +from OpenGL.GL.ARB.compressed_texture_pixel_storage import * +from OpenGL.GL.ARB.conservative_depth import * +from OpenGL.GL.ARB.internalformat_query import * +from OpenGL.GL.ARB.map_buffer_alignment import * +from OpenGL.GL.ARB.shader_atomic_counters import * +from OpenGL.GL.ARB.shader_image_load_store import * +from OpenGL.GL.ARB.shading_language_packing import * +from OpenGL.GL.ARB.texture_storage import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_3.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_3.py new file mode 100644 index 0000000000000000000000000000000000000000..16dff352fc98d698ef02f8311ee325644a682aec --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_3.py @@ -0,0 +1,169 @@ +'''OpenGL extension VERSION.GL_4_3 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_3.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.VERSION.GL_4_3 import * +from OpenGL.raw.GL.VERSION.GL_4_3 import _EXTENSION_NAME + +def glInitGl43VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearBufferData.data size not checked against 'format,type' +glClearBufferData=wrapper.wrapper(glClearBufferData).setInputArraySize( + 'data', None +) +# INPUT glClearBufferSubData.data size not checked against 'format,type' +glClearBufferSubData=wrapper.wrapper(glClearBufferSubData).setInputArraySize( + 'data', None +) +# INPUT glGetFramebufferParameteriv.params size not checked against 'pname' +glGetFramebufferParameteriv=wrapper.wrapper(glGetFramebufferParameteriv).setInputArraySize( + 'params', None +) +# INPUT glGetInternalformati64v.params size not checked against bufSize +glGetInternalformati64v=wrapper.wrapper(glGetInternalformati64v).setInputArraySize( + 'params', None +) +# INPUT glInvalidateFramebuffer.attachments size not checked against numAttachments +glInvalidateFramebuffer=wrapper.wrapper(glInvalidateFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glInvalidateSubFramebuffer.attachments size not checked against numAttachments +glInvalidateSubFramebuffer=wrapper.wrapper(glInvalidateSubFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glMultiDrawArraysIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawArraysIndirect=wrapper.wrapper(glMultiDrawArraysIndirect).setInputArraySize( + 'indirect', None +) +# INPUT glMultiDrawElementsIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawElementsIndirect=wrapper.wrapper(glMultiDrawElementsIndirect).setInputArraySize( + 'indirect', None +) +# INPUT glGetProgramInterfaceiv.params size not checked against 'pname' +glGetProgramInterfaceiv=wrapper.wrapper(glGetProgramInterfaceiv).setInputArraySize( + 'params', None +) +# INPUT glGetProgramResourceIndex.name size not checked against 'name' +glGetProgramResourceIndex=wrapper.wrapper(glGetProgramResourceIndex).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceName.name size not checked against bufSize +glGetProgramResourceName=wrapper.wrapper(glGetProgramResourceName).setInputArraySize( + 'length', 1 +).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceiv.params size not checked against bufSize +# INPUT glGetProgramResourceiv.props size not checked against propCount +glGetProgramResourceiv=wrapper.wrapper(glGetProgramResourceiv).setInputArraySize( + 'length', 1 +).setInputArraySize( + 'params', None +).setInputArraySize( + 'props', None +) +# INPUT glGetProgramResourceLocation.name size not checked against 'name' +glGetProgramResourceLocation=wrapper.wrapper(glGetProgramResourceLocation).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceLocationIndex.name size not checked against 'name' +glGetProgramResourceLocationIndex=wrapper.wrapper(glGetProgramResourceLocationIndex).setInputArraySize( + 'name', None +) +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +# INPUT glGetDebugMessageLog.lengths size not checked against count +# INPUT glGetDebugMessageLog.ids size not checked against count +# INPUT glGetDebugMessageLog.severities size not checked against count +# INPUT glGetDebugMessageLog.sources size not checked against count +# INPUT glGetDebugMessageLog.messageLog size not checked against bufSize +# INPUT glGetDebugMessageLog.types size not checked against count +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setInputArraySize( + 'lengths', None +).setInputArraySize( + 'ids', None +).setInputArraySize( + 'severities', None +).setInputArraySize( + 'sources', None +).setInputArraySize( + 'messageLog', None +).setInputArraySize( + 'types', None +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +# INPUT glGetObjectLabel.label size not checked against bufSize +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setInputArraySize( + 'length', 1 +).setInputArraySize( + 'label', None +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +# INPUT glGetObjectPtrLabel.label size not checked against bufSize +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setInputArraySize( + 'length', 1 +).setInputArraySize( + 'label', None +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION + +from OpenGL.GL.ARB.arrays_of_arrays import * +from OpenGL.GL.ARB.fragment_layer_viewport import * +from OpenGL.GL.ARB.shader_image_size import * +from OpenGL.GL.ARB.ES3_compatibility import * +from OpenGL.GL.ARB.clear_buffer_object import * +from OpenGL.GL.ARB.compute_shader import * +from OpenGL.GL.ARB.copy_image import * +# Extension registry no longer defines these extensions? +#from OpenGL.GL.ARB.debug_group import * +#from OpenGL.GL.ARB.debug_label import * +#from OpenGL.GL.ARB.debug_output2 import * +from OpenGL.GL.KHR.debug import * +from OpenGL.GL.ARB.explicit_uniform_location import * +from OpenGL.GL.ARB.framebuffer_no_attachments import * +from OpenGL.GL.ARB.internalformat_query2 import * +from OpenGL.GL.ARB.invalidate_subdata import * +from OpenGL.GL.ARB.multi_draw_indirect import * +from OpenGL.GL.ARB.program_interface_query import * +from OpenGL.GL.ARB.robust_buffer_access_behavior import * +from OpenGL.GL.ARB.shader_storage_buffer_object import * +from OpenGL.GL.ARB.stencil_texturing import * +from OpenGL.GL.ARB.texture_buffer_range import * +from OpenGL.GL.ARB.texture_query_levels import * +from OpenGL.GL.ARB.texture_storage_multisample import * +from OpenGL.GL.ARB.texture_view import * +from OpenGL.GL.ARB.vertex_attrib_binding import * diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_4.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_4.py new file mode 100644 index 0000000000000000000000000000000000000000..1987ddbfa5c1f87d806289cbf6a324856540ce4e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/GL_4_4.py @@ -0,0 +1,70 @@ +'''OpenGL extension VERSION.GL_4_4 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_4.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.VERSION.GL_4_4 import * +from OpenGL.raw.GL.VERSION.GL_4_4 import _EXTENSION_NAME + +def glInitGl44VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBufferStorage.data size not checked against size +glBufferStorage=wrapper.wrapper(glBufferStorage).setInputArraySize( + 'data', None +) +# INPUT glClearTexImage.data size not checked against 'format,type' +glClearTexImage=wrapper.wrapper(glClearTexImage).setInputArraySize( + 'data', None +) +# INPUT glClearTexSubImage.data size not checked against 'format,type' +glClearTexSubImage=wrapper.wrapper(glClearTexSubImage).setInputArraySize( + 'data', None +) +# INPUT glBindBuffersBase.buffers size not checked against count +glBindBuffersBase=wrapper.wrapper(glBindBuffersBase).setInputArraySize( + 'buffers', None +) +# INPUT glBindBuffersRange.sizes size not checked against count +# INPUT glBindBuffersRange.buffers size not checked against count +# INPUT glBindBuffersRange.offsets size not checked against count +glBindBuffersRange=wrapper.wrapper(glBindBuffersRange).setInputArraySize( + 'sizes', None +).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +) +# INPUT glBindTextures.textures size not checked against count +glBindTextures=wrapper.wrapper(glBindTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindSamplers.samplers size not checked against count +glBindSamplers=wrapper.wrapper(glBindSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glBindImageTextures.textures size not checked against count +glBindImageTextures=wrapper.wrapper(glBindImageTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindVertexBuffers.strides size not checked against count +# INPUT glBindVertexBuffers.buffers size not checked against count +# INPUT glBindVertexBuffers.offsets size not checked against count +glBindVertexBuffers=wrapper.wrapper(glBindVertexBuffers).setInputArraySize( + 'strides', None +).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d09581f7a89411286cedd22b919f9889ad532ae Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1e454eb6484b6082e8f746161e4f78cf9e16166 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f78995eab1385803058b392e97065a2fcb620bb8 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77d888dfaa35c1732de9f3e221e88e3719b8a66c Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc0fe7c758d52b5842fe2b0fcfde8f377ea0c475 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e24b27b74ec1b4a162dba2661c863a7b9e64c743 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5791d3c242de42d55665bff3660e739a48fb7504 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__init__.py b/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b912d19ef8f0e54409434cb78557ba570cae4c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6a7aa50e85508c698b1f89e0bd5fd8d660b4774 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-310.pyc differ