pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → 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.8 → 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.

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/graphics/shader.py

@@ -170,14 +170,14 @@ class Attribute:
         self.name = name
         self.location = location
         self.count = count
-
         self.gl_type = gl_type
-        self.c_type = _c_types[gl_type]
         self.normalize = normalize
 
-        self.align = sizeof(self.c_type)
-        self.size = count * self.align
-        self.stride = self.size
+        self.c_type = _c_types[gl_type]
+
+        self.element_size = sizeof(self.c_type)
+        self.byte_size = count * self.element_size
+        self.stride = self.byte_size
 
     def enable(self):
         """Enable the attribute."""
@@ -207,20 +207,16 @@ class Attribute:
         will be ``3 * 4 = 12``.
 
         :Parameters:
-            `buffer` : `AbstractMappable`
+            `buffer` : `AttributeBufferObject`
                 The buffer to map.
             `start` : int
                 Offset of the first vertex to map.
             `count` : int
                 Number of vertices to map
 
-        :rtype: `AbstractBufferRegion`
+        :rtype: `BufferObjectRegion`
         """
-        byte_start = self.stride * start
-        byte_size = self.stride * count
-        array_count = self.count * count
-        ptr_type = POINTER(self.c_type * array_count)
-        return buffer.get_region(byte_start, byte_size, ptr_type)
+        return buffer.get_region(start, count)
 
     def set_region(self, buffer, start, count, data):
         """Set the data over a region of the buffer.
@@ -234,11 +230,7 @@ class Attribute:
                 Number of vertices to set.
             `data` : A sequence of data components.
         """
-        byte_start = self.stride * start
-        byte_size = self.stride * count
-        array_count = self.count * count
-        data = (self.c_type * array_count)(*data)
-        buffer.set_data_region(data, byte_start, byte_size)
+        buffer.set_region(start, count, data)
 
     def __repr__(self):
         return f"Attribute(name='{self.name}', location={self.location}, count={self.count})"
@@ -682,6 +674,7 @@ class Shader:
     """
 
     def __init__(self, source_string: str, shader_type: str):
+        self._context = pyglet.gl.current_context
         self._id = None
         self.type = shader_type
 
@@ -697,6 +690,7 @@ class Shader:
         source_length = c_int(len(shader_source_utf8))
 
         shader_id = glCreateShader(shader_type)
+        self._id = shader_id
         glShaderSource(shader_id, 1, byref(source_buffer_pointer), source_length)
         glCompileShader(shader_id)
 
@@ -717,8 +711,6 @@ class Shader:
         elif _debug_gl_shaders:
             print(self._get_shader_log(shader_id))
 
-        self._id = shader_id
-
     @property
     def id(self):
         return self._id
@@ -729,8 +721,8 @@ class Shader:
         result_str = create_string_buffer(log_length.value)
         glGetShaderInfoLog(shader_id, log_length, None, result_str)
         if result_str.value:
-            return ("OpenGL returned the following message when compiling the '{0}' shader: "
-                    "\n{1}".format(self.type, result_str.value.decode('utf8')))
+            return (f"OpenGL returned the following message when compiling the "
+                    f"'{self.type}' shader: \n{result_str.value.decode('utf8')}")
         else:
             return f"{self.type.capitalize()} Shader '{shader_id}' compiled successfully."
 
@@ -743,16 +735,19 @@ class Shader:
         glGetShaderSource(shader_id, source_length, None, source_str)
         return source_str.value.decode('utf8')
 
-    def __del__(self):
-        try:
-            glDeleteShader(self._id)
-            if _debug_gl_shaders:
-                print(f"Destroyed {self.type} Shader '{self._id}'")
+    def delete(self):
+        glDeleteShader(self._id)
+        self._id = None
 
-        except Exception:
-            # Interpreter is shutting down,
-            # or Shader failed to compile.
-            pass
+    def __del__(self):
+        if self._id is not None:
+            try:
+                self._context.delete_shader(self._id)
+                if _debug_gl_shaders:
+                    print(f"Destroyed {self.type} Shader '{self._id}'")
+                self._id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     def __repr__(self):
         return "{0}(id={1}, type={2})".format(self.__class__.__name__, self.id, self.type)
@@ -764,6 +759,8 @@ class ShaderProgram:
     __slots__ = '_id', '_context', '_attributes', '_uniforms', '_uniform_blocks', '__weakref__'
 
     def __init__(self, *shaders: Shader):
+        self._id = None
+
         assert shaders, "At least one Shader object is required."
         self._id = _link_program(*shaders)
         self._context = pyglet.gl.current_context
@@ -807,13 +804,17 @@ class ShaderProgram:
     def __exit__(self, *_):
         glUseProgram(0)
 
+    def delete(self):
+        glDeleteProgram(self._id)
+        self._id = None
+
     def __del__(self):
-        try:
-            self._context.delete_shader_program(self.id)
-        except Exception:
-            # Interpreter is shutting down,
-            # or ShaderProgram failed to link.
-            pass
+        if self._id is not None:
+            try:
+                self._context.delete_shader_program(self._id)
+                self._id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     def __setitem__(self, key, value):
         try:
@@ -936,10 +937,10 @@ class ShaderProgram:
 class ComputeShaderProgram:
     """OpenGL Compute Shader Program"""
 
-    __slots__ = '_shader', '_id', '_context', '_uniforms', '_uniform_blocks', '__weakref__', 'limits'
-
     def __init__(self, source: str):
         """Create an OpenGL ComputeShaderProgram from source."""
+        self._id = None
+
         if not (gl_info.have_version(4, 3) or gl_info.have_extension("GL_ARB_compute_shader")):
             raise ShaderException("Compute Shader not supported. OpenGL Context version must be at least "
                                   "4.3 or higher, or 4.2 with the 'GL_ARB_compute_shader' extension.")
@@ -954,12 +955,10 @@ class ComputeShaderProgram:
         self._uniforms = _introspect_uniforms(self._id, True)
         self._uniform_blocks = _introspect_uniform_blocks(self)
 
-        self.limits = {
-            'work_group_count':       self._get_tuple(GL_MAX_COMPUTE_WORK_GROUP_COUNT),
-            'work_group_size':        self._get_tuple(GL_MAX_COMPUTE_WORK_GROUP_SIZE),
-            'work_group_invocations': self._get_value(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS),
-            'shared_memory_size':     self._get_value(GL_MAX_COMPUTE_SHARED_MEMORY_SIZE),
-        }
+        self.max_work_group_size = self._get_tuple(GL_MAX_COMPUTE_WORK_GROUP_SIZE)
+        self.max_work_group_count = self._get_tuple(GL_MAX_COMPUTE_WORK_GROUP_COUNT)
+        self.max_shared_memory_size = self._get_value(GL_MAX_COMPUTE_SHARED_MEMORY_SIZE)
+        self.max_work_group_invocations = self._get_value(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS)
 
     @staticmethod
     def _get_tuple(parameter: int):
@@ -1014,13 +1013,17 @@ class ComputeShaderProgram:
     def __exit__(self, *_):
         glUseProgram(0)
 
+    def delete(self):
+        glDeleteProgram(self._id)
+        self._id = None
+
     def __del__(self):
-        try:
-            self._context.delete_shader_program(self.id)
-        except Exception:
-            # Interpreter is shutting down,
-            # or ShaderProgram failed to link.
-            pass
+        if self._id is not None:
+            try:
+                self._context.delete_shader_program(self._id)
+                self._id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     def __setitem__(self, key, value):
         try:

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/graphics/vertexarray.py

@@ -27,10 +27,8 @@ class VertexArray:
         glBindVertexArray(0)
 
     def delete(self):
-        try:
-            glDeleteVertexArrays(1, self._id)
-        except Exception:
-            pass
+        glDeleteVertexArrays(1, self._id)
+        self._id = None
 
     __enter__ = bind
 
@@ -38,11 +36,12 @@ class VertexArray:
         glBindVertexArray(0)
 
     def __del__(self):
-        try:
-            self._context.delete_vao(self.id)
-        # Python interpreter is shutting down:
-        except ImportError:
-            pass
+        if self._id is not None:
+            try:
+                self._context.delete_vao(self.id)
+                self._id = None
+            except (ImportError, AttributeError):
+                pass  # Interpreter is shutting down
 
     def __repr__(self):
         return "{}(id={})".format(self.__class__.__name__, self._id.value)

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/graphics/vertexbuffer.py

@@ -11,6 +11,8 @@ the buffer.
 import sys
 import ctypes
 
+from functools import lru_cache
+
 import pyglet
 from pyglet.gl import *
 
@@ -98,36 +100,6 @@ class AbstractBuffer:
         raise NotImplementedError('abstract')
 
 
-class AbstractMappable:
-
-    def get_region(self, start, size, ptr_type):
-        """Map a region of the buffer into a ctypes array of the desired
-        type.  This region does not need to be unmapped, but will become
-        invalid if the buffer is resized.
-
-        Note that although a pointer type is required, an array is mapped.
-        For example::
-
-            get_region(0, ctypes.sizeof(c_int) * 20, ctypes.POINTER(c_int * 20))
-
-        will map bytes 0 to 80 of the buffer to an array of 20 ints.
-
-        Changes to the array may not be recognised until the region's
-        :py:meth:`AbstractBufferRegion.invalidate` method is called.
-
-        :Parameters:
-            `start` : int
-                Offset into the buffer to map from, in bytes
-            `size` : int
-                Size of the buffer region to map, in bytes
-            `ptr_type` : ctypes pointer type
-                Pointer type describing the array format to create
-
-        :rtype: :py:class:`AbstractBufferRegion`
-        """
-        raise NotImplementedError('abstract')
-
-
 class BufferObject(AbstractBuffer):
     """Lightweight representation of an OpenGL Buffer Object.
 
@@ -180,7 +152,8 @@ class BufferObject(AbstractBuffer):
 
     def map(self):
         glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        ptr = ctypes.cast(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY), ctypes.POINTER(ctypes.c_byte * self.size)).contents
+        ptr = ctypes.cast(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY),
+                          ctypes.POINTER(ctypes.c_byte * self.size)).contents
         return ptr
 
     def map_range(self, start, size, ptr_type):
@@ -191,21 +164,18 @@ class BufferObject(AbstractBuffer):
     def unmap(self):
         glUnmapBuffer(GL_ARRAY_BUFFER)
 
-    def __del__(self):
-        try:
-            if self.id is not None:
-                self._context.delete_buffer(self.id)
-        except:
-            pass
-
     def delete(self):
-        buffer_id = GLuint(self.id)
-        try:
-            glDeleteBuffers(1, buffer_id)
-        except Exception:
-            pass
+        glDeleteBuffers(1, self.id)
         self.id = None
 
+    def __del__(self):
+        if self.id is not None:
+            try:
+                self._context.delete_buffer(self.id)
+                self.id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
+
     def resize(self, size):
         # Map, create a copy, then reinitialize.
         temp = (ctypes.c_byte * size)()
@@ -222,27 +192,31 @@ class BufferObject(AbstractBuffer):
         return f"{self.__class__.__name__}(id={self.id}, size={self.size})"
 
 
-class MappableBufferObject(BufferObject, AbstractMappable):
+class AttributeBufferObject(BufferObject):
     """A buffer with system-memory backed store.
 
