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

pyglet/graphics/api/gl/win32/context.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from ctypes import c_int
+
+from pyglet.graphics.api.gl.base import ContextException
+from pyglet.graphics.api.gl.context import OpenGLSurfaceContext
+from pyglet.libs.win32 import wglext_arb, wgl
+from pyglet.libs.win32.wgl import WGLFunctions
+from pyglet.graphics.api.gl.win32.wgl_info import WGLInfo
+from pyglet.libs.win32 import _gdi32
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.config.gl.windows import GLSurfaceConfig, GLLegacyConfig
+    from pyglet.graphics.api.gl.global_opengl import OpenGLBackend
+    from pyglet.window.win32 import Win32Window
+
+
+
+class _BaseWin32Context(OpenGLSurfaceContext):
+    def __init__(self,
+                 opengl_backend: OpenGLBackend,
+                 window: Win32Window,
+                 config: GLSurfaceConfig,
+                 share: Win32Context | Win32ARBContext) -> None:
+        super().__init__(opengl_backend, window, config,
+                         platform_info=WGLInfo(), context_share=share, platform_func_class=WGLFunctions)
+
+    def set_current(self) -> None:
+        if self._context is not None and self != self.core.current_context:
+            wgl.wglMakeCurrent(self.window._dc, self._context)  # noqa: SLF001
+        super().set_current()
+
+    def detach(self) -> None:
+        if self._context:
+            wgl.wglDeleteContext(self._context)
+            self._context = None
+        super().detach()
+
+    def flip(self) -> None:
+        _gdi32.SwapBuffers(self.window._dc)  # noqa: SLF001
+
+    def get_vsync(self) -> bool:
+        if self._info.have_extension('WGL_EXT_swap_control'):
+            return bool(self.platform_func.wglGetSwapIntervalEXT())
+        return False
+
+    def set_vsync(self, vsync: bool) -> None:
+        if self._info.have_extension('WGL_EXT_swap_control'):
+            self.platform_func.wglSwapIntervalEXT(int(vsync))
+
+
+class Win32Context(_BaseWin32Context):
+    config: GLLegacyConfig
+    context_share: Win32Context | None
+
+    def attach(self, window: Win32Window) -> None:
+        if not self._context:
+            self.config.apply_format()
+            self._context = wgl.wglCreateContext(window.dc)
+
+        share = self.context_share
+        if share:
+            if not share.window:
+                msg = 'Share context has no window.'
+                raise RuntimeError(msg)
+            if not wgl.wglShareLists(share._context, self._context):  # noqa: SLF001
+                msg = 'Unable to share contexts.'
+                raise ContextException(msg)
+
+        super().attach(window)
+
+
+class Win32ARBContext(_BaseWin32Context):
+    config: GLSurfaceConfig
+    context_share: Win32ARBContext | None
+
+    def attach(self, window: Win32Window) -> None:
+        share = self.context_share
+        if share:
+            if not share.window:
+                msg = 'Share context has no window.'
+                raise RuntimeError(msg)
+            share = share._context  # noqa: SLF001
+
+        attribs = []
+        user_config = self.config.config
+        if user_config.major_version is not None:
+            attribs.extend([wglext_arb.WGL_CONTEXT_MAJOR_VERSION_ARB, user_config.major_version])
+        if user_config.minor_version is not None:
+            attribs.extend([wglext_arb.WGL_CONTEXT_MINOR_VERSION_ARB, user_config.minor_version])
+        flags = 0
+        if user_config.forward_compatible and not user_config.opengl_api:
+            flags |= wglext_arb.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
+        if user_config.debug:
+            flags |= wglext_arb.WGL_CONTEXT_DEBUG_BIT_ARB
+        if user_config.opengl_api == "gles":
+            attribs.extend([wglext_arb.WGL_CONTEXT_PROFILE_MASK_ARB, wglext_arb.WGL_CONTEXT_ES_PROFILE_BIT_EXT])
+        if flags:
+            attribs.extend([wglext_arb.WGL_CONTEXT_FLAGS_ARB, flags])
+        attribs.append(0)
+        attribs = (c_int * len(attribs))(*attribs)
+
+        self.config.apply_format()
+
+        from pyglet.config.gl.windows import _global_wgl
+        self._context = _global_wgl.funcs.wglCreateContextAttribsARB(window.dc, share, attribs)
+        super().attach(window)

