pyglet 2.1.12__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/libs/linux/wayland/lib_wayland.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from ctypes import POINTER, Structure, _Pointer, addressof, c_char_p, c_int, c_size_t, c_uint32, c_void_p, cast, sizeof
+
+import pyglet.lib
+
+_lib_wl = pyglet.lib.load_library("libwayland-client.so")
+
+
+class wl_proxy(Structure):
+    pass
+
+
+class wl_interface(Structure):
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name.decode()}, version={self.version}, methods={self.method_count}, events={self.event_count})"
+
+
+class wl_message(Structure):
+    _fields_ = [
+        ("name", c_char_p),
+        ("signature", c_char_p),
+        ("types", c_void_p),  # POINTER(POINTER(wl_interface))),
+    ]
+
+
+wl_interface._fields_ = [
+    ("name", c_char_p),
+    ("version", c_int),
+    ("method_count", c_int),
+    ("methods", POINTER(wl_message)),  # not POINTER(c_void_p)!
+    ("event_count", c_int),
+    ("events", POINTER(wl_message)),
+]
+
+
+class wl_display(Structure): pass
+
+
+class wl_registry(Structure): pass
+
+
+class wl_compositor(Structure): pass
+
+
+class wl_surface(Structure): pass
+
+
+class wl_event_queue(Structure): pass
+
+
+class wl_array(Structure):
+    _fields_ = [
+        ("size", c_size_t),
+        ("alloc", c_size_t),
+        ("data", c_void_p),
+    ]
+
+
+def as_proxy(ptr: c_void_p) -> _Pointer[wl_proxy]:
+    return cast(ptr, POINTER(wl_proxy))
+
+
+WL_DISPLAY_SYNC = 0
+WL_DISPLAY_GET_REGISTRY = 1
+WL_REGISTRY_BIND = 0
+
+wl_proxy_get_id = _lib_wl.wl_proxy_get_id
+wl_proxy_get_id.restype = c_uint32
+wl_proxy_get_id.argtypes = [POINTER(wl_proxy)]
+
+wl_proxy_destroy = _lib_wl.wl_proxy_destroy
+wl_proxy_destroy.restype = None
+wl_proxy_destroy.argtypes = [POINTER(wl_proxy)]
+
+wl_proxy_add_listener = _lib_wl.wl_proxy_add_listener
+wl_proxy_add_listener.restype = c_int
+wl_proxy_add_listener.argtypes = [c_void_p, POINTER(c_void_p), c_void_p]
+
+wl_display_get_fd = _lib_wl.wl_display_get_fd
+wl_display_get_fd.restype = c_int
+wl_display_get_fd.argtypes = [POINTER(wl_display)]
+
+wl_display_flush = _lib_wl.wl_display_flush
+wl_display_flush.restype = c_int
+wl_display_flush.argtypes = [POINTER(wl_display)]
+
+wl_display_dispatch = _lib_wl.wl_display_dispatch
+wl_display_dispatch.restype = c_int
+wl_display_dispatch.argtypes = [POINTER(wl_display)]
+
+wl_display_dispatch_pending = _lib_wl.wl_display_dispatch_pending
+wl_display_dispatch_pending.restype = c_int
+wl_display_dispatch_pending.argtypes = [POINTER(wl_display)]
+
+wl_display_prepare_read = _lib_wl.wl_display_prepare_read
+wl_display_prepare_read.restype = c_int
+wl_display_prepare_read.argtypes = [POINTER(wl_display)]
+
+wl_display_cancel_read = _lib_wl.wl_display_cancel_read
+wl_display_cancel_read.restype = None
+wl_display_cancel_read.argtypes = [POINTER(wl_display)]
+
+wl_display_read_events = _lib_wl.wl_display_read_events
+wl_display_read_events.restype = c_int
+wl_display_read_events.argtypes = [POINTER(wl_display)]
+
+wl_display_roundtrip = _lib_wl.wl_display_roundtrip
+wl_display_roundtrip.restype = c_int
+wl_display_roundtrip.argtypes = [POINTER(wl_display)]
+
+wl_display_disconnect = _lib_wl.wl_display_disconnect
+wl_display_disconnect.restype = None
+wl_display_disconnect.argtypes = [POINTER(wl_display)]
+
+wl_display_connect = _lib_wl.wl_display_connect
+wl_display_connect.restype = POINTER(wl_display)
+wl_display_connect.argtypes = [c_char_p]
+
+wl_display_connect_to_fd = _lib_wl.wl_display_connect_to_fd
+wl_display_connect_to_fd.restype = POINTER(wl_display)
+wl_display_connect_to_fd.argtypes = [c_int]
+
+wl_display_create_queue = _lib_wl.wl_display_create_queue
+wl_display_create_queue.restype = POINTER(wl_event_queue)
+wl_display_create_queue.argtypes = [POINTER(wl_display)]
+
+wl_display_get_error = _lib_wl.wl_display_get_error
+wl_display_get_error.restype = c_int
+wl_display_get_error.argtypes = [POINTER(wl_display)]
+
+wl_display_get_protocol_error = _lib_wl.wl_display_get_protocol_error
+wl_display_get_protocol_error.restype = c_uint32
+wl_display_get_protocol_error.argtypes = [POINTER(wl_display), POINTER(POINTER(wl_interface)), POINTER(c_int)]
+
+wl_display_dispatch_queue = _lib_wl.wl_display_dispatch_queue
+wl_display_dispatch_queue.restype = c_int
+wl_display_dispatch_queue.argtypes = [POINTER(wl_display),
+                                      POINTER(wl_event_queue)]
+
+wl_display_dispatch_queue_pending = _lib_wl.wl_display_dispatch_queue_pending
+wl_display_dispatch_queue_pending.restype = c_int
+wl_display_dispatch_queue_pending.argtypes = [POINTER(wl_display),
+                                              POINTER(wl_event_queue)]
+
+wl_display_prepare_read_queue = _lib_wl.wl_display_prepare_read_queue
+wl_display_prepare_read_queue.restype = c_int
+wl_display_prepare_read_queue.argtypes = [POINTER(wl_display),
+                                          POINTER(wl_event_queue)]
+
+wl_proxy_marshal_constructor = _lib_wl.wl_proxy_marshal_constructor
+# Args are variadic, setting types may cause issues...
+# wl_proxy_marshal_constructor.argtypes = [POINTER(wl_proxy), c_uint32, POINTER(wl_interface)]
+wl_proxy_marshal_constructor.restype = POINTER(wl_proxy)
+
+wl_proxy_marshal = _lib_wl.wl_proxy_marshal
+wl_proxy_marshal.restype = None
+# Args are variadic, setting types may cause issues...
+
+wl_proxy_marshal_constructor_versioned = _lib_wl.wl_proxy_marshal_constructor_versioned
+wl_proxy_marshal_constructor_versioned.restype = POINTER(wl_proxy)
+# Args are variadic, setting types may cause issues...
+# wl_proxy_marshal_constructor_versioned.argtypes = [POINTER(wl_proxy), c_uint32, POINTER(wl_interface), c_uint32]
+
+wl_display_roundtrip = _lib_wl.wl_display_roundtrip
+wl_display_roundtrip.argtypes = [c_void_p]
+wl_display_roundtrip.restype = c_int
+
+
+def wl_interface_object(name: str) -> wl_interface:
+    return wl_interface.in_dll(_lib_wl, f"{name}_interface")
+
+
+def wl_registry_bind(wl_registry_ptr, name, interface, interface_name, version):
+    wl_registry_proxy = wl_registry_ptr
+    return wl_proxy_marshal_constructor_versioned(
+        wl_registry_proxy,
+        c_uint32(WL_REGISTRY_BIND),
+        interface,
+        c_uint32(version),
+        c_uint32(name),
+        c_char_p(interface_name),
+        c_uint32(version),
+    )
+
+
+def dump_iface(iface: wl_interface):
+    """Debugging..."""
+    print(f"--- {iface.name} ---")
+    print("addr:", hex(addressof(iface)))
+    print("sizeof:", sizeof(iface))
+    print("name:", iface.name)
+    print("version:", int(iface.version))
+    print("method_count:", int(iface.method_count))
+    print("methods ptr:", bool(iface.methods))
+    print("event_count:", int(iface.event_count))
+    print("events ptr:", bool(iface.events))
+    if bool(iface.events):
+        for i in range(iface.event_count):
+            msg = iface.events[i]
+            print(f"  event[{i}] name={msg.name} sig={msg.signature} types={msg.types}")
+    if bool(iface.methods):
+        for i in range(iface.method_count):
+            msg = iface.methods[i]
+            print(f"  method[{i}] name={msg.name} sig={msg.signature} types={msg.types}")
+    print("----------------")

