pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/shapes.py

@@ -72,66 +72,23 @@ from typing import TYPE_CHECKING, Sequence, Tuple, Union
 
 import pyglet
 from pyglet.extlibs import earcut
-from pyglet.gl import GL_BLEND, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRIANGLES, glBlendFunc, glDisable, glEnable
-from pyglet.graphics import Batch, Group
+from pyglet.graphics import Batch, Group, ShaderProgram
+from pyglet.enums import BlendFactor
 from pyglet.math import Vec2
 
 if TYPE_CHECKING:
     from pyglet.graphics.shader import ShaderProgram
 
-vertex_source = """#version 150 core
-    in vec2 position;
-    in vec2 translation;
-    in vec4 colors;
-    in float zposition;
-
-    in float rotation;
-
-
-    out vec4 vertex_colors;
-
-    uniform WindowBlock
-    {
-        mat4 projection;
-        mat4 view;
-    } window;
-
-    mat4 m_rotation = mat4(1.0);
-    mat4 m_translate = mat4(1.0);
-
-    void main()
-    {
-        m_translate[3][0] = translation.x;
-        m_translate[3][1] = translation.y;
-        m_rotation[0][0] =  cos(-radians(rotation));
-        m_rotation[0][1] =  sin(-radians(rotation));
-        m_rotation[1][0] = -sin(-radians(rotation));
-        m_rotation[1][1] =  cos(-radians(rotation));
-
-        gl_Position = window.projection * window.view * m_translate * m_rotation * vec4(position, zposition, 1.0);
-        vertex_colors = colors;
-    }
-"""
-
-fragment_source = """#version 150 core
-    in vec4 vertex_colors;
-    out vec4 final_color;
-
-    void main()
-    {
-        final_color = vertex_colors;
-        // No GL_ALPHA_TEST in core, use shader to discard.
-        if(final_color.a < 0.01){
-            discard;
-        }
-    }
-"""
-
-
-def get_default_shader() -> ShaderProgram:
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (fragment_source, 'fragment'))
 
+if pyglet.options.backend in ("opengl", "gles3"):
+    from pyglet.graphics.api.gl.shapes import get_default_shader
+elif pyglet.options.backend in ("gl2", "gles2"):
+    from pyglet.graphics.api.gl2.shapes import get_default_shader
+elif pyglet.options.backend == "webgl":
+    from pyglet.graphics.api.webgl.shapes import get_default_shader
+elif pyglet.options.backend == "vulkan":
+    from pyglet.graphics.api.vulkan.shapes import get_default_shader
+from pyglet.graphics import GeometryMode
 
 def _rotate_point(center: tuple[float, float], point: tuple[float, float], angle: float) -> tuple[float, float]:
     prev_angle = math.atan2(point[1] - center[1], point[0] - center[0])