pyglet/graphics/api/gl/win32/wgl_info.py

@@ -0,0 +1,24 @@
+"""Cached information about version and extensions of current WGL implementation."""
+from __future__ import annotations
+
+import warnings
+from ctypes import c_char_p, cast
+
+from pyglet.graphics.api.gl import GL_EXTENSIONS, OpenGLSurfaceContext
+from pyglet.graphics.api.gl.lib import MissingFunctionException
+from pyglet.util import asstr
+
+
+class WGLInfoException(Exception):  # noqa: N818
+    pass
+
+
+class WGLInfo:
+    @staticmethod
+    def get_extensions(ctx: OpenGLSurfaceContext) -> list[str]:
+        """Can only be called when a context is in scope."""
+        try:
+            return asstr(ctx.platform_func.wglGetExtensionsStringEXT()).split()
+        except MissingFunctionException:
+            warnings.warn("Missing WGL function: wglGetExtensionsStringEXT}.")
+            return asstr(cast(ctx.glGetString(GL_EXTENSIONS), c_char_p).value).split()

pyglet/graphics/api/gl/xlib/context.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import warnings
+from ctypes import byref, c_int, c_uint
+from typing import TYPE_CHECKING
+
+from pyglet.graphics.api import gl
+from pyglet.graphics.api.gl import lib, OpenGLSurfaceContext
+from pyglet.graphics.api.gl.base import ContextException
+from pyglet.graphics.api.gl.xlib import glx_info
+from pyglet.libs.linux.glx import glxext_arb, glx, glxext_mesa
+
+if TYPE_CHECKING:
+    from pyglet.config.gl.x11 import XlibGLSurfaceConfig
+    from pyglet.graphics.api.gl import OpenGLBackend
+    from pyglet.window.xlib import XlibWindow
+    from pyglet.libs.linux.x11.xlib import Display
+
+
+class XlibContext(OpenGLSurfaceContext):
+    x_display: Display
+    glx_context: glx.GLXContext
+    glx_window: glx.GLXWindow | None
+    _use_video_sync: bool
+    _vsync: bool
+    config: XlibGLSurfaceConfig
+    attached: bool = False
+
+    _have_SGI_swap_control: bool  # noqa: N815
+    _have_EXT_swap_control: bool  # noqa: N815
+    _have_MESA_swap_control: bool  # noqa: N815
+    _have_SGI_video_sync: bool  # noqa: N815
+
+    def __init__(self,
+                 opengl_backend: OpenGLBackend,
+                 window: XlibWindow,
+                 config: XlibGLSurfaceConfig,
+                 share: XlibContext | None) -> None:
+        self.x_display = window._x_display  # noqa: SLF001
+        info = glx_info.GLXInfo(self.x_display)
+        super().__init__(opengl_backend, window, config,
+                         platform_info=info,
+                         context_share=share)
+
+        self.glx_context = self._create_glx_context(share)
+        if not self.glx_context:
+            # TODO: Check Xlib error generated
+            msg = 'Could not create GL context'
+            raise ContextException(msg)
+
+        self._have_SGI_video_sync = info.have_extension('GLX_SGI_video_sync')
+        self._have_SGI_swap_control = info.have_extension('GLX_SGI_swap_control')
+        self._have_EXT_swap_control = info.have_extension('GLX_EXT_swap_control')
+        self._have_MESA_swap_control = info.have_extension('GLX_MESA_swap_control')
+
+        # In order of preference:
+        # 1. GLX_EXT_swap_control (more likely to work where video_sync will not)
+        # 2. GLX_MESA_swap_control (same as above, but supported by MESA drivers)
+        # 3. GLX_SGI_video_sync (does not work on Intel 945GM, but that has EXT)
+        # 4. GLX_SGI_swap_control (cannot be disabled once enabled)
+        self._use_video_sync = (self._have_SGI_video_sync and
+                                not (self._have_EXT_swap_control or self._have_MESA_swap_control))
+
+        # XXX Mandate that vsync defaults on across all platforms.
+        self._vsync = True
+        self.glx_window = None
+
+    def is_direct(self) -> bool:
+        return bool(glx.glXIsDirect(self.x_display, self.glx_context))
+
+    def _create_glx_context(self, share: XlibContext | None) -> glx.GLXContext:
+        if share:
+            share_context = share.glx_context
+        else:
+            share_context = None
+
+        user_config = self.config.config
+
+        attribs = []
+        if user_config.major_version is not None:
+            attribs.extend([glxext_arb.GLX_CONTEXT_MAJOR_VERSION_ARB, user_config.major_version])
+        if user_config.minor_version is not None:
+            attribs.extend([glxext_arb.GLX_CONTEXT_MINOR_VERSION_ARB, user_config.minor_version])
+
+        if user_config.opengl_api == "gl":
+            attribs.extend([glxext_arb.GLX_CONTEXT_PROFILE_MASK_ARB, glxext_arb.GLX_CONTEXT_CORE_PROFILE_BIT_ARB])
+        elif user_config.opengl_api == "gles":
+            attribs.extend([glxext_arb.GLX_CONTEXT_PROFILE_MASK_ARB, glxext_arb.GLX_CONTEXT_ES2_PROFILE_BIT_EXT])
+
+        flags = 0
+        if user_config.forward_compatible:
+            flags |= glxext_arb.GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
+        if user_config.debug:
+            flags |= glxext_arb.GLX_CONTEXT_DEBUG_BIT_ARB
+
+        if flags:
+            attribs.extend([glxext_arb.GLX_CONTEXT_FLAGS_ARB, flags])
+        attribs.append(0)
+        attribs = (c_int * len(attribs))(*attribs)
+
+        return glxext_arb.glXCreateContextAttribsARB(self.window._x_display, self.config.fbconfig,  # noqa: SLF001
+                                                     share_context, True, attribs)
+
+    def attach(self, window: XlibWindow) -> None:
+        if self.attached:
+            return
+
+        super().attach(window)
+
+        self.glx_window = glx.glXCreateWindow(self.x_display,
+                                              self.config.fbconfig, self.window._x_window,  # noqa: SLF001
+                                              None)
+        self.set_current()
+        self.attached = True
+
+    def set_current(self) -> None:
+        glx.glXMakeContextCurrent(self.x_display, self.glx_window, self.glx_window, self.glx_context)
+        super().set_current()
+
+    def detach(self) -> None:
+        if not self.attached:
+            return
+
+        self.set_current()
+        gl.glFlush()
+
+        super().detach()
+
+        self.attached = False
+
+        glx.glXMakeContextCurrent(self.x_display, 0, 0, None)
+        if self.glx_window:
+            glx.glXDestroyWindow(self.x_display, self.glx_window)
+            self.glx_window = None
+
+    def destroy(self) -> None:
+        super().destroy()
+        if self.glx_window:
+            glx.glXDestroyWindow(self.x_display, self.glx_window)
+            self.glx_window = None
+        if self.glx_context:
+            glx.glXDestroyContext(self.x_display, self.glx_context)
+            self.glx_context = None
+
+    def set_vsync(self, vsync: bool = True) -> None:
+        self._vsync = vsync
+        interval = (vsync and 1) or 0
+        try:
+            if not self._use_video_sync and self._have_EXT_swap_control:
+                glxext_arb.glXSwapIntervalEXT(self.x_display, glx.glXGetCurrentDrawable(), interval)
+            elif not self._use_video_sync and self._have_MESA_swap_control:
+                glxext_mesa.glXSwapIntervalMESA(interval)
+            elif self._have_SGI_swap_control:
+                glxext_arb.glXSwapIntervalSGI(interval)
+        except lib.MissingFunctionException as e:
+            warnings.warn(str(e))
+
+    def get_vsync(self) -> bool:
+        return self._vsync
+
+    def _wait_vsync(self) -> None:
+        if self._vsync and self._have_SGI_video_sync and self._use_video_sync:
+            count = c_uint()
+            glxext_arb.glXGetVideoSyncSGI(byref(count))
+            glxext_arb.glXWaitVideoSyncSGI(2, (count.value + 1) % 2, byref(count))
+
+    def flip(self) -> None:
+        if not self.glx_window:
+            return
+
+        if self._vsync:
+            self._wait_vsync()
+
+        glx.glXSwapBuffers(self.x_display, self.glx_window)