pyglet/libs/linux/wayland/wayland_egl.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from ctypes import POINTER, c_int, c_void_p
+
+import pyglet
+
+_lib = pyglet.lib.load_library('wayland-egl')
+
+wl_egl_window_ptr = c_void_p
+wl_surface_ptr = c_void_p
+
+
+wl_egl_window_create = _lib.wl_egl_window_create
+wl_egl_window_create.restype = wl_egl_window_ptr
+wl_egl_window_create.argtypes = [wl_surface_ptr, c_int, c_int]
+
+
+wl_egl_window_destroy = _lib.wl_egl_window_destroy
+wl_egl_window_destroy.restype = None
+wl_egl_window_destroy.argtypes = [wl_egl_window_ptr]
+
+
+wl_egl_window_resize = _lib.wl_egl_window_resize
+wl_egl_window_resize.restype = None
+wl_egl_window_resize.argtypes = [wl_egl_window_ptr, c_int, c_int, c_int, c_int]
+
+
+wl_egl_window_get_attached_size = _lib.wl_egl_window_get_attached_size
+wl_egl_window_get_attached_size.restype = None
+wl_egl_window_get_attached_size.argtypes = [wl_egl_window_ptr, POINTER(c_int), POINTER(c_int)]
+
+
+__all__ = [
+    'wl_egl_window_create',
+    'wl_egl_window_destroy',
+    'wl_egl_window_get_attached_size',
+    'wl_egl_window_resize',
+]

