pyglet 2.0.8__zip → 2.0.10__zip

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

@@ -23,11 +23,9 @@ primitives of the same OpenGL primitive mode.
 
 import ctypes
 
-import pyglet
-
 from pyglet.gl import *
 from pyglet.graphics import allocation, shader, vertexarray
-from pyglet.graphics.vertexbuffer import BufferObject, MappableBufferObject
+from pyglet.graphics.vertexbuffer import BufferObject, AttributeBufferObject
 
 
 def _nearest_pow2(v):
@@ -66,23 +64,39 @@ _gl_types = {
 }
 
 
+def _make_attribute_property(name):
+
+    def _attribute_getter(self):
+        attribute = self.domain.attribute_names[name]
+        region = attribute.buffer.get_region(self.start, self.count)
+        region.invalidate()
+        return region.array
+
+    def _attribute_setter(self, data):
+        attribute = self.domain.attribute_names[name]
+        attribute.buffer.set_region(self.start, self.count, data)
+
+    return property(_attribute_getter, _attribute_setter)
+
+
+
 class VertexDomain:
     """Management of a set of vertex lists.
 
     Construction of a vertex domain is usually done with the
     :py:func:`create_domain` function.
     """
-    version = 0
     _initial_count = 16
 
     def __init__(self, program, attribute_meta):
-        self.program = program
+        self.program = program          # Needed a reference for migration
         self.attribute_meta = attribute_meta
         self.allocator = allocation.Allocator(self._initial_count)
-        self.vao = vertexarray.VertexArray()
 
-        self.attributes = []
-        self.buffer_attributes = []  # list of (buffer, attributes)
+        self.attribute_names = {}       # name: attribute
+        self.buffer_attributes = []     # list of (buffer, attributes)
+
+        self._property_dict = {}        # name: property(_getter, _setter)
 
         for name, meta in attribute_meta.items():
             assert meta['format'][0] in _gl_types, f"'{meta['format']}' is not a valid atrribute format for '{name}'."
@@ -91,27 +105,27 @@ class VertexDomain:
             gl_type = _gl_types[meta['format'][0]]
             normalize = 'n' in meta['format']
             attribute = shader.Attribute(name, location, count, gl_type, normalize)
-            self.attributes.append(attribute)
+            self.attribute_names[attribute.name] = attribute
 
             # Create buffer:
-            attribute.buffer = MappableBufferObject(attribute.stride * self.allocator.capacity)
-            attribute.buffer.element_size = attribute.stride
-            attribute.buffer.attributes = (attribute,)
+            attribute.buffer = AttributeBufferObject(attribute.stride * self.allocator.capacity, attribute)
+
             self.buffer_attributes.append((attribute.buffer, (attribute,)))
 
-        # Create named attributes for each attribute
-        self.attribute_names = {}
-        for attribute in self.attributes:
-            self.attribute_names[attribute.name] = attribute
+            # Create custom property to be used in the VertexList:
+            self._property_dict[attribute.name] = _make_attribute_property(name)
 
-    def __del__(self):
-        # Break circular refs that Python GC seems to miss even when forced
-        # collection.
-        for attribute in self.attributes:
-            try:
-                del attribute.buffer
-            except AttributeError:
-                pass
+        # Make a custom VertexList class w/ properties for each attribute in the ShaderProgram:
+        self._vertexlist_class = type("VertexList", (VertexList,), self._property_dict)
+
+        self.vao = vertexarray.VertexArray()
+        self.vao.bind()
+        for buffer, attributes in self.buffer_attributes:
+            buffer.bind()
+            for attribute in attributes:
+                attribute.enable()
+                attribute.set_pointer(buffer.ptr)
+        self.vao.unbind()
 
     def safe_alloc(self, count):
         """Allocate vertices, resizing the buffers if necessary."""
@@ -119,9 +133,8 @@ class VertexDomain:
             return self.allocator.alloc(count)
         except allocation.AllocatorMemoryException as e:
             capacity = _nearest_pow2(e.requested_capacity)
