pyglet 2.1.5__tar.gz → 2.1.6__tar.gz

{pyglet-2.1.5 → pyglet-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyglet
-Version: 2.1.5
+Version: 2.1.6
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8

{pyglet-2.1.5 → pyglet-2.1.6}/RELEASE_NOTES

@@ -1,3 +1,12 @@
+pyglet 2.1.6
+
+Bugfixes
+--------
+shapes: revert color -> colors in default shader.
+shaders: fix UniformBlock introspection for creating an array of single types, like float.
+shaders: in compute_shader example, fix incorrect assumption that bind_image_texture used uniform location.
+
+
 pyglet 2.1.5
 
 Changes

{pyglet-2.1.5 → pyglet-2.1.6}/examples/opengl/compute_shader.py

@@ -30,12 +30,11 @@ program = pyglet.graphics.shader.ComputeShaderProgram(compute_src)
 # Create an RGBA32F Texture that we can bind to the ShaderProgram.
 out_texture = pyglet.image.Texture.create(540, 540, internalformat=GL_RGBA32F)
 
-# If the uniform location is not specifically set in the shader,
-# you can look up it's metadata in the `program.uniforms` dict.
-# This metadata is automatically introspected on Program linking:
-# {'img_output': {'location': 0, 'length': 2, 'size': 1}}
-uniform_location = program.uniforms['img_output']['location']
-out_texture.bind_image_texture(unit=uniform_location)
+# The image binding unit in the shader needs to be set for the texture.
+# The uniform set for the image can be used. In most cases this will be 0 unless explicitly
+# changed via layout qualifier of layout(binding=X, rgba32f)
+output_binding = program['img_output']
+out_texture.bind_image_texture(unit=output_binding)
 
 
 with program:

{pyglet-2.1.5 → pyglet-2.1.6}/pyglet/__init__.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.5'
+version = '2.1.6'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8

{pyglet-2.1.5 → pyglet-2.1.6}/pyglet/graphics/shader.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 import warnings
 import weakref
+from _ctypes import _Pointer, _SimpleCData
 from collections import defaultdict
 from ctypes import (
     POINTER,
@@ -29,8 +30,6 @@ from ctypes import (
 )
 from typing import TYPE_CHECKING, Any, Callable, Literal, Sequence, Type, Union
 
-from _ctypes import _Pointer, _SimpleCData
-
 import pyglet
 from pyglet.gl import Context, GLException, gl, gl_info
 from pyglet.gl.gl import (
@@ -171,19 +170,19 @@ _uniform_setters: dict[int, tuple[GLDataType, GLFunc, GLFunc, int]] = {
     # GL_FLOAT_MAT4x3: glUniformMatrix4x3fv, glProgramUniformMatrix4x3fv,
 
     gl.GL_IMAGE_1D: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
-    gl.GL_IMAGE_2D: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 2),
-    gl.GL_IMAGE_2D_RECT: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
-    gl.GL_IMAGE_3D: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
+    gl.GL_IMAGE_2D: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
+    gl.GL_IMAGE_2D_RECT: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
+    gl.GL_IMAGE_3D: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
 
-    gl.GL_IMAGE_1D_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 2),
-    gl.GL_IMAGE_2D_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
+    gl.GL_IMAGE_1D_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
+    gl.GL_IMAGE_2D_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
 
-    gl.GL_IMAGE_2D_MULTISAMPLE: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 2),
-    gl.GL_IMAGE_2D_MULTISAMPLE_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
+    gl.GL_IMAGE_2D_MULTISAMPLE: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
+    gl.GL_IMAGE_2D_MULTISAMPLE_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
 
-    gl.GL_IMAGE_BUFFER: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
+    gl.GL_IMAGE_BUFFER: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
     gl.GL_IMAGE_CUBE: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
-    gl.GL_IMAGE_CUBE_MAP_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 3),
+    gl.GL_IMAGE_CUBE_MAP_ARRAY: (gl.GLint, gl.glUniform1iv, gl.glProgramUniform1iv, 1),
 }
 
 _attribute_types: dict[int, tuple[int, str]] = {
@@ -332,8 +331,17 @@ class _UniformArray:
     _ptr: CTypesPointer[GLDataType]
     _idx_to_loc: dict[int, int]
 
-    __slots__ = ('_uniform', '_gl_type', '_gl_getter', '_gl_setter', '_is_matrix', '_dsa', '_c_array', '_ptr',
-                 '_idx_to_loc')
+    __slots__ = (
+        '_c_array',
+        '_dsa',
+        '_gl_getter',
+        '_gl_setter',
+        '_gl_type',
+        '_idx_to_loc',
+        '_is_matrix',
+        '_ptr',
+        '_uniform',
+    )
 
     def __init__(self, uniform: _Uniform, gl_getter: GLFunc, gl_setter: GLFunc, gl_type: GLDataType, is_matrix: bool,
                  dsa: bool) -> None:
@@ -362,7 +370,7 @@ class _UniformArray:
         right location.
         """
         loc = gl.glGetUniformLocation(self._uniform.program,
-                                create_string_buffer(f"{self._uniform.name}[{index}]".encode('utf-8')))
+                                create_string_buffer(f"{self._uniform.name}[{index}]".encode()))
         return loc
 
     def _get_array_loc(self, index: int) -> int:
@@ -471,7 +479,7 @@ class _Uniform:
     get: Callable[[], Array[GLDataType] | GLDataType]
     set: Callable[[float], None] | Callable[[Sequence], None]
 
-    __slots__ = 'type', 'size', 'location', 'length', 'count', 'get', 'set', 'program', 'name'
+    __slots__ = 'count', 'get', 'length', 'location', 'name', 'program', 'set', 'size', 'type'
 
     def __init__(self, program: int, name: str, uniform_type: int, size: int, location: int, dsa: bool) -> None:
         self.name = name
@@ -662,7 +670,7 @@ class UniformBlock:
     binding: int
     uniforms: dict[int, tuple[str, GLDataType, int, int]]
     view_cls: type[Structure] | None
-    __slots__ = 'program', 'name', 'index', 'size', 'binding', 'uniforms', 'view_cls', 'uniform_count'
+    __slots__ = 'binding', 'index', 'name', 'program', 'size', 'uniform_count', 'uniforms', 'view_cls'
 
     def __init__(self, program: ShaderProgram, name: str, index: int, size: int, binding: int,
                  uniforms: dict[int, tuple[str, GLDataType, int, int]], uniform_count: int) -> None:
@@ -793,9 +801,15 @@ class UniformBlock:
                 if part_idx == len(parts) - 1:  # The last part is the actual type
                     if u_size > 1:
                         # If size > 1, treat as an array of type
-                        current_structure[part_name] = gl_type * length * u_size
+                        if length > 1:
+                            current_structure[part_name] = (gl_type * length) * u_size
+                        else:
+                            current_structure[part_name] = gl_type * u_size
                     else:
-                        current_structure[part_name] = gl_type * length
+                        if length > 1:
+                            current_structure[part_name] = gl_type * length
+                        else:
+                            current_structure[part_name] = gl_type
 
                     offset_size = offsets[i + 1] - offsets[i]
                     c_type_size = sizeof(current_structure[part_name])
@@ -836,7 +850,7 @@ class UniformBufferObject:
     _view_ptr: CTypesPointer[Structure]
     binding: int
     buffer: BufferObject
-    __slots__ = 'buffer', 'view', '_view_ptr', 'binding'
+    __slots__ = '_view_ptr', 'binding', 'buffer', 'view'
 
     def __init__(self, view_class: type[Structure], buffer_size: int, binding: int) -> None:
         """Initialize the Uniform Buffer Object with the specified Structure."""
@@ -1267,7 +1281,7 @@ class ShaderProgram:
     _uniforms: dict[str, _Uniform]
     _uniform_blocks: dict[str, UniformBlock]
 
-    __slots__ = '_id', '_context', '_attributes', '_uniforms', '_uniform_blocks', '__weakref__'
+    __slots__ = '__weakref__', '_attributes', '_context', '_id', '_uniform_blocks', '_uniforms'
 
     def __init__(self, *shaders: Shader) -> None:
         """Initialize the ShaderProgram using at least two Shader instances."""

{pyglet-2.1.5 → pyglet-2.1.6}/pyglet/shapes.py

@@ -82,12 +82,13 @@ if TYPE_CHECKING:
 vertex_source = """#version 150 core
     in vec2 position;
     in vec2 translation;
-    in vec4 color;
+    in vec4 colors;
     in float zposition;
+
     in float rotation;
 
 
-    out vec4 vertex_color;
+    out vec4 vertex_colors;
 
     uniform WindowBlock
     {
@@ -108,17 +109,17 @@ vertex_source = """#version 150 core
         m_rotation[1][1] =  cos(-radians(rotation));
 
         gl_Position = window.projection * window.view * m_translate * m_rotation * vec4(position, zposition, 1.0);
-        vertex_color = color;
+        vertex_colors = colors;
     }
 """
 
 fragment_source = """#version 150 core
-    in vec4 vertex_color;
+    in vec4 vertex_colors;
     out vec4 final_color;
 
     void main()
     {
-        final_color = vertex_color;
+        final_color = vertex_colors;
         // No GL_ALPHA_TEST in core, use shader to discard.
         if(final_color.a < 0.01){
             discard;
@@ -376,12 +377,12 @@ class ShapeBase(ABC):
     def _update_color(self) -> None:
         """Send the new colors for each vertex to the GPU.
 
-        This method must set the contents of `self._vertex_list.color`
+        This method must set the contents of `self._vertex_list.colors`
         using a list or tuple that contains the RGBA color components
         for each vertex in the shape. This is usually done by repeating
         `self._rgba` for each vertex.
         """
-        self._vertex_list.color[:] = self._rgba * self._num_verts
+        self._vertex_list.colors[:] = self._rgba * self._num_verts
 
     def _update_translation(self) -> None:
         self._vertex_list.translation[:] = (self._x, self._y) * self._num_verts
@@ -862,7 +863,7 @@ class Arc(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1032,7 +1033,7 @@ class BezierCurve(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1169,7 +1170,7 @@ class Circle(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._segments * 3, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1287,7 +1288,7 @@ class Ellipse(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._segments * 3, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1420,7 +1421,7 @@ class Sector(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1562,7 +1563,7 @@ class Line(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             6, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1688,7 +1689,7 @@ class Rectangle(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             6, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -1831,11 +1832,11 @@ class BorderedRectangle(ShapeBase):
         self._vertex_list = self._program.vertex_list_indexed(
             8, self._draw_mode, indices, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * 4 + self._border_rgba * 4),
+            colors=('Bn', self._rgba * 4 + self._border_rgba * 4),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _update_color(self) -> None:
-        self._vertex_list.color[:] = self._rgba * 4 + self._border_rgba * 4
+        self._vertex_list.colors[:] = self._rgba * 4 + self._border_rgba * 4
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2045,11 +2046,11 @@ class Box(ShapeBase):
         self._vertex_list = self._program.vertex_list_indexed(
             self._num_verts, self._draw_mode, indices, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _update_color(self):
-        self._vertex_list.color[:] = self._rgba * self._num_verts
+        self._vertex_list.colors[:] = self._rgba * self._num_verts
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2224,7 +2225,7 @@ class RoundedRectangle(pyglet.shapes.ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -2375,7 +2376,7 @@ class Triangle(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             3, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -2511,7 +2512,7 @@ class Star(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             rotation=('f', (self._rotation,) * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
@@ -2636,7 +2637,7 @@ class Polygon(ShapeBase):
             earcut.earcut(vertices),
             self._batch, self._group,
             position=('f', vertices),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:
@@ -2721,7 +2722,7 @@ class MultiLine(ShapeBase):
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            color=('Bn', self._rgba * self._num_verts),
+            colors=('Bn', self._rgba * self._num_verts),
             translation=('f', (self._x, self._y) * self._num_verts))
 
     def _get_vertices(self) -> Sequence[float]:

{pyglet-2.1.5 → pyglet-2.1.6}/tests/integration/graphics/test_shaders.py

@@ -67,6 +67,8 @@ def test_shader_ubo_data_structure():
 
         layout(std140) uniform EntityDataBlock {
              DataStruct data[5];
+             float simple_type;
+             vec2 vec_type;
         } data_struct;
 
         uniform sampler2D sprite_texture;
@@ -90,7 +92,9 @@ def test_shader_ubo_data_structure():
     
     with ubo as block:
         block.data[0].color[1][:] = test_data
-        
+        block.simple_type = 1.0
+        block.vec_type[:] = (1.0, 2.0)
+
         # Just test a random deep node.
         assert len(block.data[3].within[2].position[:]) == 3