pyglet 3.0.dev8__py3-none-any.whl → 3.0.dev10__py3-none-any.whl

pyglet/__init__.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev8'
+version = '3.0.dev10'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 10
@@ -264,6 +264,15 @@ class Options:
 
     .. versionadded:: 2.0.5"""
 
+    osx_displaylink: bool = True
+    """If ``True`` (the default), macOS 14 and later uses ``CADisplayLink`` to schedule window draws.
+
+    Set this to ``False`` before calling :func:`pyglet.app.run` to retain the clock-driven redraw behavior used by
+    earlier pyglet versions. This is useful for applications that need a timer defined frame cadence, such as a
+    deterministic capture pipeline or an application that coordinates drawing with an external scheduler.
+
+    .. versionadded:: 3.0.0"""
+
     dpi_scaling: Literal["platform", "stretch"] = "platform"
     """For 'HiDPI' displays, Window behavior can differ between operating systems. Defaults to `'platform'`.
 
@@ -354,7 +363,7 @@ for _option_name, _type_str in options.__annotations__.items():
 
 
 if (__debug__ is False) or getattr(sys, "frozen", False):
-    options.debug_gl = False
+    options.debug_api = False
 
 
 # Call tracing

pyglet/__init__.pyi

@@ -68,6 +68,7 @@ class Options:
     win32_disable_xinput: bool
     com_mta: bool
     osx_alt_loop: bool
+    osx_displaylink: bool
     dpi_scaling: Literal["platform", "stretch"]
     shader_bind_management: bool
     wayland: bool

pyglet/app/__init__.py

@@ -51,6 +51,9 @@ else:
         # Use alternate loop only if forced, or using an M1 chip.
         if (platform.machine() == 'arm64' and "M1" in get_chip_model()) or pyglet.options.osx_alt_loop:
             from pyglet.app.cocoa import CocoaAlternateEventLoop as EventLoop
+    elif compat_platform == 'ios':
+        from pyglet.app.ios import IOSEventLoop as EventLoop
+        from pyglet.app.ios import IOSPlatformEventLoop as PlatformEventLoop
     elif compat_platform in ('win32', 'cygwin'):
         from pyglet.app.win32 import Win32EventLoop as PlatformEventLoop
     elif compat_platform == 'linux':

pyglet/app/cocoa.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import signal
 import time
+from typing import TYPE_CHECKING
 
+import pyglet
 from pyglet import app
-from pyglet.app.base import EventLoop, PlatformEventLoop
-from pyglet.libs.darwin import cocoapy, AutoReleasePool, ObjCSubclass, PyObjectEncoding, ObjCInstance, send_super, \
-    ObjCClass, get_selector, set_realtime_thread_policy
+from pyglet.app.base import EventLoop, PlatformEventLoop, WindowDrawSource
+from pyglet.libs.darwin import cocoapy, AutoReleasePool, PyObjectEncoding, ObjCInstance, send_super, \
+    ObjCClass, get_selector, objc_method, set_realtime_thread_policy
 
 NSApplication = cocoapy.ObjCClass('NSApplication')
+NSObject = cocoapy.ObjCClass('NSObject')
 NSMenu = cocoapy.ObjCClass('NSMenu')
 NSMenuItem = cocoapy.ObjCClass('NSMenuItem')
 NSDate = cocoapy.ObjCClass('NSDate')
@@ -17,6 +20,9 @@ NSUserDefaults = cocoapy.ObjCClass('NSUserDefaults')
 NSTimer = cocoapy.ObjCClass('NSTimer')
 NSRunningApplication = cocoapy.ObjCClass('NSRunningApplication')
 
+if TYPE_CHECKING:
+    from pyglet.window.apple.cocoa import CocoaWindow
+
 def add_menu_item(menu, title, action, key):
     with AutoReleasePool():
         title = cocoapy.CFSTR(title)