pyglet/libs/{wayland → linux/wayland}/xkbcommon.py

@@ -69,6 +69,32 @@ XKB_CONTEXT_NO_ENVIRONMENT_NAMES = (1 << 1)
 XKB_KEYMAP_COMPILE_NO_FLAGS = 0
 XKB_KEYMAP_FORMAT_TEXT_V1 = 1
 
+XKB_MOD_NAME_SHIFT = c_char_p(b'Shift')
+XKB_MOD_NAME_CAPS = c_char_p(b'Lock')
+XKB_MOD_NAME_CTRL = c_char_p(b'Control')
+XKB_MOD_NAME_MOD1 = c_char_p(b'Mod1')
+XKB_MOD_NAME_MOD2 = c_char_p(b'Mod2')
+XKB_MOD_NAME_MOD3 = c_char_p(b'Mod3')
+XKB_MOD_NAME_MOD4 = c_char_p(b'Mod4')
+XKB_MOD_NAME_MOD5 = c_char_p(b'Mod5')
+XKB_MOD_NAME_ALT = c_char_p(b'Mod1')
+XKB_MOD_NAME_LOGO = c_char_p(b'Mod4')
+XKB_MOD_NAME_NUM = c_char_p(b'Mod2')
+XKB_VMOD_NAME_ALT = c_char_p(b'Alt')
+XKB_VMOD_NAME_HYPER = c_char_p(b'Hyper')
+XKB_VMOD_NAME_LEVEL3 = c_char_p(b'LevelThree')
+XKB_VMOD_NAME_LEVEL5 = c_char_p(b'LevelFive')
+XKB_VMOD_NAME_META = c_char_p(b'Meta')
+XKB_VMOD_NAME_NUM = c_char_p(b'NumLock')
+XKB_VMOD_NAME_SCROLL = c_char_p(b'ScrollLock')
+XKB_VMOD_NAME_SUPER = c_char_p(b'Super')
+XKB_LED_NAME_NUM = c_char_p(b'Num')
+XKB_LED_NAME_CAPS = c_char_p(b'Caps')
+XKB_LED_NAME_SCROLL = c_char_p(b'Scroll')
+XKB_LED_NAME_COMPOSE = c_char_p(b'Compose')
+XKB_LED_NAME_KANA = c_char_p(b'Kana')
+
+
 xkb_keycode_t = c_uint32  # /usr/include/xkbcommon/xkbcommon.h:165
 xkb_keysym_t = c_uint32  # /usr/include/xkbcommon/xkbcommon.h:195
 xkb_layout_index_t = c_uint32  # /usr/include/xkbcommon/xkbcommon.h:224