-            self.version += 1
             for buffer, _ in self.buffer_attributes:
-                buffer.resize(capacity * buffer.element_size)
+                buffer.resize(capacity * buffer.attribute_stride)
             self.allocator.set_capacity(capacity)
             return self.allocator.alloc(count)
 
@@ -131,9 +144,8 @@ class VertexDomain:
             return self.allocator.realloc(start, count, new_count)
         except allocation.AllocatorMemoryException as e:
             capacity = _nearest_pow2(e.requested_capacity)
-            self.version += 1
             for buffer, _ in self.buffer_attributes:
-                buffer.resize(capacity * buffer.element_size)
+                buffer.resize(capacity * buffer.attribute_stride)
             self.allocator.set_capacity(capacity)
             return self.allocator.realloc(start, count, new_count)
 
@@ -149,7 +161,7 @@ class VertexDomain:
         :rtype: :py:class:`VertexList`
         """
         start = self.safe_alloc(count)
-        return VertexList(self, start, count)
+        return self._vertexlist_class(self, start, count)
 
     def draw(self, mode):
         """Draw all vertices in the domain.
@@ -163,12 +175,8 @@ class VertexDomain:
 
         """
         self.vao.bind()
-
-        for buffer, attributes in self.buffer_attributes:
+        for buffer, _ in self.buffer_attributes:
             buffer.bind()
-            for attribute in attributes:
-                attribute.enable()
-                attribute.set_pointer(attribute.buffer.ptr)
 
         starts, sizes = self.allocator.get_allocated_regions()
         primcount = len(starts)
@@ -182,9 +190,6 @@ class VertexDomain:
             sizes = (GLsizei * primcount)(*sizes)
             glMultiDrawArrays(mode, starts, sizes, primcount)
 
-        for buffer, _ in self.buffer_attributes:
-            buffer.unbind()
-
     def draw_subset(self, mode, vertex_list):
         """Draw a specific VertexList in the domain.
 
@@ -199,18 +204,11 @@ class VertexDomain:
 
         """
         self.vao.bind()
-
-        for buffer, attributes in self.buffer_attributes:
+        for buffer, _ in self.buffer_attributes:
             buffer.bind()
-            for attribute in attributes:
-                attribute.enable()
-                attribute.set_pointer(attribute.buffer.ptr)
 
         glDrawArrays(mode, vertex_list.start, vertex_list.count)
 
-        for buffer, _ in self.buffer_attributes:
-            buffer.unbind()
-
     @property
     def is_empty(self):
         return not self.allocator.starts
@@ -227,8 +225,6 @@ class VertexList:
         self.domain = domain
         self.start = start
         self.count = count
-        self._caches = {}
-        self._cache_versions = {}
 
     def draw(self, mode):
         """Draw this vertex list in the given OpenGL mode.
@@ -253,7 +249,7 @@ class VertexList:
         new_start = self.domain.safe_realloc(self.start, self.count, count)
         if new_start != self.start:
             # Copy contents to new location
-            for attribute in self.domain.attributes:
+            for attribute in self.domain.attribute_names.values():
                 old = attribute.get_region(attribute.buffer, self.start, self.count)
                 new = attribute.get_region(attribute.buffer, new_start, self.count)
                 new.array[:] = old.array[:]
@@ -261,9 +257,6 @@ class VertexList:
         self.start = new_start
         self.count = count
 
-        for version in self._cache_versions:
-            self._cache_versions[version] = None
-
     def delete(self):
         """Delete this group."""
         self.domain.allocator.dealloc(self.start, self.count)
@@ -293,33 +286,10 @@ class VertexList:
         self.domain = domain
         self.start = new_start
 
-        for version in self._cache_versions:
-            self._cache_versions[version] = None
-
     def set_attribute_data(self, name, data):
         attribute = self.domain.attribute_names[name]
         attribute.set_region(attribute.buffer, self.start, self.count, data)
 