@@ -54,25 +60,24 @@ def create_menu():
         appMenuItem.release()
 
 
-class _AppDelegate_Implementation:
-    _AppDelegate = ObjCSubclass('NSObject', '_AppDelegate')
+class _AppDelegate(NSObject):
 
-    @_AppDelegate.method(b'@' + PyObjectEncoding)
+    @objc_method(b'@' + PyObjectEncoding)
     def init(self, pyglet_loop):
         objc = ObjCInstance(send_super(self, 'init'))
         self._pyglet_loop = pyglet_loop
         return objc  # objc is self
 
-    @_AppDelegate.method('v')
+    @objc_method('v')
     def updatePyglet_(self):
         self._pyglet_loop.nsapp_step()
 
-    @_AppDelegate.method('v@')
+    @objc_method('v@')
     def applicationWillTerminate_(self, notification):
         self._pyglet_loop.is_running = False
         self._pyglet_loop.has_exit = True
 
-    @_AppDelegate.method('v@')
+    @objc_method('v@')
     def applicationDidFinishLaunching_(self, notification):
         self._pyglet_loop._finished_launching = True
 
@@ -96,38 +101,32 @@ class _AppDelegate_Implementation:
 
         NSApp.activateIgnoringOtherApps_(True)
 
-    @_AppDelegate.method('v@')
+    @objc_method('v@')
     def applicationWillFinishLaunching_(self, notification):
         pass
 
-    @_AppDelegate.method('B')
+    @objc_method('B')
     def applicationSupportsSecureRestorableState_(self):
         return True
 
-_AppDelegate = ObjCClass('_AppDelegate')  # the actual class
-
 class CocoaAlternateEventLoop(EventLoop):
     """This is an alternate loop developed mainly for ARM64 variants of macOS.
-    nextEventMatchingMask_untilDate_inMode_dequeue_ is very broken with ctypes calls. Events eventually stop
-    working properly after X returns. This event loop differs in that it uses the built-in NSApplication event
+
+    nextEventMatchingMask_untilDate_inMode_dequeue_ is very broken with ctypes calls on M1.
+
+    Events eventually stop working properly after X returns. This event loop
+    differs in that it uses the built-in NSApplication event
     loop. We tie our schedule into it via timer.
     """
     def __init__(self):
         super().__init__()
         self.platform_event_loop = None
 
-    def run(self, interval: float | None = 1/60):
-        if interval is None:
-            pass  # do not schedule redraws
-        elif not interval:
-            self.clock.schedule(self._redraw_windows)
-        else:
-            self.clock.schedule_interval(self._redraw_windows, interval)
-
+    def run(self, interval: float | None = 1/60) -> None:
         self.has_exit = False
 
-        from pyglet.window import Window
-        Window._enable_event_queue = False
+        from pyglet.window import Window  # noqa: PLC0415
+        Window._enable_event_queue = False  # noqa: SLF001
 
         # Dispatch pending events
         for window in app.windows:
@@ -135,13 +134,18 @@ class CocoaAlternateEventLoop(EventLoop):
             window.dispatch_pending_events()
 
         self.platform_event_loop = app.platform_event_loop
+        self._schedule_window_draw(interval)
 
         self.dispatch_event('on_enter')
         self.is_running = True
 
-        self.platform_event_loop.nsapp_start(interval or 0)
+        try:
+            self.platform_event_loop.nsapp_start(interval or 0)
+        finally:
+            self._unschedule_window_draw()
+        self._raise_window_draw_exception()
 