@@ -243,14 +200,19 @@ def _get_segment(p0: tuple[float, float] | list[float], p1: tuple[float, float]
     return v_miter2, scale2, v1[0], v1[1], v2[0], v2[1], v3[0], v3[1], v4[0], v4[1], v5[0], v5[1], v6[0], v6[1]
 
 
+
+
 class _ShapeGroup(Group):
     """Shared Shape rendering Group.
 
     The group is automatically coalesced with other shape groups
     sharing the same parent group and blend parameters.
     """
+    blend_src: int
+    blend_dest: int
 
-    def __init__(self, blend_src: int, blend_dest: int, program: ShaderProgram, parent: Group | None = None) -> None:
+    def __init__(self, blend_src: BlendFactor, blend_dest: BlendFactor, program: ShaderProgram,
+                 parent: Group | None = None) -> None:
         """Create a Shape group.
 
         The group is created internally. Usually you do not
@@ -267,28 +229,8 @@ class _ShapeGroup(Group):
                 Optional parent group.
         """
         super().__init__(parent=parent)
-        self.program = program
-        self.blend_src = blend_src
-        self.blend_dest = blend_dest
-
-    def set_state(self) -> None:
-        self.program.bind()
-        glEnable(GL_BLEND)
-        glBlendFunc(self.blend_src, self.blend_dest)
-
-    def unset_state(self) -> None:
-        glDisable(GL_BLEND)
-        self.program.unbind()
-
-    def __eq__(self, other: Group | _ShapeGroup) -> None:
-        return (other.__class__ is self.__class__ and
-                self.program == other.program and
-                self.parent == other.parent and
-                self.blend_src == other.blend_src and
-                self.blend_dest == other.blend_dest)
-
-    def __hash__(self) -> int:
-        return hash((self.program, self.parent, self.blend_src, self.blend_dest))
+        self.set_shader_program(program)
+        self.set_blend(blend_src, blend_dest)
 
 
 class ShapeBase(ABC):
@@ -317,13 +259,13 @@ class ShapeBase(ABC):
     _num_verts: int = 0
     _user_group: Group | None = None
     _vertex_list = None
-    _draw_mode: int = GL_TRIANGLES
+    _draw_mode: GeometryMode = GeometryMode.TRIANGLES
     group_class: Group = _ShapeGroup
 
     def __init__(self,
                  vertex_count: int,
-                 blend_src: int = GL_SRC_ALPHA,
-                 blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+                 blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+                 blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
                  batch: Batch | None = None,
                  group: Group | None = None,
                  program: ShaderProgram | None = None,
@@ -336,7 +278,7 @@ class ShapeBase(ABC):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch object.
             group:
@@ -385,7 +327,7 @@ class ShapeBase(ABC):
         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
+        self._vertex_list.translation[:] = (self._x, self._y, self._z) * self._num_verts
 
     def _create_vertex_list(self) -> None:
         """Build internal vertex list.
@@ -413,7 +355,7 @@ class ShapeBase(ABC):
         raise NotImplementedError("_update_vertices must be defined for every ShapeBase subclass")
 
     @property
-    def blend_mode(self) -> tuple[int, int]:
+    def blend_mode(self) -> tuple[BlendFactor, BlendFactor]:
         """The current blend mode applied to this shape.
 
         .. note:: Changing this can be an expensive operation as it involves a group creation and transfer.
@@ -452,7 +394,7 @@ class ShapeBase(ABC):
         self._group = self.get_shape_group()
 
         if (self._batch and
-                self._batch.update_shader(self._vertex_list, GL_TRIANGLES, self._group, program)):
+                self._batch.update_shader(self._vertex_list, self._draw_mode, self._group, program)):
             # Exit early if changing domain is not needed.
             return
 
@@ -502,9 +444,10 @@ class ShapeBase(ABC):
                      and call its :py:meth:`~Batch.draw` method.
 
         """
-        self._group.set_state_recursive()
+        ctx = pyglet.graphics.api.core.current_context
+        self._group.set_state_recursive(ctx)
         self._vertex_list.draw(self._draw_mode)
-        self._group.unset_state_recursive()
+        self._group.unset_state_recursive(ctx)
 
     def delete(self) -> None:
         """Force immediate removal of the shape from video memory.
@@ -572,7 +515,7 @@ class ShapeBase(ABC):
     @z.setter
     def z(self, value: float) -> None:
         self._z = value
-        self._vertex_list.zposition = (value,) * self._num_verts
+        self._update_translation()
 
     @property
     def position(self) -> tuple[float, float]:
@@ -690,7 +633,7 @@ class ShapeBase(ABC):
 
         Opacity is implemented as the alpha component of a shape's
         :py:attr:`.color`. When part of a group with a default blend
-        mode of ``(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)``, opacities
+        mode of ``(GL_SRC_ALPHA, ONE_MINUS_SRC_ALPHA)``, opacities
         below ``255`` draw with fractional opacity over the background:
 
         .. list-table:: Example Values & Effects
@@ -789,8 +732,8 @@ class Arc(ShapeBase):
             closed: bool = False,
             thickness: float = 1.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -828,7 +771,7 @@ class Arc(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -864,8 +807,9 @@ class Arc(ShapeBase):
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -971,8 +915,8 @@ class BezierCurve(ShapeBase):
             segments: int = 100,
             thickness: int = 1.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1000,7 +944,7 @@ class BezierCurve(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1035,8 +979,9 @@ class BezierCurve(ShapeBase):
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -1114,8 +1059,8 @@ class Circle(ShapeBase):
             radius: float,
             segments: int | None = None,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1143,7 +1088,7 @@ class Circle(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1169,12 +1114,14 @@ class Circle(ShapeBase):
         return math.dist((self._x - self._anchor_x, self._y - self._anchor_y), point) < self._radius
 
     def _create_vertex_list(self) -> None:
+        vert_count = self._segments * 3
         self._vertex_list = self._program.vertex_list(
-            self._segments * 3, self._draw_mode, self._batch, self._group,
+            vert_count, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
-            colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            colors=('Bn', self._rgba * vert_count),
+            translation=('f', (self._x, self._y, self._z) * vert_count),
+            rotation=('f', (self._rotation,) * vert_count),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -1219,8 +1166,8 @@ class Ellipse(ShapeBase):
             a: float, b: float,
             segments: int | None = None,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1251,7 +1198,7 @@ class Ellipse(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1292,8 +1239,9 @@ class Ellipse(ShapeBase):
             self._segments * 3, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -1349,8 +1297,8 @@ class Sector(ShapeBase):
             angle: float = 360.0,
             start_angle: float = 0.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1385,7 +1333,7 @@ class Sector(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1414,30 +1362,21 @@ class Sector(ShapeBase):
     def __contains__(self, point: tuple[float, float]) -> bool:
         assert len(point) == 2
         point = _rotate_point((self._x, self._y), point, math.radians(self._rotation))
-        if math.dist((self._x - self._anchor_x, self._y - self._anchor_y), point) > self._radius:
-            return False
-        angle = math.degrees(math.atan2(point[1] - self._y + self._anchor_y, point[0] - self._x + self._anchor_x))
-        angle = angle % 360
-        start_angle = self._start_angle % 360
-        end_angle = (start_angle + self._angle) % 360
-        if self._angle >= 0:
-            if start_angle <= end_angle:
-                return start_angle <= angle <= end_angle
-            else:
-                return angle >= start_angle or angle <= end_angle
-        else:
-            if end_angle <= start_angle:
-                return end_angle <= angle <= start_angle
-            else:
-                return angle >= end_angle or angle <= start_angle
+        angle = math.atan2(point[1] - self._y + self._anchor_y, point[0] - self._x + self._anchor_x)
+        if angle < 0:
+            angle += 2 * math.pi
+        if self._start_angle < angle < self._start_angle + self._angle:
+            return math.dist((self._x - self._anchor_x, self._y - self._anchor_y), point) < self._radius
+        return False
 
     def _create_vertex_list(self) -> None:
         self._vertex_list = self._program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -1447,7 +1386,7 @@ class Sector(ShapeBase):
         y = -self._anchor_y
         r = self._radius
         segment_radians = math.radians(self._angle) / self._segments
-        start_radians = math.radians(self._start_angle)
+        start_radians = math.radians(self._start_angle - self._rotation)
 
         # Calculate the outer points of the sector.
         points = [(x + (r * math.cos((i * segment_radians) + start_radians)),
@@ -1506,8 +1445,8 @@ class Line(ShapeBase):
             x: float, y: float, x2: float, y2: float,
             thickness: float = 1.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1535,7 +1474,7 @@ class Line(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1579,8 +1518,9 @@ class Line(ShapeBase):
             6, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -1648,8 +1588,8 @@ class Rectangle(ShapeBase):
             x: float, y: float,
             width: float, height: float,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1675,7 +1615,7 @@ class Rectangle(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1706,19 +1646,19 @@ class Rectangle(ShapeBase):
             6, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation = ('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
             return (0, 0) * self._num_verts
-        else:
-            x1 = -self._anchor_x
-            y1 = -self._anchor_y
-            x2 = x1 + self._width
-            y2 = y1 + self._height
+        x1 = -self._anchor_x
+        y1 = -self._anchor_y
+        x2 = x1 + self._width
+        y2 = y1 + self._height
 
-            return x1, y1, x2, y1, x2, y2, x1, y1, x2, y2, x1, y2
+        return x1, y1, x2, y1, x2, y2, x1, y1, x2, y2, x1, y2
 
     def _update_vertices(self) -> None:
         self._vertex_list.position[:] = self._get_vertices()
@@ -1760,8 +1700,8 @@ class BorderedRectangle(ShapeBase):
             border: float = 1.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255),
             border_color: tuple[int, int, int, int] | tuple[int, int, int] = (100, 100, 100),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -1798,7 +1738,7 @@ class BorderedRectangle(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -1825,7 +1765,7 @@ class BorderedRectangle(ShapeBase):
                              "they must both have the same opacity")
 
         # Choose a value to use if there is no conflict
-        elif fill_a:
+        if fill_a:
             alpha = fill_a[0]
         elif border_a:
             alpha = border_a[0]
@@ -1850,8 +1790,9 @@ class BorderedRectangle(ShapeBase):
             8, self._draw_mode, indices, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * 4 + self._border_rgba * 4),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _update_color(self) -> None:
         self._vertex_list.colors[:] = self._rgba * 4 + self._border_rgba * 4
@@ -1998,8 +1939,8 @@ class Box(ShapeBase):
             width: float, height: float,
             thickness: float = 1.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2029,7 +1970,7 @@ class Box(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2065,8 +2006,9 @@ class Box(ShapeBase):
             self._num_verts, self._draw_mode, indices, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation = ('f', (self._rotation,) * self._num_verts),
+        )
 
     def _update_color(self):
         self._vertex_list.colors[:] = self._rgba * self._num_verts
@@ -2146,8 +2088,8 @@ class RoundedRectangle(pyglet.shapes.ShapeBase):
             radius: _RadiusT | tuple[_RadiusT, _RadiusT, _RadiusT, _RadiusT],
             segments: int | tuple[int, int, int, int] | None = None,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2185,7 +2127,7 @@ class RoundedRectangle(pyglet.shapes.ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2245,8 +2187,9 @@ class RoundedRectangle(pyglet.shapes.ShapeBase):
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2334,8 +2277,8 @@ class Triangle(ShapeBase):
             x2: float, y2: float,
             x3: float, y3: float,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2364,7 +2307,7 @@ class Triangle(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2397,20 +2340,20 @@ class Triangle(ShapeBase):
             3, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
             return (0, 0) * self._num_verts
-        else:
-            x1 = -self._anchor_x
-            y1 = -self._anchor_y
-            x2 = self._x2 + x1 - self._x
-            y2 = self._y2 + y1 - self._y
-            x3 = self._x3 + x1 - self._x
-            y3 = self._y3 + y1 - self._y
-            return x1, y1, x2, y2, x3, y3
+        x1 = -self._anchor_x
+        y1 = -self._anchor_y
+        x2 = self._x2 + x1 - self._x
+        y2 = self._y2 + y1 - self._y
+        x3 = self._x3 + x1 - self._x
+        y3 = self._y3 + y1 - self._y
+        return x1, y1, x2, y2, x3, y3
 
     def _update_vertices(self) -> None:
         self._vertex_list.position[:] = self._get_vertices()
@@ -2465,8 +2408,8 @@ class Star(ShapeBase):
             num_spikes: int,
             rotation: float = 0.0,
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2498,7 +2441,7 @@ class Star(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2534,8 +2477,9 @@ class Star(ShapeBase):
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            rotation=('f', (self._rotation,) * self._num_verts),
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2604,8 +2548,8 @@ class Polygon(ShapeBase):
             self,
             *coordinates: tuple[float, float] | Sequence[float],
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2626,7 +2570,7 @@ class Polygon(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2659,8 +2603,9 @@ class Polygon(ShapeBase):
             self._batch, self._group,
             position=('f', vertices),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2687,8 +2632,8 @@ class MultiLine(ShapeBase):
             closed: bool = False,
             thickness: float = 1.0,
             color: tuple[int, int, int, int] = (255, 255, 255, 255),
-            blend_src: int = GL_SRC_ALPHA,
-            blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+            blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+            blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
             batch: Batch | None = None,
             group: Group | None = None,
             program: ShaderProgram | None = None,
@@ -2714,7 +2659,7 @@ class MultiLine(ShapeBase):
             blend_src:
                 OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+                OpenGL blend destination mode; for example, ``ONE_MINUS_SRC_ALPHA``.
             batch:
                 Optional batch to add the shape to.
             group:
@@ -2745,8 +2690,9 @@ class MultiLine(ShapeBase):
             self._num_verts, self._draw_mode, self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._x, self._y) * self._num_verts),
-            rotation=('f', (self._rotation,) * self._num_verts))
+            translation=('f', (self._x, self._y, self._z) * self._num_verts),
+            rotation=('f', (self._rotation,) * self._num_verts),
+        )
 
     def _get_vertices(self) -> Sequence[float]:
         if not self._visible:
@@ -2790,5 +2736,19 @@ class MultiLine(ShapeBase):
         self._update_vertices()
 
 
-__all__ = ('Arc', 'Box', 'BezierCurve', 'Circle', 'Ellipse', 'Line', 'MultiLine', 'Rectangle',
-           'BorderedRectangle', 'Triangle', 'Star', 'Polygon', 'Sector', 'ShapeBase')
+__all__ = (
+    'Arc',
+    'BezierCurve',
+    'BorderedRectangle',
+    'Box',
+    'Circle',
+    'Ellipse',
+    'Line',
+    'MultiLine',
+    'Polygon',
+    'Rectangle',
+    'Sector',
+    'ShapeBase',
+    'Star',
+    'Triangle',
+)