pyglet 2.1.dev6__py3-none-any.whl → 2.1.dev7__py3-none-any.whl

pyglet/__init__.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.dev6'
+version = '2.1.dev7'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -25,9 +25,6 @@ if sys.version_info < MIN_PYTHON_VERSION:
     msg = f"pyglet {version} requires Python {MIN_PYTHON_VERSION_STR} or newer."
     raise Exception(msg)
 
-if "sphinx" in sys.modules:
-    sys.is_pyglet_doc_run = True
-
 # pyglet platform treats *BSD systems as Linux
 compat_platform = sys.platform
 if "bsd" in compat_platform:

pyglet/app/__init__.py

@@ -68,7 +68,7 @@ the set when they are no longer referenced or are closed explicitly.
 """
 
 
-def run(interval: float | None = 1/60) -> None:
+def run(interval: float | None = 1 / 60) -> None:
     """Begin processing events, scheduled functions and window updates.
 
     This is a convenience function, equivalent to::

pyglet/app/cocoa.py

@@ -1,4 +1,6 @@
 import signal
+import time
+
 from pyglet import app
 from pyglet.app.base import PlatformEventLoop, EventLoop
 from pyglet.libs.darwin import cocoapy, AutoReleasePool, ObjCSubclass, PyObjectEncoding, ObjCInstance, send_super, \
@@ -11,7 +13,7 @@ NSDate = cocoapy.ObjCClass('NSDate')
 NSEvent = cocoapy.ObjCClass('NSEvent')
 NSUserDefaults = cocoapy.ObjCClass('NSUserDefaults')
 NSTimer = cocoapy.ObjCClass('NSTimer')
-
+NSRunningApplication = cocoapy.ObjCClass('NSRunningApplication')
 
 
 def add_menu_item(menu, title, action, key):
@@ -71,6 +73,30 @@ class _AppDelegate_Implementation:
     def applicationDidFinishLaunching_(self, notification):
         self._pyglet_loop._finished_launching = True
 
+        # Force App to activate to the foreground due to being an unbundled CLI program.
+        # This prevents an issue where if you move the mouse when launching the program, it's focus can be stolen
+        # by an app under/behind it leading to a weird state of input and the menu bar being greyed out until
+        # reactivating it.
+        NSApp = NSApplication.sharedApplication()
+
+        # Activate dock to ensure all other apps are deactivated.
+        dock_str = cocoapy.get_NSString("com.apple.dock")
+        running_apps = NSRunningApplication.runningApplicationsWithBundleIdentifier_(dock_str)
+        app_count = running_apps.count()
+        for i in range(app_count):
+            running_app = running_apps.objectAtIndex_(i)
+            running_app.activateWithOptions_(cocoapy.NSApplicationActivateIgnoringOtherApps)
+            break
+
+        # Doesn't seem to work unless we add a small sleep for some reason...
+        time.sleep(0.01)
+
+        NSApp.activateIgnoringOtherApps_(True)
+
+    @_AppDelegate.method('v@')
+    def applicationWillFinishLaunching_(self, notification):
+        pass
+
     @_AppDelegate.method('B')
     def applicationSupportsSecureRestorableState_(self):
         return True
@@ -129,7 +155,9 @@ class CocoaAlternateEventLoop(EventLoop):
 class CocoaPlatformEventLoop(PlatformEventLoop):
 
     def __init__(self):
-        super(CocoaPlatformEventLoop, self).__init__()
+        super().__init__()
+        self._timer = None
+
         with AutoReleasePool():
             # Prepare the default application.
             self.NSApp = NSApplication.sharedApplication()
@@ -151,8 +179,23 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
             if not defaults.objectForKey_(holdEnabled):
                 defaults.setBool_forKey_(False, holdEnabled)
 
+            self.appdelegate = _AppDelegate.alloc().init(self)
+            self.NSApp.setDelegate_(self.appdelegate)
+
             self._finished_launching = False
 
+        def term_received(*args):
+            if self._timer:
+                self._timer.invalidate()
+                self._timer = None
+
+            if self.NSApp:
+                self.NSApp.terminate_(None)
+
+        # Force NSApp to close if Python receives sig events.
+        signal.signal(signal.SIGINT, term_received)
+        signal.signal(signal.SIGTERM, term_received)
+
     def start(self):
         with AutoReleasePool():
             if not self.NSApp.isRunning() and not self._finished_launching:
@@ -167,38 +210,31 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
         from pyglet.app import event_loop
         self._event_loop = event_loop
 
-        def term_received(*args):
-            if self.timer:
-                self.timer.invalidate()
-                self.timer = None
+        assert self._timer is None
 