-    def __getattr__(self, name):
-        """dynamic access to vertex attributes, for backwards compatibility.
-        """
-        domain = self.domain
-        if self._cache_versions.get(name, None) != domain.version:
-            attribute = domain.attribute_names[name]
-            self._caches[name] = attribute.get_region(attribute.buffer, self.start, self.count)
-            self._cache_versions[name] = domain.version
-
-        region = self._caches[name]
-        region.invalidate()
-        return region.array
-
-    def __setattr__(self, name, value):
-        # Allow setting vertex attributes directly without overwriting them:
-        if 'domain' in self.__dict__ and name in self.__dict__['domain'].attribute_names:
-            getattr(self, name)[:] = value
-            return
-        super().__setattr__(name, value)
-
 
 class IndexedVertexDomain(VertexDomain):
     """Management of a set of indexed vertex lists.
@@ -339,13 +309,19 @@ class IndexedVertexDomain(VertexDomain):
         self.index_element_size = ctypes.sizeof(self.index_c_type)
         self.index_buffer = BufferObject(self.index_allocator.capacity * self.index_element_size)
 
+        self.vao.bind()
+        self.index_buffer.bind_to_index_buffer()
+        self.vao.unbind()
+
+        # Make a custom VertexList class w/ properties for each attribute in the ShaderProgram:
+        self._vertexlist_class = type("IndexedVertexList", (IndexedVertexList,), self._property_dict)
+
     def safe_index_alloc(self, count):
         """Allocate indices, resizing the buffers if necessary."""
         try:
             return self.index_allocator.alloc(count)
         except allocation.AllocatorMemoryException as e:
             capacity = _nearest_pow2(e.requested_capacity)
-            self.version += 1
             self.index_buffer.resize(capacity * self.index_element_size)
             self.index_allocator.set_capacity(capacity)
             return self.index_allocator.alloc(count)
@@ -356,7 +332,6 @@ class IndexedVertexDomain(VertexDomain):
             return self.index_allocator.realloc(start, count, new_count)
         except allocation.AllocatorMemoryException as e:
             capacity = _nearest_pow2(e.requested_capacity)
-            self.version += 1
             self.index_buffer.resize(capacity * self.index_element_size)
             self.index_allocator.set_capacity(capacity)
             return self.index_allocator.realloc(start, count, new_count)
@@ -373,7 +348,7 @@ class IndexedVertexDomain(VertexDomain):
         """
         start = self.safe_alloc(count)
         index_start = self.safe_index_alloc(index_count)
-        return IndexedVertexList(self, start, count, index_start, index_count)
+        return self._vertexlist_class(self, start, count, index_start, index_count)
 
     def get_index_region(self, start, count):
         """Get a data from a region of the index buffer.
@@ -414,13 +389,8 @@ class IndexedVertexDomain(VertexDomain):
 
         """
         self.vao.bind()
-
-        for buffer, attributes in self.buffer_attributes:
+        for buffer, _ in self.buffer_attributes:
             buffer.bind()
-            for attribute in attributes:
-                attribute.enable()
-                attribute.set_pointer(attribute.buffer.ptr)
-        self.index_buffer.bind_to_index_buffer()
 
         starts, sizes = self.index_allocator.get_allocated_regions()
         primcount = len(starts)
@@ -436,10 +406,6 @@ class IndexedVertexDomain(VertexDomain):
             sizes = (GLsizei * primcount)(*sizes)
             glMultiDrawElements(mode, sizes, self.index_gl_type, starts, primcount)
 
-        self.index_buffer.unbind()
-        for buffer, _ in self.buffer_attributes:
-            buffer.unbind()
-
     def draw_subset(self, mode, vertex_list):
         """Draw a specific IndexedVertexList in the domain.
 
@@ -454,22 +420,13 @@ class IndexedVertexDomain(VertexDomain):
 
         """
         self.vao.bind()
