pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/shapes.py

@@ -5,12 +5,11 @@ such as Rectangles, Circles, and Lines. These shapes are made
 internally from OpenGL primitives, and provide excellent performance
 when drawn as part of a :py:class:`~pyglet.graphics.Batch`.
 Convenience methods are provided for positioning, changing color
-and opacity, and rotation (where applicable). To create more
-complex shapes than what is provided here, the lower level
-graphics API is more appropriate.
-You can also use the ``in`` operator to check whether a point is
-inside a shape.
-See the :ref:`guide_graphics` for more details.
+and opacity, and rotation (where applicable).
+The Python ``in`` operator to check whether a point is inside a shape.
+
+To create more complex shapes than what is provided here, the lower level
+graphics API is more appropriate. See the :ref:`guide_graphics` for more details.
 
 A simple example of drawing shapes::
 
@@ -102,21 +101,15 @@ fragment_source = """#version 150 core
 
 
 def get_default_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_shapes_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_shapes_default_shader = default_shader_program
-        return default_shader_program
+    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
+                                                    (fragment_source, 'fragment'))
 
 
 def _rotate_point(center, point, angle):
     prev_angle = math.atan2(point[1] - center[1], point[0] - center[0])
     now_angle = prev_angle + angle
     r = math.dist(point, center)
-    return (center[0] + r * math.cos(now_angle), center[1] + r * math.sin(now_angle))
+    return center[0] + r * math.cos(now_angle), center[1] + r * math.sin(now_angle)
 
 
 def _sat(vertices, point):
@@ -198,6 +191,7 @@ class ShapeBase(ABC):
     """
 
     _rgba = (255, 255, 255, 255)
+    _rotation = 0
     _visible = True
     _x = 0
     _y = 0
@@ -258,6 +252,29 @@ class ShapeBase(ABC):
         """
         raise NotImplementedError("_update_vertices must be defined"
                                   "for every ShapeBase subclass")
+    @property
+    def rotation(self) -> float:
+        """Clockwise rotation of the shape in degrees.
+
+        It will be rotated about its (anchor_x, anchor_y) position,
+        which defaults to the first vertex point of the shape.
+
+        For most shapes, this is the lower left corner. The shapes
+        below default to the points their ``radius`` values are
+        measured from:
+
+            * :py:class:`.Circle`
+            * :py:class:`.Ellipse`
+            * :py:class:`.Arc`
+            * :py:class:`.Sector`
+            * :py:class:`.Star`
+        """
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, rotation: float) -> None:
+        self._rotation = rotation
+        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
 
     def draw(self):
         """Draw the shape at its current position.
@@ -527,7 +544,7 @@ class Arc(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0,) * (self._segments + 1) * 4
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -551,22 +568,6 @@ class Arc(ShapeBase):
 
         self._vertex_list.position[:] = vertices
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the arc, in degrees.
-
-        The arc will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
     @property
     def angle(self):
         """The angle of the arc.
@@ -629,6 +630,7 @@ class BezierCurve(ShapeBase):
                 Optional parent group of the curve.
         """
         self._points = list(points)
+        self._x, self._y = self._points[0]
         self._t = t
         self._segments = segments
         self._num_verts = self._segments * 2
@@ -655,11 +657,11 @@ class BezierCurve(ShapeBase):
         self._vertex_list = self._group.program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._points[0]) * self._num_verts))