-            self.nsapp_stop()
-
-        # Force NSApp to close if Python receives sig events.
-        signal.signal(signal.SIGINT, term_received)
-        signal.signal(signal.SIGTERM, term_received)
-
-        self.appdelegate = _AppDelegate.alloc().init(self)
-        self.NSApp.setDelegate_(self.appdelegate)
-
-        self.timer = NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(
-             interval,  # Clamped internally to 0.0001 (including 0)
-             self.appdelegate,
-             get_selector('updatePyglet:'),
-             False,
-             True
-         )
+        self._timer = NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(
+            interval,  # Clamped internally to 0.0001 (including 0)
+            self.appdelegate,
+            get_selector('updatePyglet:'),
+            False,
+            True
+        )
 
         self.NSApp.run()
 
     def nsapp_step(self):
         """Used only for CocoaAlternateEventLoop"""
         self._event_loop.idle()
-        self.dispatch_posted_events()
+        with AutoReleasePool():
+            self.dispatch_posted_events()
 
     def nsapp_stop(self):
         """Used only for CocoaAlternateEventLoop"""
-        self.NSApp.terminate_(None)
+        self.NSApp.stop_(None)
+
+        if self._timer:
+            self._timer.invalidate()
+            self._timer = None
 
     def step(self, timeout=None):
         with AutoReleasePool():
@@ -210,7 +246,7 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
                 # will wait until the next event comes along.
                 timeout_date = NSDate.distantFuture()
             elif timeout == 0.0:
-                timeout_date = NSDate.distantPast()
+                timeout_date = None
             else:
                 timeout_date = NSDate.dateWithTimeIntervalSinceNow_(timeout)
 

pyglet/customtypes.py

@@ -14,7 +14,7 @@ else:
 HorizontalAlign = Literal["left", "center", "right"]
 AnchorX = Literal["left", "center", "right"]
 AnchorY = Literal["top", "bottom", "center", "baseline"]
-ContentVAlign = Literal["left", "center", "top"]
+ContentVAlign = Literal["bottom", "center", "top"]
 
 
 

pyglet/gl/cocoa.py

@@ -239,6 +239,11 @@ class CocoaDisplayConfig(DisplayConfig):  # noqa: D101
             self._pixel_format,
             share_context)
 
+        # No longer needed after context creation.
+        if self._pixel_format:
+            self._pixel_format.release()
+            self._pixel_format = None
+
         return CocoaContext(self, nscontext, share)
 
     def compatible(self, canvas: CocoaCanvas) -> bool:

pyglet/graphics/shader.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 import warnings
 import weakref
 from collections import defaultdict
@@ -329,9 +330,10 @@ class _UniformArray:
     _dsa: bool
     _c_array: Array[GLDataType]
     _ptr: CTypesPointer[GLDataType]
-    _uniform: _Uniform
+    _idx_to_loc: dict[int, int]
 
-    __slots__ = ('_uniform', '_gl_type', '_gl_getter', '_gl_setter', '_is_matrix', '_dsa', '_c_array', '_ptr')
+    __slots__ = ('_uniform', '_gl_type', '_gl_getter', '_gl_setter', '_is_matrix', '_dsa', '_c_array', '_ptr',
+                 '_idx_to_loc')
 
     def __init__(self, uniform: _Uniform, gl_getter: GLFunc, gl_setter: GLFunc, gl_type: GLDataType, is_matrix: bool,
                  dsa: bool) -> None:
@@ -340,6 +342,7 @@ class _UniformArray:
         self._gl_getter = gl_getter
         self._gl_setter = gl_setter
         self._is_matrix = is_matrix
+        self._idx_to_loc = {}  # Array index to uniform location mapping.
         self._dsa = dsa
 
         if self._uniform.length > 1:
@@ -349,6 +352,31 @@ class _UniformArray:
 
         self._ptr = cast(self._c_array, POINTER(gl_type))
 
+    def _get_location_for_index(self, index: int) -> int:
+        """Get the location for the array name.
+
+        It is not guaranteed that the location ID's of the uniform in the shader program will be a contiguous offset.
+
+        On MacOS, the location ID of index 0 may be 1, and then index 2 might be 5. Whereas on Windows it may be a 1:1
+        offset from 0 to index. Here, we store the location ID's of each index to ensure we are setting data on the
+        right location.
+        """
+        loc = gl.glGetUniformLocation(self._uniform.program,
+                                create_string_buffer(f"{self._uniform.name}[{index}]".encode('utf-8')))
+        return loc
+
+    def _get_array_loc(self, index: int) -> int:
+        try:
+            return self._idx_to_loc[index]
+        except KeyError:
+            loc = self._idx_to_loc[index] = self._get_location_for_index(index)
+
+        if loc == -1:
+            msg = f"{self._uniform.name}[{index}] not found.\nThis may have been optimized out by the OpenGL driver if unused."
+            raise ShaderException(msg)
+
+        return loc
+
     def __len__(self) -> int:
         return self._uniform.size
 