-
-        for buffer, attributes in self.buffer_attributes:
+        for buffer, _ in self.buffer_attributes:
             buffer.bind()
-            for attribute in attributes:
-                attribute.enable()
-                attribute.set_pointer(attribute.buffer.ptr)
-        self.index_buffer.bind_to_index_buffer()
 
         glDrawElements(mode, vertex_list.index_count, self.index_gl_type,
                        self.index_buffer.ptr +
                        vertex_list.index_start * self.index_element_size)
 
-        self.index_buffer.unbind()
-        for buffer, _ in self.buffer_attributes:
-            buffer.unbind()
-
 
 class IndexedVertexList(VertexList):
     """A list of vertices within an :py:class:`IndexedVertexDomain` that are

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/gui/frame.py

@@ -68,10 +68,10 @@ class Frame:
             widget.on_mouse_drag(x, y, dx, dy, buttons, modifiers)
         self._mouse_pos = x, y
 
-    def on_mouse_scroll(self, x, y, index, direction):
+    def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
         """Pass the event to any widgets within range of the mouse"""
         for widget in self._cells.get(self._hash(x, y), set()):
-            widget.on_mouse_scroll(x, y, index, direction)
+            widget.on_mouse_scroll(x, y, scroll_x, scroll_y)
 
     def on_mouse_motion(self, x, y, dx, dy):
         """Pass the event to any widgets within range of the mouse"""

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/gui/widgets.py

@@ -122,7 +122,7 @@ class WidgetBase(EventDispatcher):
     def on_mouse_motion(self, x, y, dx, dy):
         pass
 
-    def on_mouse_scroll(self, x, y, mouse, direction):
+    def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
         pass
 
     def on_text(self, text):
@@ -348,11 +348,11 @@ class Slider(WidgetBase):
         if self._in_update:
             self._update_knob(x)
 
-    def on_mouse_scroll(self, x, y, mouse, direction):
+    def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
         if not self.enabled:
             return
         if self._check_hit(x, y):
-            self._update_knob(self._knob_spr.x + self._half_knob_width + direction)
+            self._update_knob(self._knob_spr.x + self._half_knob_width + scroll_y)
 
     def on_mouse_release(self, x, y, buttons, modifiers):
         if not self.enabled:
@@ -433,6 +433,34 @@ class TextEntry(WidgetBase):
         assert type(value) is str, "This Widget's value must be a string."
         self._doc.text = value
 
+    @property
+    def width(self):
+        return self._width
+
+    @width.setter
+    def width(self, value):
+        self._width = value
+        self._layout.width = value
+        self._outline.width = value
+
+    @property
+    def height(self):
+        return self._height
+
+    @height.setter
+    def height(self, value):
+        self._height = value
+        self._layout.height = value
+        self._outline.height = value
+    
+    @property
+    def focus(self) -> bool:
+        return self._focus
+
+    @focus.setter
+    def focus(self, value: bool) -> None:
+        self._set_focus(value)
+
     def _check_hit(self, x, y):
         return self._x < x < self._x + self._width and self._y < y < self._y + self._height
 

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/image/__init__.py

@@ -131,10 +131,6 @@ class TextureArrayDepthExceeded(Exception):
 def load(filename, file=None, decoder=None):
     """Load an image from a file.
 
-    :note: You can make no assumptions about the return type; usually it will
-        be ImageData or CompressedImageData, but decoders are free to return
-        any subclass of AbstractImage.
-
     :Parameters:
         `filename` : str
             Used to guess the image format, and to load the file if `file` is
@@ -147,6 +143,11 @@ def load(filename, file=None, decoder=None):
             first decoder is raised.
 
     :rtype: AbstractImage
