PyOpenGL 4.0.0a9__tar.gz → 4.0.0b1__tar.gz

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/OpenGL/Tk/context.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
+from OpenGL import dispatch
 from OpenGL.Tk.attributes import ContextAttributes
 from OpenGL.Tk.errors import TkContextError
 
@@ -99,4 +100,11 @@ def createContext(
             % (system, ', '.join(sorted(IMPLEMENTATIONS))))
     moduleName, className = named
     module = __import__(moduleName, {}, {}, [className])
-    return getattr(module, className)(widget, attributes)
+    made = getattr(module, className)(widget, attributes)
+    if attributes.share is not None:
+        # The driver numbers the two contexts' buffers, textures and programs
+        # together; PyOpenGL is told so that a ``VBO`` made in one is deleted
+        # from the other.
+        dispatch.share_context(
+            made.handle, getattr(attributes.share, 'handle', attributes.share))
+    return made

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/OpenGL/WGL/offscreen.py

@@ -575,6 +575,12 @@ class OffscreenContext:
                     self.width, self.height)
                 self.context = self._create_context(
                     debug, forward_compatible, share)
+                if share:
+                    from OpenGL import dispatch
+
+                    # PyOpenGL is told the two contexts number their buffers,
+                    # textures and programs together.
+                    dispatch.share_context(self.context, share)
         except BaseException:
             # Release what was created, so an application that tries this and
             # falls back does not leak a pbuffer per attempt.

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/OpenGL/dispatch.py

@@ -51,6 +51,7 @@ __all__ = [
     'make_current',
     'forget_context',
     'context_identity',
+    'share_context',
     'reclaim_retired',
     'set_error_checking',
     'error_checking_mode',
@@ -335,6 +336,32 @@ def context_identity():
     return identity
 
 
+def share_context(handle, with_handle):
+    """Say that the context at ``handle`` shares its objects with the one at ``with_handle``.
+
+    Contexts made to share (the ``share`` argument of ``glfwCreateWindow`` and
+    of ``eglCreateContext``, ``wglShareLists``) number their
+    buffers, textures, samplers and programs together: a name made in one is
+    the same object in the others.  Afterwards :func:`context_identity` answers
+    the same object whichever of them is current, so the deleter of a buffer
+    made on a loading thread's context runs from the rendering thread's, and
+    the other way round.  Objects that are not shared, such as vertex arrays,
+    framebuffers and the state of the context, stay the one context's.
+
+    Call it after the context is made, from any thread.  The group outlives
+    each member: :func:`forget_context` on one leaves the others as they were.
+    """
+    shared = _as_address(handle)
+    owner = _as_address(with_handle)
+    if not shared or not owner or shared == owner:
+        return
+    with _identities_lock:
+        identity = _identities.get(owner)
+        if identity is None:
+            identity = _identities[owner] = ContextIdentity(owner)
+        _identities[shared] = identity
+
+
 def _forget_context_data(handle):
     """Drop the values cached about a context, as well as its dispatch table.
 

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/OpenGL/version.py

@@ -1,3 +1,3 @@
 """Declares the current version for use in setuptools and the like"""
 
-__version__ = "4.0.0a9"
+__version__ = "4.0.0b1"

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL
-Version: 4.0.0a9
+Version: 4.0.0b1
 Summary: Standard OpenGL bindings for Python
 Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
 License-Expression: BSD-3-Clause

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/PyOpenGL.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyOpenGL
-Version: 4.0.0a9
+Version: 4.0.0b1
 Summary: Standard OpenGL bindings for Python
 Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
 License-Expression: BSD-3-Clause

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/tests/glcontext.py

@@ -159,6 +159,14 @@ class Context(object):
         with Context(profile='core', gl_version=(3, 3)) as context:
             ...
 
+    ``share_with`` is another :class:`Context`: the new one is created to share
+    its buffers, textures and programs with that one, as ``glfwCreateWindow``'s
+    ``share`` argument or ``eglCreateContext``'s ``share_context`` does.  It
+    skips on a backend that cannot make a shared context.  The harness does not
+    tell PyOpenGL about the sharing -- that is
+    :func:`OpenGL.dispatch.share_context`, which a case calls where it means a
+    program to have done so.
+
     Raises :exc:`unittest.SkipTest` where the machine cannot serve the
     request -- which is what the backends raise, and what pytest and unittest
     both read as a skip -- including where the context that came back is older
@@ -169,8 +177,11 @@ class Context(object):
     #: the entry-point module each API's version string is read through.
     _API_MODULES: ClassVar[dict] = {'gl': 'OpenGL.GL', 'gles': 'OpenGL.GLES2', 'es': 'OpenGL.GLES2'}
 
-    def __init__(self, **requirements):
-        namespace = dict(requirements, runTest=lambda self: None)
+    def __init__(self, share_with=None, **requirements):
+        namespace = dict(
+            requirements, runTest=lambda self: None,
+            share_with=None if share_with is None else share_with._case,
+        )
         self._case = type(
             'StandaloneContext', (pick_backend(), ContextTestCase), namespace,
         )('runTest')
@@ -359,6 +370,11 @@ class ContextTestCase(unittest.TestCase):
     #: module exporting the indexed glGetStringi query (GL / GLES3); subclass.
     gl3 = None
 
+    #: The case whose context this one is created to share objects with, or
+    #: ``None``.  Set by :class:`Context`; a backend that can share reads it
+    #: through :meth:`_sharing`.
+    share_with = None
+
     # --- backend hooks (a mixin must implement these) --------------------
     def _create_context(self):
         raise NotImplementedError(
@@ -369,6 +385,27 @@ class ContextTestCase(unittest.TestCase):
     def _swap(self):
         raise NotImplementedError
 
+    def _native_context(self):
+        """What the toolkit takes as the context to share with (a GLFW window,
+        an EGL context handle).  A backend that can make a shared context
+        defines this and reads :meth:`_sharing` where it creates one."""
+        raise NotImplementedError
+
+    def _sharing(self):
+        """The native context to create this one sharing with, or ``None``.
+
+        Skips where the backend has no :meth:`_native_context`, which is how a
+        backend says it cannot make a shared context.
+        """
+        if self.share_with is None:
+            return None
+        try:
+            return self.share_with._native_context()
+        except NotImplementedError:
+            self.skipTest(
+                'the %s backend cannot make a context that shares with another'
+                % (getattr(self, 'backend_name', type(self).__name__),))
+
     def _make_current(self):
         """Make this instance's context current on the calling thread.
 
@@ -398,6 +435,7 @@ class ContextTestCase(unittest.TestCase):
         from OpenGL import error
 
         error.end_abandoned_block()
+        self._sharing()  # skips on a backend that cannot honour share_with
         self._create_context()
 
     # --- giving a context back -------------------------------------------

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/tests/glcontext_egl.py

@@ -244,7 +244,8 @@ class EGLDeviceBackend(object):
         # a skip and not a failure.
         try:
             context = eglCreateContext(
-                display, config[0], EGL_NO_CONTEXT, context_attrs)
+                display, config[0], self._sharing() or EGL_NO_CONTEXT,
+                context_attrs)
         except EGLError as err:
             context = EGL_NO_CONTEXT
             reason = str(err.err)
