pyglet 2.0.9__zip → 2.0.10__zip

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/gl/base.py

@@ -1,4 +1,10 @@
+import weakref
+
 from enum import Enum
+import threading
+from typing import Tuple
+
+import pyglet
 
 from pyglet import gl
 from pyglet.gl import gl_info
@@ -162,7 +168,7 @@ class Config:
 
 
 class CanvasConfig(Config):
-    """OpenGL configuration for a particular canvas.
+    """An OpenGL configuration for a particular canvas.
 
     Use `Config.match` to obtain an instance of this class.
 
@@ -204,16 +210,16 @@ class CanvasConfig(Config):
 
 class ObjectSpace:
     def __init__(self):
-        # Textures and buffers scheduled for deletion
-        # the next time this object space is active.
+        # Objects scheduled for deletion the next time this object space is active.
         self.doomed_textures = []
         self.doomed_buffers = []
-        self.doomed_vaos = []
         self.doomed_shader_programs = []
+        self.doomed_shaders = []
+        self.doomed_renderbuffers = []
 
 
 class Context:
-    """OpenGL context for drawing.
+    """An OpenGL context for drawing.
 
     Use `CanvasConfig.create_context` to create a context.
 
@@ -231,14 +237,25 @@ class Context:
         self.context_share = context_share
         self.canvas = None
 
+        self.doomed_vaos = []
+        self.doomed_framebuffers = []
+
         if context_share:
             self.object_space = context_share.object_space
         else:
             self.object_space = ObjectSpace()
 
+        self._cached_programs = weakref.WeakValueDictionary()
+
     def __repr__(self):
         return f"{self.__class__.__name__}(id={id(self)}, share={self.context_share})"
 
+    def __enter__(self):
+        self.set_current()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+
     def attach(self, canvas):
         if self.canvas is not None:
             self.detach()
@@ -263,28 +280,49 @@ class Context:
             self._info = gl_info.GLInfo()
             self._info.set_active_context()
 
-        # Release Textures, Buffers, and VAOs on this context scheduled for
-        # deletion. Note that the garbage collector may introduce a race
-        # condition, so operate on a copy, and clear the list afterwards.
         if self.object_space.doomed_textures:
-            textures = self.object_space.doomed_textures[:]
-            textures = (gl.GLuint * len(textures))(*textures)
-            gl.glDeleteTextures(len(textures), textures)
-            self.object_space.doomed_textures.clear()
+            self._delete_objects(self.object_space.doomed_textures, gl.glDeleteTextures)
         if self.object_space.doomed_buffers:
-            buffers = self.object_space.doomed_buffers[:]
-            buffers = (gl.GLuint * len(buffers))(*buffers)
-            gl.glDeleteBuffers(len(buffers), buffers)
-            self.object_space.doomed_buffers.clear()
-        if self.object_space.doomed_vaos:
-            vaos = self.object_space.doomed_vaos[:]
-            vaos = (gl.GLuint * len(vaos))(*vaos)
-            gl.glDeleteVertexArrays(len(vaos), vaos)
-            self.object_space.doomed_vaos.clear()
+            self._delete_objects(self.object_space.doomed_buffers, gl.glDeleteBuffers)
         if self.object_space.doomed_shader_programs:
-            for program_id in self.object_space.doomed_shader_programs:
-                gl.glDeleteProgram(program_id)
-            self.object_space.doomed_shader_programs.clear()
+            self._delete_objects_one_by_one(self.object_space.doomed_shader_programs,
+                                            gl.glDeleteProgram)
+        if self.object_space.doomed_shaders:
+            self._delete_objects_one_by_one(self.object_space.doomed_shaders, gl.glDeleteShader)
+        if self.object_space.doomed_renderbuffers:
+            self._delete_objects(self.object_space.doomed_renderbuffers, gl.glDeleteRenderbuffers)
+
+        if self.doomed_vaos:
+            self._delete_objects(self.doomed_vaos, gl.glDeleteVertexArrays)
+        if self.doomed_framebuffers:
+            self._delete_objects(self.doomed_framebuffers, gl.glDeleteFramebuffers)
+
+    # For the functions below:
+    # The garbage collector introduces a race condition.
+    # The provided list might be appended to (and only appended to) while this
+    # method runs, as it's a `doomed_*` list either on the context or its
+    # object space. If `count` wasn't stored in a local, this method might
+    # leak objects.
+    def _delete_objects(self, list_, deletion_func):
+        """Release all OpenGL objects in the given list using the supplied
+        deletion function with the signature ``(GLuint count, GLuint *names)``.
+        """
+        count = len(list_)
+        to_delete = list_[:count]
+        del list_[:count]
+
+        deletion_func(count, (gl.GLuint * count)(*to_delete))
+
+    def _delete_objects_one_by_one(self, list_, deletion_func):
+        """Similar to ``_delete_objects``, but assumes the deletion functions's
+        signature to be ``(GLuint name)``, calling it once for each object.
+        """
+        count = len(list_)
+        to_delete = list_[:count]
+        del list_[:count]
+
+        for name in to_delete:
+            deletion_func(gl.GLuint(name))
 
     def destroy(self):
         """Release the context.
@@ -304,26 +342,80 @@ class Context:
             if gl._shadow_window is not None:
                 gl._shadow_window.switch_to()
 
+    def _safe_to_operate_on_object_space(self):
+        """Return whether it is safe to interact with this context's object
+        space.
+
+        This is considered to be the case if the currently active context's
+        object space is the same as this context's object space and this
+        method is called from the main thread.
+        """
+        return (
+            self.object_space is gl.current_context.object_space and
+            threading.current_thread() is threading.main_thread()
+        )
+
+    def _safe_to_operate_on(self):
+        """Return whether it is safe to interact with this context.
+
+        This is considered to be the case if it's the current context and this
+        method is called from the main thread.
+        """
+        return gl.current_context is self and threading.current_thread() is threading.main_thread()
+
+    def create_program(self, *sources: Tuple[str, str], program_class=None):
+        """Create a ShaderProgram from OpenGL GLSL source.
+
+        This is a convenience method that takes one or more tuples of
+        (source_string, shader_type), and returns a
+        :py:class:`~pyglet.graphics.shader.ShaderProgram` instance.
+
+        `source_string` is OpenGL GLSL source code as a str, and `shader_type`
+        is the OpenGL shader type, such as "vertex" or "fragment". See
+        :py:class:`~pyglet.graphics.shader.Shader` for more information.
+
+        .. note:: This method is cached. Given the same shader sources, the
+                  same ShaderProgram instance will be returned. For more
+                  control over the ShaderProgram lifecycle, it is recommended
+                  to manually create Shaders and link ShaderPrograms.
+
+        .. versionadded:: 2.0.10
+        """
+        if program := self._cached_programs.get(str(sources)):
+            return program
+
+        program_class = program_class or pyglet.graphics.shader.ShaderProgram
+        shaders = (pyglet.graphics.shader.Shader(src, srctype) for (src, srctype) in sources)
+        program = program_class(*shaders)
+        self._cached_programs[str(sources)] = program
+
+        return program
+
     def delete_texture(self, texture_id):
-        """Safely delete a Texture belonging to this context.
+        """Safely delete a Texture belonging to this context's object space.
 
-        Usually, the Texture is released immediately using
-        ``glDeleteTextures``, however if another context that does not share
-        this context's object space is currently active, the deletion will
-        be deferred until an appropriate context is activated.
+        This method will delete the texture immediately via
+        ``glDeleteTextures`` if the current context's object space is the same
+        as this context's object space and it is called from the main thread.
+
+        Otherwise, the texture will only be marked for deletion, postponing
+        it until any context with the same object space becomes active again.
+
+        This makes it safe to call from anywhere, including other threads.
 
         :Parameters:
             `texture_id` : int
                 The OpenGL name of the Texture to delete.
 
         """
-        if self.object_space is gl.current_context.object_space:
+        if self._safe_to_operate_on_object_space():
             gl.glDeleteTextures(1, gl.GLuint(texture_id))
         else:
             self.object_space.doomed_textures.append(texture_id)
 
     def delete_buffer(self, buffer_id):