+
+    .. note:: You can make no assumptions about the return type; usually it will
+        be ImageData or CompressedImageData, but decoders are free to return
+        any subclass of AbstractImage.
+
     """
     if decoder:
         return decoder.decode(filename, file)
@@ -181,10 +182,6 @@ def load_animation(filename, file=None, decoder=None):
 def create(width, height, pattern=None):
     """Create an image optionally filled with the given pattern.
 
-    :note: You can make no assumptions about the return type; usually it will
-        be ImageData or CompressedImageData, but patterns are free to return
-        any subclass of AbstractImage.
-
     :Parameters:
         `width` : int
             Width of image to create
@@ -195,6 +192,10 @@ def create(width, height, pattern=None):
             initially be transparent.
 
     :rtype: AbstractImage
+
+    .. note:: You can make no assumptions about the return type; usually it will
+              be ImageData or CompressedImageData, but patterns are free to return
+              any subclass of AbstractImage.
     """
     if not pattern:
         pattern = SolidColorImagePattern()
@@ -1219,11 +1220,20 @@ class Texture(AbstractImage):
         self.id = tex_id
         self._context = pyglet.gl.current_context
 
+    def delete(self):
+        """Delete this texture and the memory it occupies.
+        After this, it may not be used anymore.
+        """
+        glDeleteTextures(1, self.id)
+        self.id = None
+
     def __del__(self):
-        try:
-            self._context.delete_texture(self.id)
-        except Exception:
-            pass
+        if self.id is not None:
+            try:
+                self._context.delete_texture(self.id)
+                self.id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     def bind(self, texture_unit: int = 0):
         """Bind to a specific Texture Unit by number."""
@@ -1233,7 +1243,7 @@ class Texture(AbstractImage):
     def bind_image_texture(self, unit, level=0, layered=False, layer=0, access=GL_READ_WRITE, fmt=GL_RGBA32F):
         """Bind as an ImageTexture for use with a :py:class:`~pyglet.shader.ComputeShaderProgram`.
 
-        ..note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extention is required.
+        .. note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extention is required.
         """
         glBindImageTexture(unit, self.id, level, layered, layer, access, fmt)
 
@@ -1426,6 +1436,12 @@ class Texture(AbstractImage):
         order = self.tex_coords_order
         self.tex_coords_order = (order[bl], order[br], order[tr], order[tl])
 
+    @property
+    def uv(self):
+        """Tuple containing the left, bottom, right, top 2D texture coordinates."""
+        tex_coords = self.tex_coords
+        return tex_coords[0], tex_coords[1], tex_coords[3], tex_coords[7]
+
     def __repr__(self):
         return "{}(id={}, size={}x{})".format(self.__class__.__name__, self.id, self.width, self.height)
 
@@ -1472,8 +1488,13 @@ class TextureRegion(Texture):
         return "{}(id={}, size={}x{}, owner={}x{})".format(self.__class__.__name__, self.id, self.width, self.height,
                                                            self.owner.width, self.owner.height)
 
+    def delete(self):
+        """Deleting a TextureRegion has no effect. Operate on the owning
+        texture instead.
+        """
+        pass
+
     def __del__(self):
-        # only the owner Texture should handle deletion
         pass
 
 

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/image/atlas.py

@@ -23,7 +23,7 @@ the application's responsibility to keep track of the regions returned by the
 
 .. versionadded:: 1.1
 """
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING, Tuple, Optional
 
 import pyglet
 
@@ -40,13 +40,13 @@ class AllocatorException(Exception):
 class _Strip:
     __slots__ = 'x', 'y', 'max_height', 'y2'
 
-    def __init__(self, y: int, max_height: int):
+    def __init__(self, y: int, max_height: int) -> None:
         self.x = 0
         self.y = y
         self.max_height = max_height
         self.y2 = y
 
-    def add(self, width: int, height: int):
+    def add(self, width: int, height: int) -> Tuple[int, int]:
         assert width > 0 and height > 0
         assert height <= self.max_height
 
@@ -55,7 +55,7 @@ class _Strip:
         self.y2 = max(self.y + height, self.y2)
         return x, y
 