-    def exit(self):
+    def exit(self) -> None:
         """Safely exit the event loop at the end of the current iteration.
 
         This method is a thread-safe equivalent for setting
@@ -159,12 +163,52 @@ class CocoaAlternateEventLoop(EventLoop):
             self.platform_event_loop.nsapp_stop()
 
 
+class CocoaWindowDrawSource(WindowDrawSource):
+    """Display driven drawing backed by one CADisplayLink."""
+
+    def __init__(self) -> None:
+        self._active = False
+        self._interval = None
+
+    def start(self, interval: float) -> bool:
+        started_windows = []
+        for window in app.windows:
+            if not window._start_display_link(interval):  # noqa: SLF001
+                for started_window in started_windows:
+                    started_window._stop_display_link()  # noqa: SLF001
+                return False
+            started_windows.append(window)
+
+        self._interval = interval
+        self._active = True
+        return True
+
+    def stop(self) -> None:
+        if not self._active:
+            return
+
+        self._active = False
+        self._interval = None
+        for window in app.windows:
+            window._stop_display_link()  # noqa: SLF001
+
+    def add_window(self, window: CocoaWindow) -> bool:
+        return not self._active or window._start_display_link(self._interval)  # noqa: SLF001
+
+    def remove_window(self, window: CocoaWindow) -> None:
+        window._stop_display_link()  # noqa: SLF001
+
+
 class CocoaPlatformEventLoop(PlatformEventLoop):
 
     def __init__(self):
         super().__init__()
         set_realtime_thread_policy()
         self._timer = None
+        nsview = ObjCClass('NSView')
+        self._display_link_supported = bool(
+            nsview.instancesRespondToSelector_(get_selector('displayLinkWithTarget:selector:'))
+        )
 
         with AutoReleasePool():
             # Prepare the default application.
@@ -198,7 +242,7 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
         signal.signal(signal.SIGINT, term_received)
         signal.signal(signal.SIGTERM, term_received)
 
-    def start(self):
+    def start(self) -> None:
         with AutoReleasePool():
             if not self.NSApp.isRunning() and not self._finished_launching:
                 # finishLaunching should be called only once. However isRunning will not
@@ -207,9 +251,14 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
                 self.NSApp.activateIgnoringOtherApps_(True)
                 self._finished_launching = True
 
-    def nsapp_start(self, interval):
-        """Used only for CocoaAlternateEventLoop"""
-        from pyglet.app import event_loop
+    def create_window_draw_source(self, _event_loop: EventLoop) -> WindowDrawSource | None:
+        if pyglet.options.osx_displaylink and self._display_link_supported:
+            return CocoaWindowDrawSource()
+        return None
+
+    def nsapp_start(self, interval: float) -> None:
+        """Used only for CocoaAlternateEventLoop."""
+        from pyglet.app import event_loop  # noqa: PLC0415
         self._event_loop = event_loop
 
         assert self._timer is None
@@ -219,26 +268,26 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
             self.appdelegate,
             get_selector('updatePyglet:'),
             False,
-            True
+            True,
         )
 
         self.NSApp.run()
 
-    def nsapp_step(self):
-        """Used only for CocoaAlternateEventLoop"""
+    def nsapp_step(self) -> None:
+        """Used only for CocoaAlternateEventLoop."""
         self._event_loop.idle()
         with AutoReleasePool():
             self.dispatch_posted_events()
 
-    def nsapp_stop(self):
-        """Used only for CocoaAlternateEventLoop"""
+    def nsapp_stop(self) -> None:
+        """Used only for CocoaAlternateEventLoop."""
         self.NSApp.stop_(None)
 
         if self._timer:
             self._timer.invalidate()
             self._timer = None
 
-    def step(self, timeout=None):
+    def step(self, timeout: float | None=None) -> bool:  # noqa: ANN201
         with AutoReleasePool():
             self.dispatch_posted_events()
 
@@ -274,10 +323,10 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
 
             return did_time_out
 
-    def stop(self):
+    def stop(self) -> None:
         pass
 
-    def notify(self):
+    def notify(self) -> None:
         with AutoReleasePool():
             notifyEvent = NSEvent.otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_(
                 cocoapy.NSApplicationDefined, # type

pyglet/app/ios.py

@@ -0,0 +1,168 @@
+"""UIKit app loop integration on iOS."""
+from __future__ import annotations
+
+import os
+
+from pyglet import app
+from pyglet.app.base import EventLoop, PlatformEventLoop, WindowDrawSource
+from pyglet.libs.darwin import get_display_link_dt
+from pyglet.libs.darwin.cocoapy import (
+    CAFrameRateRange,
+    NSRunLoopCommonModes,
+    ObjCClass,
+    ObjCInstance,
+    PyObjectEncoding,
+    get_selector,
+    objc_method,
+    send_super,
+)
+
+_XCTEST_ENVIRONMENT = (
+    "XCTestBundlePath",
+    "XCTestConfigurationFilePath",
+    "XCTestSessionIdentifier",
+)
+
+def _is_xctest() -> bool:
+    return any(name in os.environ for name in _XCTEST_ENVIRONMENT)
+
+NSObject = ObjCClass('NSObject')
+NSRunLoop = ObjCClass('NSRunLoop')
+CADisplayLink = ObjCClass('CADisplayLink')
+
+
+class _PygletIOSDisplayLinkTarget(NSObject):
+
+    @objc_method(b'@' + PyObjectEncoding)
+    def initWithDrawSource_(self, draw_source: IOSDisplayLinkDrawSource) -> ObjCInstance | None:
+        self = ObjCInstance(send_super(self, 'init'))
+        if not self:
+            return None
+        self._draw_source = draw_source
+        return self
+
+    @objc_method('v@')
+    def displayLinkFired_(self, display_link: ObjCInstance) -> None:
+        self._draw_source.tick(display_link)
+
+
+class IOSDisplayLinkDrawSource(WindowDrawSource):
+    """One UIKit display link that paces all pyglet window drawing."""
+
+    def __init__(self, event_loop: IOSEventLoop) -> None:
+        self._event_loop = event_loop
+        self._display_link = None
+        self._target = None
+        self._last_timestamp: float | None = None
+
+    def start(self, interval: float) -> bool:
+        if self._display_link is not None:
+            return True
+
+        self._target = _PygletIOSDisplayLinkTarget.alloc().initWithDrawSource_(self)
+        display_link = CADisplayLink.displayLinkWithTarget_selector_(
+            self._target,
+            get_selector('displayLinkFired:'),
+        )
+        if display_link is None:
+            self._target.release()
+            self._target = None
+            return False
+
+        if interval:
+            frame_rate = 1 / interval
+            if CADisplayLink.instancesRespondToSelector_(get_selector('setPreferredFrameRateRange:')):
+                display_link.setPreferredFrameRateRange_(
+                    CAFrameRateRange(frame_rate, frame_rate, frame_rate),
+                )
+            else:
+                display_link.setPreferredFramesPerSecond_(round(frame_rate))
+
+        self._display_link = display_link
+        self._last_timestamp = None
+        display_link.addToRunLoop_forMode_(NSRunLoop.mainRunLoop(), NSRunLoopCommonModes)
+        return True
+
+    def stop(self) -> None:
+        if self._display_link is not None:
+            self._display_link.invalidate()
+            self._display_link = None
+        if self._target is not None:
+            self._target.release()
+            self._target = None
+        self._last_timestamp = None
+
+    def tick(self, display_link: ObjCInstance) -> None:
+        if self._display_link is None or not self._event_loop.is_running:
+            return
+        self._last_timestamp, dt = get_display_link_dt(display_link, self._last_timestamp)
+        self._event_loop._tick_app(dt)  # noqa: SLF001
+
+class IOSPlatformEventLoop(PlatformEventLoop):
+    """Schedules pyglet work from UIKit's already-running main run loop."""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def notify(self) -> None:
+        return None
+
+    def start(self) -> None:
+        self._is_running.set()
+
+    def step(self, timeout: float | None = None) -> None:
+        self.dispatch_posted_events()
+
+    def stop(self) -> None:
+        self._is_running.clear()
+
+    def create_window_draw_source(self, event_loop: EventLoop) -> WindowDrawSource:
+        return IOSDisplayLinkDrawSource(event_loop)
+
+
+class IOSEventLoop(EventLoop):
+    """Event loop similar to what we did for alt macos loop.."""
+
+    def run(self, interval: float | None = 1 / 60) -> None:
+        # Check for XCode environment as it owns the app lifetime and finalizes its embedded
+        # interpreter after the test returns.  It must not receive native
+        # callbacks from a pyglet timer after that point.
+        if _is_xctest():
+            # Tick app once during test to ensure at least one draw.
+            self._tick_app()
+            self.has_exit = True
+            return
+
+        self.has_exit = False
+        from pyglet.window import Window  # noqa: PLC0415
+        Window._enable_event_queue = False # noqa: SLF001
+        for window in app.windows:
+            window.dispatch_pending_events()
+
+        self._interval = interval
+        self.dispatch_event('on_enter')
+        self.is_running = True
+        app.platform_event_loop.start()
+        self._schedule_display_link(interval)
+
+    def _schedule_display_link(self, interval: float | None) -> None:
+        self._window_draw_source = app.platform_event_loop.create_window_draw_source(self)
+        if not self._window_draw_source.start(1 / 60 if interval is None else interval):
+            raise RuntimeError("Unable to create the iOS CADisplayLink.")
+
+    def _tick_app(self, draw_dt: float | None = None) -> None:
+        app.platform_event_loop.dispatch_posted_events()
+        clock_dt = self.clock.update_time()
+        self.clock.call_scheduled_functions(clock_dt)
+        if self._interval is not None:
+            for window in app.windows:
+                self._dispatch_platform_draw(window, clock_dt if draw_dt is None else draw_dt)
+
+    def exit(self) -> None:
+        if not self.is_running:
+            return
+        self.has_exit = True
+        self.is_running = False
+        self._unschedule_window_draw()
+        app.platform_event_loop.stop()
+        self.dispatch_event('on_exit')