-        """Safely delete a Buffer object belonging to this context.
+        """Safely delete a Buffer object belonging to this context's object
+        space.
 
         This method behaves similarly to `delete_texture`, though for
         ``glDeleteBuffers`` instead of ``glDeleteTextures``.
@@ -334,16 +426,73 @@ class Context:
 
         .. versionadded:: 1.1
         """
-        if self.object_space is gl.current_context.object_space and False:
+        if self._safe_to_operate_on_object_space():
             gl.glDeleteBuffers(1, gl.GLuint(buffer_id))
         else:
             self.object_space.doomed_buffers.append(buffer_id)
 
+    def delete_shader_program(self, program_id):
+        """Safely delete a Shader Program belonging to this context's
+        object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteProgram`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `program_id` : int
+                The OpenGL name of the Shader Program to delete.
+
+        .. versionadded:: 2.0
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteProgram(gl.GLuint(program_id))
+        else:
+            self.object_space.doomed_shader_programs.append(program_id)
+
+    def delete_shader(self, shader_id):
+        """Safely delete a Shader belonging to this context's object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteShader`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `shader_id` : int
+                The OpenGL name of the Shader to delete.
+
+        .. versionadded:: 2.0.10
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteShader(gl.GLuint(shader_id))
+        else:
+            self.object_space.doomed_shaders.append(shader_id)
+
+    def delete_renderbuffer(self, rbo_id):
+        """Safely delete a Renderbuffer Object belonging to this context's
+        object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteRenderbuffers`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `rbo_id` : int
+                The OpenGL name of the Shader Program to delete.
+
+        .. versionadded:: 2.0.10
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteRenderbuffers(1, gl.GLuint(rbo_id))
+        else:
+            self.object_space.doomed_renderbuffers.append(rbo_id)
+
     def delete_vao(self, vao_id):
         """Safely delete a Vertex Array Object belonging to this context.
 
-        This method behaves similarly to `delete_texture`, though for
-        ``glDeleteVertexArrays`` instead of ``glDeleteTextures``.
+        If this context is not the current context or this method is not
+        called from the main thread, its deletion will be postponed until
+        this context is next made active again.
+
+        Otherwise, this method will immediately delete the VAO via
+        ``glDeleteVertexArrays``.
 
         :Parameters:
             `vao_id` : int
@@ -351,27 +500,27 @@ class Context:
 
         .. versionadded:: 2.0
         """
-        if gl.current_context and self.object_space is gl.current_context.object_space and False:
+        if self._safe_to_operate_on():
             gl.glDeleteVertexArrays(1, gl.GLuint(vao_id))
         else:
-            self.object_space.doomed_vaos.append(vao_id)
+            self.doomed_vaos.append(vao_id)
 
-    def delete_shader_program(self, program_id):
-        """Safely delete a Shader Program belonging to this context.
+    def delete_framebuffer(self, fbo_id):
+        """Safely delete a Framebuffer Object belonging to this context.
 
-        This method behaves similarly to `delete_texture`, though for
-        ``glDeleteProgram`` instead of ``glDeleteTextures``.
+        This method behaves similarly to `delete_vao`, though for
+        ``glDeleteFramebuffers`` instead of ``glDeleteVertexArrays``.
 
         :Parameters:
-            `program_id` : int
-                The OpenGL name of the Shader Program to delete.
+            `fbo_id` : int
+                The OpenGL name of the Framebuffer Object to delete.
 
-        .. versionadded:: 2.0
+        .. versionadded:: 2.0.10
         """
-        if gl.current_context is self:
-            gl.glDeleteProgram(program_id)
+        if self._safe_to_operate_on():
+            gl.glDeleteFramebuffers(1, gl.GLuint(fbo_id))
         else:
-            self.object_space.doomed_shader_programs.append(program_id)
+            self.doomed_framebuffers.append(fbo_id)
 
     def get_info(self):
         """Get the OpenGL information for this context.

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/gl/gl_info.py

@@ -63,10 +63,12 @@ class GLInfo:
 
         This method is called automatically for the default context.
         """
-        from pyglet.gl.gl import glGetString, glGetStringi, GL_NUM_EXTENSIONS
-
         self._have_context = True