pyglet/{gl → graphics/api/gl/xlib}/glx_info.py

@@ -2,16 +2,14 @@
 
 Usage::
 
-    from pyglet.gl import glx_info
+    from pyglet.graphics.api.core.current_context.info import platform_info
 
-    if glx_info.have_extension('GLX_NV_float_buffer'):
+    if platform_info.have_extension('GLX_NV_float_buffer'):
         # ...
 
-Or, if using more than one display::
+Or, if using more than one Window::
 
-    from pyglet.gl.glx_info import GLXInfo
-
-    info = GLXInfo(window._display)
+    info = window.context.info.platform_info
     if info.get_server_vendor() == 'ATI':
         # ...
 
@@ -22,7 +20,7 @@ from __future__ import annotations
 from ctypes import byref, c_int
 from typing import TYPE_CHECKING
 
-from pyglet.gl.glx import (
+from pyglet.libs.linux.glx.glx import (
     GLX_EXTENSIONS,
     GLX_VENDOR,
     GLX_VERSION,
@@ -36,22 +34,19 @@ from pyglet.gl.glx import (
 from pyglet.util import asstr
 
 if TYPE_CHECKING:
-    from pyglet.libs.x11.xlib import Display
+    from pyglet.libs.linux.x11 import xlib
 
 
-class GLXInfoException(Exception):  # noqa: D101, N818
+class GLXInfoException(Exception):  # noqa: N818
     pass
 
 
-class GLXInfo:  # noqa: D101
-    def __init__(self, display: Display | None = None) -> None:  # noqa: D107
+class GLXInfo:
+    def __init__(self, display: xlib.Display | None = None) -> None:
         # Set default display if not set
-        if display and not _glx_info.display:
-            _glx_info.set_display(display)
-
-        self.display = display
+        # if display and not _glx_info.display:
+        #     _glx_info.set_display(display)
 
-    def set_display(self, display: Display) -> None:
         self.display = display
 
     def check_display(self) -> None:
@@ -105,7 +100,7 @@ class GLXInfo:  # noqa: D101
         self.check_display()
         return asstr(glXGetClientString(self.display, GLX_EXTENSIONS)).split()
 
-    def get_extensions(self) -> list[str]:
+    def get_extensions(self, _context) -> list[str]:
         self.check_display()
         return asstr(glXQueryExtensionsString(self.display, 0)).split()
 
@@ -113,20 +108,20 @@ class GLXInfo:  # noqa: D101
         self.check_display()
         if not self.have_version(1, 1):
             return False
-        return extension in self.get_extensions()
+        return extension in self.get_extensions(None)
 
 
 # Single instance suitable for apps that use only a single display.
-_glx_info = GLXInfo()
-
-set_display = _glx_info.set_display
-check_display = _glx_info.check_display
-have_version = _glx_info.have_version
-get_server_vendor = _glx_info.get_server_vendor
-get_server_version = _glx_info.get_server_version
-get_server_extensions = _glx_info.get_server_extensions
-get_client_vendor = _glx_info.get_client_vendor
-get_client_version = _glx_info.get_client_version
-get_client_extensions = _glx_info.get_client_extensions
-get_extensions = _glx_info.get_extensions
-have_extension = _glx_info.have_extension
+# _glx_info = GLXInfo()
+#
+# set_display = _glx_info.set_display
+# check_display = _glx_info.check_display
+# have_version = _glx_info.have_version
+# get_server_vendor = _glx_info.get_server_vendor
+# get_server_version = _glx_info.get_server_version
+# get_server_extensions = _glx_info.get_server_extensions
+# get_client_vendor = _glx_info.get_client_vendor
+# get_client_version = _glx_info.get_client_version
+# get_client_extensions = _glx_info.get_client_extensions
+# get_extensions = _glx_info.get_extensions
+# have_extension = _glx_info.have_extension

pyglet/{gl → graphics/api/gl1}/gl_compat.py

@@ -8,8 +8,9 @@ from ctypes import (
     CFUNCTYPE, POINTER, Structure, c_byte, c_char, c_double, c_float,
     c_int, c_int64, c_short, c_ubyte, c_uint, c_uint64, c_ushort
 )
-from pyglet.gl.lib import link_GL as _link_function
-from pyglet.gl.lib import c_ptrdiff_t
+
+from pyglet.graphics.api.gl.lib import link_GL as _link_function
+from pyglet.graphics.api.gl.lib import c_ptrdiff_t
 
 class struct___GLsync(Structure):
     __slots__ = [