pyglet/libs/{x11 → linux/x11}/xf86vmode.py

@@ -31,7 +31,7 @@ class c_void(Structure):
     _fields_ = [('dummy', c_int)]
 
 
-import pyglet.libs.x11.xlib
+import pyglet.libs.linux.x11.xlib
 
 X_XF86VidModeQueryVersion = 0 	# /usr/include/X11/extensions/xf86vmode.h:4885
 X_XF86VidModeGetModeLine = 1 	# /usr/include/X11/extensions/xf86vmode.h:4886
@@ -175,9 +175,9 @@ class struct_anon_97(Structure):
         'forced',
         'time',
     ]
-Display = pyglet.libs.x11.xlib.Display
-Window = pyglet.libs.x11.xlib.Window
-Time = pyglet.libs.x11.xlib.Time
+Display = pyglet.libs.linux.x11.xlib.Display
+Window = pyglet.libs.linux.x11.xlib.Window
+Time = pyglet.libs.linux.x11.xlib.Time
 struct_anon_97._fields_ = [
     ('type', c_int),
     ('serial', c_ulong),

pyglet/libs/{x11 → linux/x11}/xinerama.py

@@ -30,7 +30,7 @@ class c_void(Structure):
     _fields_ = [('dummy', c_int)]
 
 
-import pyglet.libs.x11.xlib
+import pyglet.libs.linux.x11.xlib
 
 class struct_anon_93(Structure):
     __slots__ = [
@@ -49,7 +49,7 @@ struct_anon_93._fields_ = [
 ]
 
 XineramaScreenInfo = struct_anon_93 	# /usr/include/X11/extensions/Xinerama.h:40
-Display = pyglet.libs.x11.xlib.Display
+Display = pyglet.libs.linux.x11.xlib.Display
 # /usr/include/X11/extensions/Xinerama.h:44
 XineramaQueryExtension = _lib.XineramaQueryExtension
 XineramaQueryExtension.restype = c_int

pyglet/libs/{x11 → linux/x11}/xinput.py

@@ -30,7 +30,7 @@ class c_void(Structure):
     _fields_ = [('dummy', c_int)]
 
 
-import pyglet.libs.x11.xlib
+import pyglet.libs.linux.x11.xlib
 
 sz_xGetExtensionVersionReq = 8 	# /usr/include/X11/extensions/XI.h:56
 sz_xGetExtensionVersionReply = 32 	# /usr/include/X11/extensions/XI.h:57
@@ -241,10 +241,10 @@ class struct_anon_94(Structure):
         'first_axis',
         'axis_data',
     ]
-Display = pyglet.libs.x11.xlib.Display
-Window = pyglet.libs.x11.xlib.Window
-XID = pyglet.libs.x11.xlib.XID
-Time = pyglet.libs.x11.xlib.Time
+Display = pyglet.libs.linux.x11.xlib.Display
+Window = pyglet.libs.linux.x11.xlib.Window
+XID = pyglet.libs.linux.x11.xlib.XID
+Time = pyglet.libs.linux.x11.xlib.Time
 struct_anon_94._fields_ = [
     ('type', c_int),
     ('serial', c_ulong),
@@ -686,7 +686,7 @@ class struct_anon_111(Structure):
         'num_syms_supported',
         'syms_supported',
     ]
-KeySym = pyglet.libs.x11.xlib.KeySym
+KeySym = pyglet.libs.linux.x11.xlib.KeySym
 struct_anon_111._fields_ = [
     ('class', XID),
     ('length', c_int),
@@ -1113,7 +1113,7 @@ class struct__XDeviceInfo(Structure):
         'use',
         'inputclassinfo',
     ]
-Atom = pyglet.libs.x11.xlib.Atom
+Atom = pyglet.libs.linux.x11.xlib.Atom
 struct__XDeviceInfo._fields_ = [
     ('id', XID),
     ('type', Atom),
@@ -1427,7 +1427,7 @@ XDeviceBell = _lib.XDeviceBell
 XDeviceBell.restype = c_int
 XDeviceBell.argtypes = [POINTER(Display), POINTER(XDevice), XID, XID, c_int]
 
-KeyCode = pyglet.libs.x11.xlib.KeyCode
+KeyCode = pyglet.libs.linux.x11.xlib.KeyCode
 # /usr/include/X11/extensions/XInput.h:5878
 XGetDeviceKeyMapping = _lib.XGetDeviceKeyMapping
 XGetDeviceKeyMapping.restype = POINTER(KeySym)
@@ -1438,7 +1438,7 @@ XChangeDeviceKeyMapping = _lib.XChangeDeviceKeyMapping
 XChangeDeviceKeyMapping.restype = c_int
 XChangeDeviceKeyMapping.argtypes = [POINTER(Display), POINTER(XDevice), c_int, c_int, POINTER(KeySym), c_int]
 
-XModifierKeymap = pyglet.libs.x11.xlib.XModifierKeymap
+XModifierKeymap = pyglet.libs.linux.x11.xlib.XModifierKeymap
 # /usr/include/X11/extensions/XInput.h:5899
 XGetDeviceModifierMapping = _lib.XGetDeviceModifierMapping
 XGetDeviceModifierMapping.restype = POINTER(XModifierKeymap)
@@ -1544,7 +1544,7 @@ XGetDeviceDontPropagateList = _lib.XGetDeviceDontPropagateList
 XGetDeviceDontPropagateList.restype = POINTER(XEventClass)
 XGetDeviceDontPropagateList.argtypes = [POINTER(Display), Window, POINTER(c_int)]
 
-XEvent = pyglet.libs.x11.xlib.XEvent
+XEvent = pyglet.libs.linux.x11.xlib.XEvent
 # /usr/include/X11/extensions/XInput.h:6014
 XSendExtensionEvent = _lib.XSendExtensionEvent
 XSendExtensionEvent.restype = c_int

pyglet/libs/{x11 → linux/x11}/xrender.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import warnings
 from ctypes import Structure, c_ushort, c_ulong, c_int, c_void_p, POINTER
 import pyglet.lib
-from pyglet.libs.x11.xlib import Visual
+from pyglet.libs.linux.x11.xlib import Visual
 
 lib = None
 try:

pyglet/libs/shared/spirv/lib_shaderc.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import ctypes
+from ctypes import c_char_p, c_size_t, c_void_p, POINTER
+
+import pyglet
+
+# Load the shaderc_shared.dll
+lib_shaderc = pyglet.lib.load_library("shaderc_shared")
+
+shaderc_shader_kind = ctypes.c_int32
+shaderc_source_language_glsl = 0
+shaderc_source_language_hlsl = 1
+
+shaderc_vertex_shader = 0
+shaderc_fragment_shader = 1
+shaderc_compute_shader = 2
+shaderc_geometry_shader = 3
+shaderc_tess_control_shader = 4
+shaderc_tess_evaluation_shader = 5
+
+shaderc_optimization_level_zero = 0  # no optimization
+shaderc_optimization_level_size = 1  # optimize towards reducing code size
+shaderc_optimization_level_performance = 2  # optimize towards performance
+
+class shaderc_compiler_t(c_void_p):
+    pass
+
+class shaderc_compilation_result(c_void_p):
+    pass
+
+class shaderc_compile_options(c_void_p):
+    pass
+
+# Define types for function arguments and return values
+shaderc_compiler_initialize = lib_shaderc.shaderc_compiler_initialize
+shaderc_compiler_initialize.restype = shaderc_compiler_t
+shaderc_compiler_initialize.argtypes = []
+
+shaderc_compiler_release = lib_shaderc.shaderc_compiler_release
+shaderc_compiler_release.restype = None
+shaderc_compiler_release.argtypes = [shaderc_compiler_t]
+
+shaderc_compile_into_spv = lib_shaderc.shaderc_compile_into_spv
+shaderc_compile_into_spv.restype = shaderc_compilation_result
+shaderc_compile_into_spv.argtypes = [shaderc_compiler_t, c_char_p, c_size_t, shaderc_shader_kind, c_char_p, c_char_p,
+                                     shaderc_compile_options]
+
+shaderc_result_release = lib_shaderc.shaderc_result_release
+shaderc_result_release.restype = None
+shaderc_result_release.argtypes = [shaderc_compilation_result]
+
+shaderc_result_get_bytes = lib_shaderc.shaderc_result_get_bytes
+shaderc_result_get_bytes.restype = POINTER(ctypes.c_ubyte)
+shaderc_result_get_bytes.argtypes = [c_void_p]
+
+shaderc_result_get_length = lib_shaderc.shaderc_result_get_length
+shaderc_result_get_length.restype = ctypes.c_size_t
+shaderc_result_get_length.argtypes = [c_void_p]
+
+shaderc_result_get_error_message = lib_shaderc.shaderc_result_get_error_message
+shaderc_result_get_error_message.restype = c_char_p
+shaderc_result_get_error_message.argtypes = [c_void_p]
+
+shaderc_result_get_compilation_status = lib_shaderc.shaderc_result_get_compilation_status
+shaderc_result_get_compilation_status.restype = shaderc_compilation_result
+shaderc_result_get_compilation_status.argtypes = [shaderc_compilation_result]
+
+# Options
+shaderc_compile_options_initialize = lib_shaderc.shaderc_compile_options_initialize
+shaderc_compile_options_initialize.restype = c_void_p
+shaderc_compile_options_initialize.argtypes = []
+
+shaderc_compile_options_set_target_spirv = lib_shaderc.shaderc_compile_options_set_target_spirv
+shaderc_compile_options_set_target_spirv.argtypes = [shaderc_compile_options, ]
+shaderc_compile_options_set_target_spirv.restype = None
+
+shaderc_optimization_level = ctypes.c_int32
+shaderc_compile_options_set_generate_debug_info = lib_shaderc.shaderc_compile_options_set_generate_debug_info
+shaderc_compile_options_set_generate_debug_info.argtypes = [shaderc_compile_options]
+shaderc_compile_options_set_generate_debug_info.restype = None
+
+shaderc_compile_options_set_optimization_level = lib_shaderc.shaderc_compile_options_set_optimization_level
+shaderc_compile_options_set_optimization_level.argtypes = [shaderc_compile_options, shaderc_optimization_level]
+shaderc_compile_options_set_optimization_level.restype = None

pyglet/libs/shared/spirv/lib_spirv_cross.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+import struct
+
+import pyglet
+from ctypes import POINTER, Structure, c_void_p, c_char_p, c_uint32, c_size_t, c_int, byref, c_int32
+
+try:
+    lib = pyglet.lib.load_library("spirv-cross-c-shared")
+except ImportError:
+    raise ImportError("spirv-cross-c-shared library not found.")
+
+spvc_result = c_int
+SPVC_SUCCESS = 0
+
+# The SPIR-V is invalid. Should have been caught by validation ideally.
+ERROR_INVALID_SPIRV = -1
+
+# The SPIR-V might be valid or invalid, but SPIRV-Cross currently cannot correctly translate this to your target language.
+ERROR_UNSUPPORTED_SPIRV = -2
+
+# If for some reason we hit this, new or malloc failed.
+ERROR_OUT_OF_MEMORY = -3
+
+# Invalid API argument.
+ERROR_INVALID_ARGUMENT = -4
+ERROR_INTERNAL = -5
+
+SPVC_ERROR_INT_MAX = 0x7fffffff
+
+
+# The Parsed IR payload will be copied, and the handle can be reused to create other compiler instances.
+SPVC_CAPTURE_MODE_COPY = 0
+
+# The payload will now be owned by the compiler.
+# parsed_ir should now be considered a dead blob and must not be used further.
+# This is optimal for performance and should be the go-to option.
+SPVC_CAPTURE_MODE_TAKE_OWNERSHIP = 1
+
+spvc_backend = c_int
+SPVC_BACKEND_NONE = 0
+SPVC_BACKEND_GLSL = 1  # spirv_cross::CompilerGLSL
+SPVC_BACKEND_HLSL = 2  #CompilerHLSL
+SPVC_BACKEND_MSL = 3  # CompilerMSL
+SPVC_BACKEND_CPP = 4  # CompilerCPP
+SPVC_BACKEND_JSON = 5  # CompilerReflection
+SPVC_BACKEND_INT_MAX = 0x7fffffff
+
+
+# Structures (opaque to the c-library)
+class spvc_context(c_void_p):
+    pass
+
+class spvc_parsed_ir(c_void_p):
+    pass
+
+class spvc_compiler(c_void_p):
+    pass
+
+class spvc_resources(c_void_p):
+    pass
+
+SpvExecutionModel = c_int
+
+class spvc_entry_point(Structure):
+    _fields_ = [
+        ('execution_model', SpvExecutionModel),
+        ('name', c_char_p),
+    ]
+
+SpvId = c_uint32
+
+spvc_resource_type = c_int
+spvc_type_id = SpvId
+spvc_variable_id = SpvId  # SPIRVariable
+spvc_constant_id = SpvId  # SPIRConstant
+
+spvc_capture_mode = c_int
+
+class spvc_reflected_resource(Structure):
+    _fields_ = [
+        ("id", spvc_variable_id),
+        ("type_id", spvc_type_id),
+        ("base_type_id", spvc_type_id),
+        ("name", c_char_p),
+    ]
+
+
+spvc_context_create = lib.spvc_context_create
+spvc_context_create.restype = spvc_result
+spvc_context_create.argtypes = [POINTER(spvc_context)]
+
+spvc_context_destroy = lib.spvc_context_destroy
+spvc_context_destroy.restype = spvc_result
+spvc_context_destroy.argtypes = [spvc_context]
+
+spvc_context_release_allocations = lib.spvc_context_release_allocations
+spvc_context_release_allocations.restype = None
+spvc_context_release_allocations.argtypes = [spvc_context]
+
+spvc_context_get_last_error_string = lib.spvc_context_get_last_error_string
+spvc_context_get_last_error_string.restype = c_char_p
+spvc_context_get_last_error_string.argtypes = [spvc_context]
+
+spvc_context_parse_spirv = lib.spvc_context_parse_spirv
+spvc_context_parse_spirv.restype = spvc_result
+spvc_context_parse_spirv.argtypes = [spvc_context, POINTER(SpvId), c_size_t, POINTER(spvc_parsed_ir)]
+
+spvc_context_create_compiler = lib.spvc_context_create_compiler
+spvc_context_create_compiler.restype = spvc_result
+spvc_context_create_compiler.argtypes = [spvc_context, spvc_backend, spvc_parsed_ir, spvc_capture_mode, POINTER(spvc_compiler)]
+
+lib.spvc_compiler_create_shader_resources.restype = spvc_result
+lib.spvc_compiler_create_shader_resources.argtypes = [spvc_compiler, POINTER(spvc_resources)]
+
+lib.spvc_resources_get_resource_list_for_type.restype = spvc_result
+lib.spvc_resources_get_resource_list_for_type.argtypes = [spvc_resources, spvc_resource_type, POINTER(POINTER(spvc_reflected_resource)), POINTER(c_size_t)]
+
+lib.spvc_compiler_get_decoration.restype = c_uint32
+lib.spvc_compiler_get_decoration.argtypes = [spvc_compiler, SpvId, c_int]
+
+lib.spvc_compiler_get_name.restype = c_char_p
+lib.spvc_compiler_get_name.argtypes = [spvc_compiler, c_uint32]
+
+spvc_compiler_compile = lib.spvc_compiler_compile
+spvc_compiler_compile.restype = spvc_result
+spvc_compiler_compile.argtypes = [spvc_compiler, POINTER(c_char_p)]