@@ -365,8 +393,12 @@ class _UniformArray:
 
             return tuple([data for data in sliced_data])  # noqa: C416
 
-        value = self._c_array[key]
-        return tuple(value) if self._uniform.length > 1 else value
+        try:
+            value = self._c_array[key]
+            return tuple(value) if self._uniform.length > 1 else value
+        except IndexError:
+            msg = f"{self._uniform.name}[{key}] not found. This may have been optimized out by the OpenGL driver if unused."
+            raise ShaderException(msg)
 
     def __setitem__(self, key: slice | int, value: Sequence) -> None:
         if isinstance(key, slice):
@@ -403,11 +435,19 @@ class _UniformArray:
         else:
             size = self._uniform.size
 
+        location = self._get_location_for_index(offset)
+
         if self._dsa:
-            self._gl_setter(self._uniform.program, self._uniform.location + offset, size, data)
+            if self._is_matrix:
+                self._gl_setter(self._uniform.program, location, size, GL_FALSE, data)
+            else:
+                self._gl_setter(self._uniform.program, location, size, data)
         else:
             glUseProgram(self._uniform.program)
-            self._gl_setter(self._uniform.location + offset, size, data)
+            if self._is_matrix:
+                self._gl_setter(location, size, GL_FALSE, data)
+            else:
+                self._gl_setter(location, size, data)
 
     def __repr__(self) -> str:
         data = [tuple(data) if self._uniform.length > 1 else data for data in self._c_array]
@@ -426,13 +466,15 @@ class _Uniform:
     size: int
     location: int
     program: int
+    name: str
     length: int
     get: Callable[[], Array[GLDataType] | GLDataType]
     set: Callable[[float], None] | Callable[[Sequence], None]
 
-    __slots__ = 'type', 'size', 'location', 'length', 'count', 'get', 'set', 'program'
+    __slots__ = 'type', 'size', 'location', 'length', 'count', 'get', 'set', 'program', 'name'
 
-    def __init__(self, program: int, uniform_type: int, size: int, location: int, dsa: bool) -> None:
+    def __init__(self, program: int, name: str, uniform_type: int, size: int, location: int, dsa: bool) -> None:
+        self.name = name
         self.type = uniform_type
         self.size = size
         self.location = location
@@ -609,6 +651,8 @@ class _UBOBindingManager:
             msg = f"Uniform binding point: {index} is not in use."
             raise ValueError(msg)
 
+# Regular expression to detect array indices like [0], [1], etc.
+array_regex = re.compile(r"(\w+)\[(\d+)\]")
 
 class UniformBlock:
     program: CallableProxyType[Callable[..., Any] | Any] | Any
@@ -616,12 +660,12 @@ class UniformBlock:
     index: int
     size: int
     binding: int
-    uniforms: dict[int, tuple[str, GLDataType, int, int, bool]]
+    uniforms: dict[int, tuple[str, GLDataType, int, int]]
     view_cls: type[Structure] | None
-    __slots__ = 'program', 'name', 'index', 'size', 'binding', 'uniforms', 'view_cls'
+    __slots__ = 'program', 'name', 'index', 'size', 'binding', 'uniforms', 'view_cls', 'uniform_count'
 
     def __init__(self, program: ShaderProgram, name: str, index: int, size: int, binding: int,
-                 uniforms: dict[int, tuple[str, GLDataType, int, int, bool]]) -> None:
+                 uniforms: dict[int, tuple[str, GLDataType, int, int]], uniform_count: int) -> None:
         """Initialize a uniform block for a ShaderProgram."""
         self.program = weakref.proxy(program)
         self.name = name
@@ -629,6 +673,7 @@ class UniformBlock:
         self.size = size
         self.binding = binding
         self.uniforms = uniforms
+        self.uniform_count = uniform_count
         self.view_cls = None
 
     def create_ubo(self) -> UniformBufferObject:
@@ -670,7 +715,7 @@ class UniformBlock:
         p_id = self.program.id
         index = self.index
 
-        active_count = len(self.uniforms)
+        active_count = self.uniform_count
 
         # Query the uniform index order and each uniform's offset:
         indices = (gl.GLuint * active_count)()