-    Updates to the data via `set_data`, `set_data_region` and `map` will be
-    held in local memory until `bind` is called.  The advantage is that fewer
-    OpenGL calls are needed, increasing performance.
-
-    There may also be less performance penalty for resizing this buffer.
-
-    Updates to data via :py:meth:`map` are committed immediately.
+    Updates to the data via `set_data` and `set_data_region` will be held
+    in local memory until `buffer_data` is called.  The advantage is that
+    fewer OpenGL calls are needed, which can increasing performance at the
+    expense of system memory.
     """
-    def __init__(self, size, usage=GL_DYNAMIC_DRAW):
-        super(MappableBufferObject, self).__init__(size, usage)
+
+    def __init__(self, size, attribute, usage=GL_DYNAMIC_DRAW):
+        super().__init__(size, usage)
+        self._size = size
         self.data = (ctypes.c_byte * size)()
         self.data_ptr = ctypes.addressof(self.data)
         self._dirty_min = sys.maxsize
         self._dirty_max = 0
 
-    def bind(self):
-        # Commit pending data
-        super(MappableBufferObject, self).bind()
+        self.attribute_stride = attribute.stride
+        self.attribute_count = attribute.count
+        self.attribute_ctype = attribute.c_type
+
+        self._array = self.get_region(0, size).array
+
+    def bind(self, target=GL_ARRAY_BUFFER):
+        super().bind(target)
         size = self._dirty_max - self._dirty_min
         if size > 0:
             if size == self.size:
@@ -252,28 +226,27 @@ class MappableBufferObject(BufferObject, AbstractMappable):
             self._dirty_min = sys.maxsize
             self._dirty_max = 0
 
-    def set_data(self, data):
-        super(MappableBufferObject, self).set_data(data)
-        ctypes.memmove(self.data, data, self.size)
-        self._dirty_min = 0
-        self._dirty_max = self.size
+    @lru_cache(maxsize=None)
+    def get_region(self, start, count):
+        byte_start = self.attribute_stride * start  # byte offset
+        byte_size = self.attribute_stride * count  # number of bytes
+        array_count = self.attribute_count * count  # number of values
 
-    def set_data_region(self, data, start, length):
-        ctypes.memmove(self.data_ptr + start, data, length)
-        self._dirty_min = min(start, self._dirty_min)
-        self._dirty_max = max(start + length, self._dirty_max)
+        ptr_type = ctypes.POINTER(self.attribute_ctype * array_count)
+        array = ctypes.cast(self.data_ptr + byte_start, ptr_type).contents
+        return BufferObjectRegion(self, byte_start, byte_start + byte_size, array)
 
-    def map(self, invalidate=False):
-        self._dirty_min = 0
-        self._dirty_max = self.size
-        return self.data
+    def set_region(self, start, count, data):
+        byte_start = self.attribute_stride * start  # byte offset
+        byte_size = self.attribute_stride * count  # number of bytes
 
-    def unmap(self):
-        pass
+        array_start = start * self.attribute_count
+        array_end = count * self.attribute_count + array_start
 
-    def get_region(self, start, size, ptr_type):
-        array = ctypes.cast(self.data_ptr + start, ptr_type).contents
-        return BufferObjectRegion(self, start, start + size, array)
+        self._array[array_start:array_end] = data
+
+        self._dirty_min = min(self._dirty_min, byte_start)
+        self._dirty_max = max(self._dirty_max, byte_start + byte_size)
 
     def resize(self, size):
         data = (ctypes.c_byte * size)()
@@ -289,6 +262,9 @@ class MappableBufferObject(BufferObject, AbstractMappable):
         self._dirty_min = sys.maxsize
         self._dirty_max = 0
 
+        self._array = self.get_region(0, size).array
+        self.get_region.cache_clear()
+
 
 class BufferObjectRegion:
     """A mapped region of a MappableBufferObject."""