+
         if not self._have_info:
+
+            from pyglet.gl.gl import glGetString, glGetStringi, GL_NUM_EXTENSIONS
+
             self.vendor = asstr(cast(glGetString(GL_VENDOR), c_char_p).value)
             self.renderer = asstr(cast(glGetString(GL_RENDERER), c_char_p).value)
             self.version = asstr(cast(glGetString(GL_VERSION), c_char_p).value)

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/gl/lib.py

@@ -62,8 +62,7 @@ def errcheck(result, func, arguments):
             print(name)
 
     from pyglet import gl
-    context = gl.current_context
-    if not context:
+    if not gl.current_context:
         raise GLException('No GL context; create a Window first')
     error = gl.glGetError()
     if error:

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/gl/win32.py

@@ -68,12 +68,12 @@ class Win32Config(Config):
         if pf:
             return [Win32CanvasConfig(canvas, pf, self)]
         else:
-            return []                    
+            return []
 
     def _get_arb_pixel_format_matching_configs(self, canvas):
         """Get configs using the WGL_ARB_pixel_format extension.
         This method assumes a (dummy) GL context is already created."""
-        
+
         # Check for required extensions        
         if self.sample_buffers or self.samples:
             if not gl_info.have_extension('GL_ARB_multisample'):
@@ -85,7 +85,7 @@ class Win32Config(Config):
             attr = Win32CanvasConfigARB.attribute_ids.get(name, None)
             if attr and value is not None:
                 attrs.extend([attr, int(value)])
-        attrs.append(0)        
+        attrs.append(0)
         attrs = (c_int * len(attrs))(*attrs)
 
         pformats = (c_int * 16)()
@@ -98,7 +98,7 @@ class Win32Config(Config):
 
 class Win32CanvasConfig(CanvasConfig):
     def __init__(self, canvas, pf, config):
-        super(Win32CanvasConfig, self).__init__(canvas, config)
+        super().__init__(canvas, config)
         self._pf = pf
         self._pfd = PIXELFORMATDESCRIPTOR()
 
@@ -153,14 +153,14 @@ class Win32CanvasConfigARB(CanvasConfig):
     }
 
     def __init__(self, canvas, pf, config):
-        super(Win32CanvasConfigARB, self).__init__(canvas, config)
+        super().__init__(canvas, config)
         self._pf = pf
-        
+
         names = list(self.attribute_ids.keys())
         attrs = list(self.attribute_ids.values())
         attrs = (c_int * len(attrs))(*attrs)
         values = (c_int * len(attrs))()
-        
+
         wglext_arb.wglGetPixelFormatAttribivARB(canvas.hdc, pf, 0, len(attrs), attrs, values)
 
         for name, value in zip(names, values):
@@ -182,35 +182,21 @@ class Win32CanvasConfigARB(CanvasConfig):
         _gdi32.SetPixelFormat(canvas.hdc, self._pf, None)
 
 
-class Win32Context(Context):
+class _BaseWin32Context(Context):
     def __init__(self, config, share):
-        super(Win32Context, self).__init__(config, share)
+        super().__init__(config, share)
         self._context = None
 
-    def attach(self, canvas):
-        super(Win32Context, self).attach(canvas)
-
-        if not self._context:
-            self.config._set_pixel_format(canvas)
-            self._context = wgl.wglCreateContext(canvas.hdc)
-
-        share = self.context_share
-        if share:
-            if not share.canvas:
-                raise RuntimeError('Share context has no canvas.')
-            if not wgl.wglShareLists(share._context, self._context):
-                raise gl.ContextException('Unable to share contexts.')
-
     def set_current(self):
         if self._context is not None and self != gl.current_context:
             wgl.wglMakeCurrent(self.canvas.hdc, self._context)
-        super(Win32Context, self).set_current()
+        super().set_current()
 
     def detach(self):
         if self.canvas:
             wgl.wglDeleteContext(self._context)
             self._context = None
-        super(Win32Context, self).detach()
+        super().detach()
 
     def flip(self):
         _gdi32.SwapBuffers(self.canvas.hdc)