@@ -693,50 +738,86 @@ class UniformBlock:
         # gl.glGetActiveUniformsiv(p_id, active_count, indices, gl.GL_UNIFORM_TYPE, gl_types_ptr)
         # gl.glGetActiveUniformsiv(p_id, active_count, indices, gl.GL_UNIFORM_MATRIX_STRIDE, stride_ptr)
 
-        view_fields = []
-
-        for i in range(active_count):
-            u_name, gl_type, length, u_size, is_array = self.uniforms[indices[i]]
-
-            # Is something like a vec2,3,4.
-            if length > 1:
-                # If it's an array, further divide it.
-                if is_array:
-                    final_gl_type = gl_type * length * u_size
-                else:
-                    final_gl_type = gl_type * length
-            else:
-                # A single length, but may be an array.
-                if is_array:
-                    final_gl_type = gl_type * u_size
+        array_sizes = {}
+        dynamic_structs = {}
+        p_count = 0
+
+        rep_func = lambda s: str(dict(s._fields_))
+
+        def build_ctypes_struct(name: str, struct_dict: dict) -> type:
+            fields = []
+            for field_name, field_type in struct_dict.items():
+                if isinstance(field_type, dict):
+                    # Recursive call for nested structures
+                    element_struct = build_ctypes_struct(field_name, field_type)
+                    field_type = element_struct  # noqa: PLW2901
+                    if field_name in array_sizes and array_sizes[field_name] > 1:
+                        field_type = element_struct * array_sizes[field_name]  # noqa: PLW2901
                 else:
-                    final_gl_type = gl_type
-
-            offset_size = offsets[i + 1] - offsets[i]
-            c_type_size = sizeof(final_gl_type)
-            padding = offset_size - c_type_size
+                    # This handles base types like c_float_Array_2, which isn't a dict.
+                    fields.append((field_name, field_type))
+                    continue
+                fields.append((field_name, field_type))
 
-            arg = (u_name, final_gl_type)
-            view_fields.append(arg)
+            return type(name.title(), (Structure,), {"_fields_": fields, "__repr__": rep_func})
 
-            if padding > 0:
-                view_fields.append((f'_padding{i}', c_byte * padding))
-
-            # TODO: Cannot get a different stride on my hardware. Needs testing.
-            # is_matrix = gl_types[i] in _gl_matrices
-            # if is_matrix:
-            #     stride_padding = (mat_stride[i] // 4) * 4 - offset_size
-            #     if stride_padding > 0:
-            #         view_fields.append((f'_matrix_stride{i}', c_byte * stride_padding))
+        # Build a ctypes Structure of the uniforms including arrays and nested structures.
+        for i in range(active_count):
+            u_name, gl_type, length, u_size = self.uniforms[indices[i]]
+
+            parts = u_name.split(".")
+
+            current_structure = dynamic_structs
+            for part_idx, part in enumerate(parts):
+                part_name = part
+                match = array_regex.match(part_name)
+                if match:  # It's an array
+                    arr_name, index = match.groups()
+                    part_name = arr_name
+
+                    if part_idx != len(parts) - 1:
+                        index = int(index)  # Convert the index to an integer
+
+                        # Track array sizes for the current array name
+                        array_sizes[arr_name] = max(array_sizes.get(arr_name, 0), index + 1)
+                        if array_sizes[arr_name] > 1:
+                            break
+
+                        if arr_name not in current_structure:
+                            current_structure[arr_name] = {}
+
+                        current_structure = current_structure[arr_name]  # Move to the correct index of the array
+                        continue
+
+                # The end should be a regular attribute
+                if part_idx == len(parts) - 1:  # The last part is the actual type
+                    if u_size > 1:
+                        # If size > 1, treat as an array of type
+                        current_structure[part_name] = gl_type * length * u_size
+                    else:
+                        current_structure[part_name] = gl_type * length
+
+                    offset_size = offsets[i + 1] - offsets[i]
+                    c_type_size = sizeof(current_structure[part_name])
+                    padding = offset_size - c_type_size
+
+                    # TODO: Cannot get a different stride on my hardware. Needs testing.
+                    # is_matrix = gl_types[i] in _gl_matrices
+                    # if is_matrix:
+                    #     stride_padding = (mat_stride[i] // 4) * 4 - offset_size
+                    #     if stride_padding > 0:
+                    #         view_fields.append((f'_matrix_stride{i}', c_byte * stride_padding))
+
+                    if padding > 0:
+                        current_structure[f'_padding{p_count}'] = c_byte * padding
+                        p_count += 1
+                else:
+                    if part_name not in current_structure:
+                        current_structure[part_name] = {}
+                    current_structure = current_structure[part_name]  # Drill down into nested structures
 
         # Custom ctypes Structure for Uniform access:
-        class View(Structure):
-            _fields_ = view_fields
-
-            def __repr__(self) -> str:
-                return str(dict(self._fields_))
-
-        return View
+        return build_ctypes_struct('View', dynamic_structs)
 
     def _actual_binding_point(self) -> int:
         """Queries OpenGL to find what the bind point currently is."""
@@ -900,9 +981,9 @@ def _introspect_uniforms(program_id: int, have_dsa: bool) -> dict[str, _Uniform]
     for index in range(_get_number(program_id, gl.GL_ACTIVE_UNIFORMS)):
         u_name, u_type, u_size = _query_uniform(program_id, index)
 
-        # Multidimensional arrays cannot be fully inspected via OpenGL calls.
+        # Multidimensional arrays cannot be fully inspected via OpenGL calls and compile errors with 3.3.
         array_count = u_name.count("[0]")
-        if array_count > 1:
+        if array_count > 1 and u_name.count("[0][0]") != 0:
             msg = "Multidimensional arrays are not currently supported."
             raise ShaderException(msg)
 
@@ -911,11 +992,11 @@ def _introspect_uniforms(program_id: int, have_dsa: bool) -> dict[str, _Uniform]
             continue
 
         # Strip [0] from array name for a more user-friendly name.
-        if array_count == 1:
+        if array_count != 0:
             u_name = u_name.strip('[0]')
 
         assert u_name not in uniforms, f"{u_name} exists twice in the shader. Possible name clash with an array."
-        uniforms[u_name] = _Uniform(program_id, u_type, u_size, loc, have_dsa)
+        uniforms[u_name] = _Uniform(program_id, u_name, u_type, u_size, loc, have_dsa)
 
     if _debug_gl_shaders:
         for uniform in uniforms.values():
@@ -956,7 +1037,7 @@ def _introspect_uniform_blocks(program: ShaderProgram | ComputeShaderProgram) ->
         indices_ptr = cast(addressof(indices), POINTER(gl.GLint))
         gl.glGetActiveUniformBlockiv(program_id, index, gl.GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices_ptr)
 
-        uniforms: dict[int, tuple[str, GLDataType, int, int, bool]] = {}
+        uniforms: dict[int, tuple[str, GLDataType, int, int]] = {}
 
         if not hasattr(pyglet.gl.current_context, "ubo_manager"):
             pyglet.gl.current_context.ubo_manager = _UBOBindingManager()
@@ -966,26 +1047,16 @@ def _introspect_uniform_blocks(program: ShaderProgram | ComputeShaderProgram) ->
         for block_uniform_index in indices:
             uniform_name, u_type, u_size = _query_uniform(program_id, block_uniform_index)
 
-            is_array = False
-            array_count = uniform_name.count("[0]")
-            if array_count > 0:
-                is_array = True
-
-                # Strip [0] from array name for a more user-friendly name.
-                if array_count == 1:
-                    uniform_name = uniform_name.strip('[0]')
-                else:
-                    msg = "Multidimensional arrays are not currently supported."
-                    raise ShaderException(msg)
+            # Remove block name.
+            if uniform_name.startswith(f"{name}."):
+                uniform_name = uniform_name[len(name) + 1:]  # Strip 'block_name.' part
 
-            # Separate uniform name from block name (Only if instance name is provided on the Uniform Block)
-            try:
-                _, uniform_name = uniform_name.split(".")
-            except ValueError:
-                pass
+            if uniform_name.count("[0][0]") > 0:
+                msg = "Multidimensional arrays are not currently supported."
+                raise ShaderException(msg)
 
             gl_type, _, _, length = _uniform_setters[u_type]
-            uniforms[block_uniform_index] = (uniform_name, gl_type, length, u_size, is_array)
+            uniforms[block_uniform_index] = (uniform_name, gl_type, length, u_size)
 
         binding_index = binding.value
         if pyglet.options.shader_bind_management:
@@ -1005,7 +1076,8 @@ def _introspect_uniform_blocks(program: ShaderProgram | ComputeShaderProgram) ->
                     warnings.warn(msg)
                 manager.add_explicit_binding(program, name, binding.value)
 
-        uniform_blocks[name] = UniformBlock(program, name, index, block_data_size.value, binding_index, uniforms)
+        uniform_blocks[name] = UniformBlock(program, name, index, block_data_size.value, binding_index, uniforms,
+                                            len(indices))
 
         if _debug_gl_shaders:
             for block in uniform_blocks.values():