+            translation=('f', (self._x, self._y) * self._num_verts))
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0,) * self._segments * 4
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -762,7 +764,7 @@ class Circle(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0,) * self._segments * 6
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -858,7 +860,7 @@ class Ellipse(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0,) * self._num_verts * 6
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -902,22 +904,6 @@ class Ellipse(ShapeBase):
         self._b = value
         self._update_vertices()
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the arc, in degrees.
-
-        The arc will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
 
 class Sector(ShapeBase):
     def __init__(self, x, y, radius, segments=None, angle=math.tau, start_angle=0,
@@ -989,7 +975,7 @@ class Sector(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0,) * self._segments * 6
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -1048,22 +1034,6 @@ class Sector(ShapeBase):
         self._radius = value
         self._update_vertices()
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the sector, in degrees.
-
-        The sector will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
 
 class Line(ShapeBase):
     def __init__(self, x, y, x2, y2, width=1, color=(255, 255, 255, 255),
@@ -1114,11 +1084,11 @@ class Line(ShapeBase):
 
     def __contains__(self, point):
         assert len(point) == 2
-        vec_AB = Vec2(self._x2 - self._x, self._y2 - self._y)
-        vec_BA = Vec2(self._x - self._x2, self._y - self._y2)
-        vec_AP = Vec2(point[0] - self._x - self._anchor_x, point[1] - self._y + self._anchor_y)
-        vec_BP = Vec2(point[0] - self._x2 - self._anchor_x, point[1] - self._y2 + self._anchor_y)
-        if vec_AB.dot(vec_AP) * vec_BA.dot(vec_BP) < 0:
+        vec_ab = Vec2(self._x2 - self._x, self._y2 - self._y)
+        vec_ba = Vec2(self._x - self._x2, self._y - self._y2)
+        vec_ap = Vec2(point[0] - self._x - self._anchor_x, point[1] - self._y + self._anchor_y)
+        vec_bp = Vec2(point[0] - self._x2 - self._anchor_x, point[1] - self._y2 + self._anchor_y)
+        if vec_ab.dot(vec_ap) * vec_ba.dot(vec_bp) < 0:
             return False
 
         a, b = point[0] + self._anchor_x, point[1] - self._anchor_y
@@ -1137,7 +1107,7 @@ class Line(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            self._vertex_list.position[:] = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
         else:
             x1 = -self._anchor_x
             y1 = self._anchor_y - self._width / 2
@@ -1158,6 +1128,15 @@ class Line(ShapeBase):
 
             self._vertex_list.position[:] = (ax, ay,  bx, by,  cx, cy, ax, ay,  cx, cy,  dx, dy)
 
+    @property
+    def width(self):
+        return self._width
+
+    @width.setter
+    def width(self, width):
+        self._width = width
+        self._update_vertices()
+
     @property
     def x2(self):
         """Second X coordinate of the shape.
@@ -1242,7 +1221,7 @@ class Rectangle(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            self._vertex_list.position[:] = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
         else:
             x1 = -self._anchor_x
             y1 = -self._anchor_y
@@ -1277,22 +1256,6 @@ class Rectangle(ShapeBase):
         self._height = value
         self._update_vertices()
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the rectangle, in degrees.
-
-        The Rectangle will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
 
 class BorderedRectangle(ShapeBase):
     def __init__(self, x, y, width, height, border=1, color=(255, 255, 255),
@@ -1318,7 +1281,7 @@ class BorderedRectangle(ShapeBase):
                 as a tuple of 3 or 4 ints in the range of 0-255. RGB
                 colors will be treated as having an opacity of 255.
             `border_color` : (int, int, int, int)
-                The RGB or RGBA fill color of the rectangle, specified
+                The RGB or RGBA fill color of the border, specified
                 as a tuple of 3 or 4 ints in the range of 0-255. RGB
                 colors will be treated as having an opacity of 255.
 
@@ -1386,7 +1349,7 @@ class BorderedRectangle(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            self._vertex_list.position[:] = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
         else:
             bx1 = -self._anchor_x
             by1 = -self._anchor_y
@@ -1401,6 +1364,19 @@ class BorderedRectangle(ShapeBase):
             self._vertex_list.position[:] = (ix1, iy1, ix2, iy1, ix2, iy2, ix1, iy2,
                                              bx1, by1, bx2, by1, bx2, by2, bx1, by2)
 
+    @property
+    def border(self):
+        """The border width of the rectangle.
+
+        :return: float
+        """
+        return self._border
+
+    @border.setter
+    def border(self, width):
+        self._border = width
+        self._update_vertices()
+
     @property
     def width(self):
         """The width of the rectangle.
@@ -1427,22 +1403,6 @@ class BorderedRectangle(ShapeBase):
         self._height = value
         self._update_vertices()
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the rectangle, in degrees.
-
-        The Rectangle will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
     @property
     def border_color(self):
         """The rectangle's border color.
@@ -1505,6 +1465,122 @@ class BorderedRectangle(ShapeBase):
         self._update_color()
 
 
+class Box(ShapeBase):
+    def __init__(self, x, y, width, height, thickness=1, color=(255, 255, 255, 255), batch=None, group=None):
+        """Create an unfilled rectangular shape, with optional thickness.
+
+        The box's anchor point defaults to the (x, y) coordinates,
+        which are at the bottom left.
+        Changing the thickness of the box will extend the walls inward;
+        the outward dimesions will not be affected.
+
+        :Parameters:
+            `x` : float
+                The X coordinate of the box.
+            `y` : float
+                The Y coordinate of the box.
+            `width` : float
+                The width of the box.
+            `height` : float
+                The height of the box.
+            `thickness` : float
+                The thickness of the lines that make up the box.
+            `color` : (int, int, int, int)
+                The RGB or RGBA color of the box, specified as a tuple
+                of 3 or 4 ints in the range of 0-255. RGB colors will
+                be treated as having an opacity of 255.
+            `batch` : `~pyglet.graphics.Batch`
+                Optional batch to add the box to.
+            `group` : `~pyglet.graphics.Group`
+                Optional parent group of the box.
+        """
+        self._x = x
+        self._y = y
+        self._width = width
+        self._height = height
+        self._thickness = thickness
+
+        self._num_verts = 8
+
+        r, g, b, *a = color
+        self._rgba = r, g, b, a[0] if a else 255
+
+        program = get_default_shader()
+        self._batch = batch or Batch()
+        self._group = self.group_class(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, program, group)
+
+        self._create_vertex_list()
+        self._update_vertices()
+
+    def __contains__(self, point):
+        assert len(point) == 2
+        point = _rotate_point((self._x, self._y), point, math.radians(self._rotation))
+        x, y = self._x - self._anchor_x, self._y - self._anchor_y
+        return x < point[0] < x + self._width and y < point[1] < y + self._height
+
+    def _create_vertex_list(self):
+        #   3        6
+        #     2    7
+        #     1    4
+        #   0        5
+        indices = [0, 1, 2, 0, 2, 3, 0, 5, 4, 0, 4, 1, 4, 5, 6, 4, 6, 7, 2, 7, 6, 2, 6, 3]
+        self._vertex_list = self._group.program.vertex_list_indexed(
+            self._num_verts, self._draw_mode, indices, self._batch, self._group,
+            colors=('Bn', self._rgba * self._num_verts),
+            translation=('f', (self._x, self._y) * self._num_verts))
+
+    def _update_color(self):
+        self._vertex_list.colors[:] = self._rgba * self._num_verts
+
+    def _update_vertices(self):
+        if not self._visible:
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
+        else:
+
+            t = self._thickness
+            left = -self._anchor_x
+            bottom = -self._anchor_y
+            right = left + self._width
+            top = bottom + self._height
+
+            x1 = left
+            x2 = left + t
+            x3 = right - t
+            x4 = right
+            y1 = bottom
+            y2 = bottom + t
+            y3 = top - t
+            y4 = top
+                                             #  0   |   1   |   2   |   3   |   4   |   5   |   6   |   7
+            self._vertex_list.position[:] =  x1, y1, x2, y2, x2, y3, x1, y4, x3, y2, x4, y1, x4, y4, x3, y3
+
+    @property
+    def width(self):
+        """The width of the Box.
+
+        :type: float
+        """
+        return self._width
+
+    @width.setter
+    def width(self, value):
+        self._width = value
+        self._update_vertices()
+
+    @property
+    def height(self):
+        """The height of the Box.
+
+        :type: float
+        """
+        return self._height
+
+    @height.setter
+    def height(self, value):
+        self._height = value
+        self._update_vertices()
+
+
 class Triangle(ShapeBase):
     def __init__(self, x, y, x2, y2, x3, y3, color=(255, 255, 255, 255),
                  batch=None, group=None):
@@ -1565,7 +1641,7 @@ class Triangle(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            self._vertex_list.position[:] = (0, 0, 0, 0, 0, 0)
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
         else:
             x1 = -self._anchor_x
             y1 = -self._anchor_y
@@ -1693,7 +1769,7 @@ class Star(ShapeBase):
 
     def _update_vertices(self):
         if not self._visible:
-            vertices = (0, 0) * self._num_spikes * 6
+            vertices = (0, 0) * self._num_verts
         else:
             x = -self._anchor_x
             y = -self._anchor_y
@@ -1749,17 +1825,6 @@ class Star(ShapeBase):
         self._num_spikes = value
         self._update_vertices()
 
-    @property
-    def rotation(self):
-        """Rotation of the star, in degrees.
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
 
 class Polygon(ShapeBase):
     def __init__(self, *coordinates, color=(255, 255, 255, 255), batch=None, group=None):
@@ -1770,7 +1835,7 @@ class Polygon(ShapeBase):
         :Parameters:
             `coordinates` : List[[int, int]]
                 The coordinates for each point in the polygon.
-            `color` : (int, int, int)
+            `color` : (int, int, int, int)
                 The RGB or RGBA color of the polygon, specified as a
                 tuple of 3 or 4 ints in the range of 0-255. RGB colors
                 will be treated as having an opacity of 255.
@@ -1783,6 +1848,7 @@ class Polygon(ShapeBase):
         # len(self._coordinates) = the number of vertices and sides in the shape.
         self._rotation = 0
         self._coordinates = list(coordinates)
+        self._x, self._y = self._coordinates[0]
         self._num_verts = (len(self._coordinates) - 2) * 3
 
         r, g, b, *a = color
@@ -1804,11 +1870,11 @@ class Polygon(ShapeBase):
         self._vertex_list = self._group.program.vertex_list(
             self._num_verts, self._draw_mode, self._batch, self._group,
             colors=('Bn', self._rgba * self._num_verts),
-            translation=('f', (self._coordinates[0]) * self._num_verts))
+            translation=('f', (self._x, self._y) * self._num_verts))
 
     def _update_vertices(self):
         if not self._visible:
-            self._vertex_list.position[:] = tuple([0] * ((len(self._coordinates) - 2) * 6))
+            self._vertex_list.position[:] = (0, 0) * self._num_verts
         else:
             # Adjust all coordinates by the anchor.
             trans_x, trans_y = self._coordinates[0]
@@ -1824,21 +1890,6 @@ class Polygon(ShapeBase):
             # Flattening the list before setting vertices to it.
             self._vertex_list.position[:] = tuple(value for coordinate in triangles for value in coordinate)
 
-    @property
-    def rotation(self):
-        """Clockwise rotation of the polygon, in degrees.
-
-        The Polygon will be rotated about its (anchor_x, anchor_y)
-        position.
-
-        :type: float
-        """
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, rotation):
-        self._rotation = rotation
-        self._vertex_list.rotation[:] = (rotation,) * self._num_verts
-
 
-__all__ = 'Arc', 'BezierCurve', 'Circle', 'Ellipse', 'Line', 'Rectangle', 'BorderedRectangle', 'Triangle', 'Star', 'Polygon', 'Sector'
+__all__ = ('Arc', 'Box', 'BezierCurve', 'Circle', 'Ellipse', 'Line', 'Rectangle',
+           'BorderedRectangle', 'Triangle', 'Star', 'Polygon', 'Sector', 'ShapeBase')

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/sprite.py

@@ -146,25 +146,12 @@ fragment_array_source = """#version 150 core
 
 
 def get_default_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_sprite_default_shader
-    except AttributeError:
-        _default_vert_shader = graphics.shader.Shader(vertex_source, 'vertex')
-        _default_frag_shader = graphics.shader.Shader(fragment_source, 'fragment')
-        default_shader_program = graphics.shader.ShaderProgram(_default_vert_shader, _default_frag_shader)
-        pyglet.gl.current_context.pyglet_sprite_default_shader = default_shader_program
-        return pyglet.gl.current_context.pyglet_sprite_default_shader
-
+    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
+                                                    (fragment_source, 'fragment'))
 
 def get_default_array_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_sprite_default_array_shader
-    except AttributeError:
-        _default_vert_shader = graphics.shader.Shader(vertex_source, 'vertex')
-        _default_array_frag_shader = graphics.shader.Shader(fragment_array_source, 'fragment')
-        default_shader_program = graphics.shader.ShaderProgram(_default_vert_shader, _default_array_frag_shader)
-        pyglet.gl.current_context.pyglet_sprite_default_array_shader = default_shader_program
-        return pyglet.gl.current_context.pyglet_sprite_default_array_shader
+   return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
+                                                   (fragment_array_source, 'fragment'))
 
 
 class SpriteGroup(graphics.Group):

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

@@ -271,6 +271,8 @@ class DocumentLabel(layout.TextLayout):
 
     @color.setter
     def color(self, color):
+        r, g, b, *a = color
+        color = r, g, b, a[0] if a else 255
         self.document.set_style(0, len(self.document.text), {'color': color})
 
     @property

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/text/caret.py

@@ -98,7 +98,7 @@ class Caret:
 
         colors = r, g, b, self._visible_alpha, r, g, b, self._visible_alpha
 
-        self._list = self._group.program.vertex_list(2, gl.GL_LINES, batch, self._group, colors=('Bn', colors))
+        self._list = self._group.program.vertex_list(2, gl.GL_LINES, self._batch, self._group, colors=('Bn', colors))
         self._ideal_x = None
         self._ideal_line = None
         self._next_attributes = {}
@@ -127,6 +127,7 @@ class Caret:
 
         Also disconnects the caret from further layout events.
         """
+        clock.unschedule(self._blink)
         self._list.delete()
         self._layout.remove_handlers(self)