@@ -224,9 +210,23 @@ class Win32Context(Context):
             wglext_arb.wglSwapIntervalEXT(int(vsync))
 
 
-class Win32ARBContext(Win32Context):
-    def __init__(self, config, share):
-        super(Win32ARBContext, self).__init__(config, share)
+class Win32Context(_BaseWin32Context):
+    def attach(self, canvas):
+        super().attach(canvas)
+
+        if not self._context:
+            self.config._set_pixel_format(canvas)
+            self._context = wgl.wglCreateContext(canvas.hdc)
+
+        share = self.context_share
+        if share:
+            if not share.canvas:
+                raise RuntimeError('Share context has no canvas.')
+            if not wgl.wglShareLists(share._context, self._context):
+                raise gl.ContextException('Unable to share contexts.')
+
+
+class Win32ARBContext(_BaseWin32Context):
 
     def attach(self, canvas):
         share = self.context_share
@@ -244,7 +244,7 @@ class Win32ARBContext(Win32Context):
         if self.config.forward_compatible:
             flags |= wglext_arb.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
         if self.config.debug:
-            flags |= wglext_arb.WGL_DEBUG_BIT_ARB
+            flags |= wglext_arb.WGL_CONTEXT_DEBUG_BIT_ARB
         if flags:
             attribs.extend([wglext_arb.WGL_CONTEXT_FLAGS_ARB, flags])
         attribs.append(0)
@@ -252,4 +252,4 @@ class Win32ARBContext(Win32Context):
 
         self.config._set_pixel_format(canvas)
         self._context = wglext_arb.wglCreateContextAttribsARB(canvas.hdc, share, attribs)
-        super(Win32ARBContext, self).attach(canvas)
+        super().attach(canvas)

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/graphics/__init__.py

@@ -55,10 +55,11 @@ def draw(size, mode, **data):
         assert size == len(array) // attribute.count, 'Data for %s is incorrect length' % fmt
 
         buffer = BufferObject(size * attribute.stride)
-        attribute.set_region(buffer, 0, size, array)
+        data = (attribute.c_type * len(array))(*array)
+        buffer.set_data(data)
+
         attribute.enable()
         attribute.set_pointer(buffer.ptr)
-
         buffers.append(buffer)      # Don't garbage collect it.
 
     glDrawArrays(mode, 0, size)
@@ -108,10 +109,12 @@ def draw_indexed(size, mode, indices, **data):
         assert size == len(array) // attribute.count, 'Data for %s is incorrect length' % fmt
 
         buffer = BufferObject(size * attribute.stride)
-        attribute.set_region(buffer, 0, size, array)
+        data = (attribute.c_type * len(array))(*array)
+        buffer.set_data(data)
+
         attribute.enable()
         attribute.set_pointer(buffer.ptr)
-        buffers.append(buffer)
+        buffers.append(buffer)      # Don't garbage collect it.
 
     if size <= 0xff:
         index_type = GL_UNSIGNED_BYTE
@@ -188,24 +191,9 @@ def get_default_batch():
         return pyglet.gl.current_context.pyglet_graphics_default_batch
 
 
-def get_default_group():
-    try:
-        return pyglet.gl.current_context.pyglet_graphics_default_group
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_graphics_default_group = ShaderGroup(get_default_shader())
-        return pyglet.gl.current_context.pyglet_graphics_default_group
-
-
 def get_default_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_graphics_default_shader
-    except AttributeError:
-        _default_vert_shader = pyglet.graphics.shader.Shader(_vertex_source, 'vertex')
-        _default_frag_shader = pyglet.graphics.shader.Shader(_fragment_source, 'fragment')
-        default_shader_program = pyglet.graphics.shader.ShaderProgram(_default_vert_shader, _default_frag_shader)
-        pyglet.gl.current_context.pyglet_graphics_default_shader = default_shader_program
-        return pyglet.gl.current_context.pyglet_graphics_default_shader
-
+    return pyglet.gl.current_context.create_program((_vertex_source, 'vertex'),
+                                                    (_fragment_source, 'fragment'))
 
 class Batch:
     """Manage a collection of drawables for batched rendering.