@@ -272,6 +273,9 @@ class EGLDeviceBackend(object):
         self._egl_context = context
         self._egl_surface = surface
 
+    def _native_context(self):
+        return self._egl_context
+
     def _swap(self):
         # Offscreen pbuffer: nothing to present.  Tests read back with
         # glReadPixels, which implicitly finishes the pipeline.

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/tests/glcontext_glfw.py

@@ -94,7 +94,8 @@ class GLFWBackend(object):
 
         try:
             window = glfw.create_window(
-                self.width, self.height, self._window_title(), None, None
+                self.width, self.height, self._window_title(), None,
+                self._sharing(),
             )
         except glfw.GLFWError as err:
             window = None
@@ -120,6 +121,9 @@ class GLFWBackend(object):
             getattr(self, 'profile', ''),
         )
 
+    def _native_context(self):
+        return self._window
+
     def _swap(self):
         if self._window is not None:
             glfw.swap_buffers(self._window)

{pyopengl-4.0.0a9 → pyopengl-4.0.0b1}/tests/test_wgl_offscreen.py

@@ -434,3 +434,55 @@ class TestSayingWhetherItCanRunAtAll:
         with pytest.raises(offscreen.WGLError) as raised:
             offscreen.OffscreenContext(width=size[0], height=size[1])
         assert 'cannot render at' in str(raised.value)
+
+
+class TestAnOffscreenContextMadeToShare:
+    """``share=`` names the context whose buffers, textures and programs the
+    new one uses.  PyOpenGL is told, and a ``VBO`` made in either is deleted
+    from the other."""
+
+    @pytest.fixture
+    def pair(self):
+        missing = offscreen.available()
+        if missing:
+            pytest.skip('no offscreen WGL here: %s missing' % (', '.join(missing),))
+        first = offscreen.OffscreenContext(width=64, height=48)
+        try:
+            second = offscreen.OffscreenContext(
+                width=64, height=48, share=first.context)
+        except BaseException:
+            first.release()
+            raise
+        try:
+            yield first, second
+        finally:
+            second.release()
+            first.release()
+
+    def test_the_contexts_have_one_identity(self, pair):
+        from OpenGL import dispatch
+
+        first, second = pair
+        first.make_current()
+        owner = dispatch.context_identity()
+        second.make_current()
+        assert dispatch.context_identity() is owner
+
+    def test_a_buffer_dropped_while_the_other_is_current_is_deleted(self, pair):
+        import gc
+
+        import numpy as np
+        from OpenGL.arrays import vbo
+        from OpenGL.GL import glIsBuffer
+
+        first, second = pair
+        first.make_current()
+        buffer = vbo.VBO(np.zeros((3, 3), 'f'))
+        buffer.bind()
+        buffer.unbind()
+        name = int(buffer)
+        assert glIsBuffer(name)
+        second.make_current()
+        del buffer
+        gc.collect()
+        assert not glIsBuffer(name)