-    def compact(self):
+    def compact(self) -> None:
         self.max_height = self.y2 - self.y
 
 
@@ -71,7 +71,7 @@ class Allocator:
     """
     __slots__ = 'width', 'height', 'strips', 'used_area'
 
-    def __init__(self, width: int, height: int):
+    def __init__(self, width: int, height: int) -> None:
         """Create an `Allocator` of the given size.
 
         :Parameters:
@@ -139,13 +139,13 @@ class Allocator:
         if not self.strips:
             return 0.0
         possible_area = self.strips[-1].y2 * self.width
-        return 1.0 - self.used_area / float(possible_area)
+        return 1.0 - self.used_area / possible_area
 
 
 class TextureAtlas:
     """Collection of images within a texture."""
 
-    def __init__(self, width: int = 2048, height: int = 2048):
+    def __init__(self, width: int = 2048, height: int = 2048) -> None:
         """Create a texture atlas of the given size.
 
         :Parameters:
@@ -194,7 +194,7 @@ class TextureBin:
     ones as necessary to accommodate images added to the bin.
     """
 
-    def __init__(self, texture_width: int = 2048, texture_height: int = 2048):
+    def __init__(self, texture_width: int = 2048, texture_height: int = 2048) -> None:
         """Create a texture bin for holding atlases of the given size.
 
         :Parameters:
@@ -252,7 +252,7 @@ class TextureArrayBin:
     ones as necessary as the depth is exceeded.
     """
 
-    def __init__(self, texture_width=2048, texture_height=2048, max_depth=None):
+    def __init__(self, texture_width: int = 2048, texture_height: int = 2048, max_depth: Optional[int] = None) -> None:
         max_texture_size = pyglet.image.get_max_texture_size()
         self.max_depth = max_depth or pyglet.image.get_max_array_texture_layers()
         self.texture_width = min(texture_width, max_texture_size)

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/image/buffer.py

@@ -13,6 +13,7 @@ class Renderbuffer:
 
     def __init__(self, width, height, internal_format, samples=1):
         """Create an instance of a Renderbuffer object."""
+        self._context = pyglet.gl.current_context
         self._id = GLuint()
         self._width = width
         self._height = height
@@ -49,13 +50,15 @@ class Renderbuffer:
 
     def delete(self):
         glDeleteRenderbuffers(1, self._id)
+        self._id = None
 
     def __del__(self):
-        try:
-            glDeleteRenderbuffers(1, self._id)
-        # Python interpreter is shutting down:
-        except Exception:
-            pass
+        if self._id is not None:
+            try:
+                self._context.delete_renderbuffer(self._id.value)
+                self._id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     def __repr__(self):
         return "{}(id={})".format(self.__class__.__name__, self._id.value)
@@ -71,6 +74,7 @@ class Framebuffer:
 
         .. versionadded:: 2.0
         """
+        self._context = pyglet.gl.current_context
         self._id = GLuint()
         glGenFramebuffers(1, self._id)
         self._attachment_types = 0
@@ -105,10 +109,16 @@ class Framebuffer:
             self.unbind()
 
     def delete(self):
-        try:
-            glDeleteFramebuffers(1, self._id)
-        except Exception:
-            pass
+        glDeleteFramebuffers(1, self._id)
+        self._id = None
+
+    def __del__(self):
+        if self._id is not None:
+            try:
+                self._context.delete_framebuffer(self._id.value)
+                self._id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
 
     @property
     def is_complete(self):
@@ -203,12 +213,5 @@ class Framebuffer:
         self._height = max(renderbuffer.height, self._height)
         self.unbind()
 
-    def __del__(self):
-        try:
-            glDeleteFramebuffers(1, self._id)
-        # Python interpreter is shutting down:
-        except Exception:
-            pass
-
     def __repr__(self):
         return "{}(id={})".format(self.__class__.__name__, self._id.value)