pyglet/config/gl/__init__.py

@@ -120,6 +120,11 @@ def get_surface_config(user_config: UserConfig, surface: pyglet.window.Window) -
 
         return match(user_config, surface)
 
+    if pyglet.compat_platform == "ios":
+        from pyglet.config.gl.ios import match  # noqa: PLC0415
+
+        return match(user_config, surface)
+
     if pyglet.compat_platform == "emscripten":
         from pyglet.config.gl.webgl import match  # noqa: PLC0415
 

pyglet/config/gl/ios.py

@@ -0,0 +1,45 @@
+"""OpenGL ES surface configuration for UIKit windows."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pyglet.config.gl import GLSurfaceConfig
+from pyglet.enums import GraphicsAPI
+
+if TYPE_CHECKING:
+    from pyglet.config import OpenGLUserConfig
+    from pyglet.graphics.api.gl.global_opengl import OpenGLBackend
+    from pyglet.graphics.api.gl.ios.context import IOSContext
+    from pyglet.window.apple.ios import IOSWindow
+
+
+def match(config: OpenGLUserConfig, window: IOSWindow) -> IOSGLSurfaceConfig | None:
+    # iOS only supports GLES2 or 3.
+    if config.api not in (GraphicsAPI.OPENGL_ES_2, GraphicsAPI.OPENGL_ES_3):
+        return None
+    if config.api == GraphicsAPI.OPENGL_ES_3 and (config.major_version or 3) > 3:
+        return None
+    return IOSGLSurfaceConfig(window, config)
+
+
+class IOSGLSurfaceConfig(GLSurfaceConfig):
+
+    def __init__(self, window: IOSWindow, config: OpenGLUserConfig) -> None:
+        super().__init__(window, config, handle=None)
+        self.double_buffer = True
+        self.red_size = self.green_size = self.blue_size = self.alpha_size = 8
+        self.buffer_size = 32
+        self.depth_size = config.depth_size or 16
+        self.stencil_size = config.stencil_size or 0
+        self.sample_buffers = self.samples = 0
+        self.stereo = self.aux_buffers = 0
+        self.major_version = config.major_version or (3 if config.api == GraphicsAPI.OPENGL_ES_3 else 2)
+        self.minor_version = config.minor_version or 0
+
+    def create_context(self, opengl_backend: OpenGLBackend, share: IOSContext | None) -> IOSContext:
+        from pyglet.graphics.api.gl.ios.context import IOSContext  # noqa: PLC0415
+
+        return IOSContext(opengl_backend, self._window, self, share)
+
+    def apply_format(self) -> None:
+        return None

pyglet/config/gl/macos.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from pyglet.config import OpenGLUserConfig
     from pyglet.graphics.api.gl.cocoa.context import NSOpenGLPixelFormat, CocoaContext
-    from pyglet.window.cocoa import CocoaWindow
+    from pyglet.window.apple.cocoa import CocoaWindow
     from pyglet.graphics.api import OpenGLBackend
 
 # Version info, needed as OpenGL different Lion and onward

pyglet/config/gl/windows.py

@@ -6,7 +6,7 @@ from dataclasses import asdict
 
 from typing import TYPE_CHECKING
 from pyglet.config.gl import GLSurfaceConfig
-from pyglet.libs.win32 import PIXELFORMATDESCRIPTOR, _gdi32, wglext_arb, wgl
+from pyglet.libs.win32 import PIXELFORMATDESCRIPTOR, _gdi32, wgl
 from pyglet.libs.win32.constants import PFD_DRAW_TO_WINDOW, PFD_SUPPORT_OPENGL, PFD_DOUBLEBUFFER, \
     PFD_DOUBLEBUFFER_DONTCARE, PFD_STEREO, PFD_STEREO_DONTCARE, PFD_DEPTH_DONTCARE, PFD_TYPE_RGBA
 from pyglet.libs.win32.wgl import WGLFunctions
@@ -221,22 +221,22 @@ class GLLegacyConfig(GLSurfaceConfig):
 
 class GLSurfaceConfig(GLSurfaceConfig):
     attribute_ids = {  # noqa: RUF012
-        'double_buffer': wglext_arb.WGL_DOUBLE_BUFFER_ARB,
-        'stereo': wglext_arb.WGL_STEREO_ARB,
-        'buffer_size': wglext_arb.WGL_COLOR_BITS_ARB,
-        'aux_buffers': wglext_arb.WGL_AUX_BUFFERS_ARB,
-        'sample_buffers': wglext_arb.WGL_SAMPLE_BUFFERS_ARB,
-        'samples': wglext_arb.WGL_SAMPLES_ARB,
-        'red_size': wglext_arb.WGL_RED_BITS_ARB,
-        'green_size': wglext_arb.WGL_GREEN_BITS_ARB,
-        'blue_size': wglext_arb.WGL_BLUE_BITS_ARB,
-        'alpha_size': wglext_arb.WGL_ALPHA_BITS_ARB,
-        'depth_size': wglext_arb.WGL_DEPTH_BITS_ARB,
-        'stencil_size': wglext_arb.WGL_STENCIL_BITS_ARB,
-        'accum_red_size': wglext_arb.WGL_ACCUM_RED_BITS_ARB,
-        'accum_green_size': wglext_arb.WGL_ACCUM_GREEN_BITS_ARB,
-        'accum_blue_size': wglext_arb.WGL_ACCUM_BLUE_BITS_ARB,
-        'accum_alpha_size': wglext_arb.WGL_ACCUM_ALPHA_BITS_ARB,
+        'double_buffer': wgl.WGL_DOUBLE_BUFFER_ARB,
+        'stereo': wgl.WGL_STEREO_ARB,
+        'buffer_size': wgl.WGL_COLOR_BITS_ARB,
+        'aux_buffers': wgl.WGL_AUX_BUFFERS_ARB,
+        'sample_buffers': wgl.WGL_SAMPLE_BUFFERS_ARB,
+        'samples': wgl.WGL_SAMPLES_ARB,
+        'red_size': wgl.WGL_RED_BITS_ARB,
+        'green_size': wgl.WGL_GREEN_BITS_ARB,
+        'blue_size': wgl.WGL_BLUE_BITS_ARB,
+        'alpha_size': wgl.WGL_ALPHA_BITS_ARB,
+        'depth_size': wgl.WGL_DEPTH_BITS_ARB,
+        'stencil_size': wgl.WGL_STENCIL_BITS_ARB,
+        'accum_red_size': wgl.WGL_ACCUM_RED_BITS_ARB,
+        'accum_green_size': wgl.WGL_ACCUM_GREEN_BITS_ARB,
+        'accum_blue_size': wgl.WGL_ACCUM_BLUE_BITS_ARB,
+        'accum_alpha_size': wgl.WGL_ACCUM_ALPHA_BITS_ARB,
     }
 
     def __init__(self, window: Win32Window, pf: int, user_config: OpenGLUserConfig) -> None:

pyglet/display/__init__.py

@@ -38,6 +38,9 @@ else:
     elif compat_platform == 'darwin':
         from pyglet.display.cocoa import CocoaDisplay as Display
         from pyglet.display.cocoa import CocoaScreen as Screen
+    elif compat_platform == 'ios':
+        from pyglet.display.ios import IOSDisplay as Display
+        from pyglet.display.ios import IOSScreen as Screen
     elif compat_platform in ('win32', 'cygwin'):
         from pyglet.display.win32 import Win32Display as Display
         from pyglet.display.win32 import Win32Screen as Screen

pyglet/display/headless.py

@@ -41,7 +41,7 @@ class EGLHeadlessDisplay(HeadlessDisplay):
         num_devices = egl.EGLint()
         try:
             egl.eglQueryDevicesEXT(0, None, byref(num_devices))
-        except pyglet.libs.egl.eglext.MissingFunctionException:
+        except pyglet.libs.MissingFunctionException:
             warnings.warn('No device available for EGL device platform. Using native display type.')
             display = egl.EGLNativeDisplayType()
             self._display_connection = egl.eglGetDisplay(display)

pyglet/display/ios.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pyglet.libs.darwin.cocoapy import ObjCClass
+
+from .base import Display, Screen, ScreenMode
+
+
+UIScreen = ObjCClass('UIScreen')
+
+
+class IOSDisplay(Display):
+    """The single display from UIKit."""
+
+    def get_screens(self) -> list[IOSScreen]:
+        return [IOSScreen(self, UIScreen.mainScreen())]
+
+
+class IOSScreen(Screen):
+    def __init__(self, display: IOSDisplay, ui_screen) -> None:
+        self._ui_screen = ui_screen
+        bounds = ui_screen.bounds()
+        scale = ui_screen.nativeScale()
+        super().__init__(display, 0, 0, round(bounds.size.width * scale), round(bounds.size.height * scale))
+
+    def get_modes(self) -> list[ScreenMode]:
+        return [self.get_mode()]
+
+    def get_mode(self) -> ScreenMode:
+        mode = ScreenMode(self)
+        mode.width, mode.height, mode.depth, mode.rate = self.width, self.height, None, None
+        return mode
+
+    def set_mode(self, mode: ScreenMode) -> None:
+        return None
+
+    def restore_mode(self) -> None:
+        return None
+
+    def get_dpi(self) -> int:
+        return round(96 * self.get_scale())
+
+    def get_scale(self) -> float:
+        return float(self._ui_screen.nativeScale())
+
+    def get_display_id(self) -> str:
+        return 'main'
+
+    def get_monitor_name(self) -> str:
+        return 'iOS Display'