pyglet 2.0.9__zip → 2.0.10__zip

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/media/drivers/xaudio2/lib_xaudio2.py

@@ -192,17 +192,19 @@ XAUDIO2_NO_VIRTUAL_AUDIO_CLIENT = 0x10000   # Used in CreateMasteringVoice to cr
 class IXAudio2VoiceCallback(com.Interface):
     _methods_ = [
         ('OnVoiceProcessingPassStart',
-         com.STDMETHOD(UINT32)),
+         com.VOIDMETHOD(UINT32)),
         ('OnVoiceProcessingPassEnd',
-         com.STDMETHOD()),
-        ('onStreamEnd',
-         com.STDMETHOD()),
-        ('onBufferStart',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
+        ('OnStreamEnd',
+         com.VOIDMETHOD()),
+        ('OnBufferStart',
+         com.VOIDMETHOD(ctypes.c_void_p)),
         ('OnBufferEnd',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(ctypes.c_void_p)),
         ('OnLoopEnd',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(ctypes.c_void_p)),
+        ('OnVoiceError',
+         com.VOIDMETHOD(ctypes.c_void_p, HRESULT))
     ]
 
 
@@ -220,20 +222,9 @@ class XA2SourceCallback(com.COMObject):
     _interfaces_ = [IXAudio2VoiceCallback]
 
     def __init__(self, xa2_player):
+        super().__init__()
         self.xa2_player = xa2_player
 
-    def OnVoiceProcessingPassStart(self, bytesRequired):
-        pass
-
-    def OnVoiceProcessingPassEnd(self):
-        pass
-
-    def onStreamEnd(self):
-        pass
-
-    def onBufferStart(self, pBufferContext):
-        pass
-
     def OnBufferEnd(self, pBufferContext):
         """At the end of playing one buffer, attempt to refill again.
         Even if the player is out of sources, it needs to be called to purge all buffers.
@@ -241,10 +232,7 @@ class XA2SourceCallback(com.COMObject):
         if self.xa2_player:
             self.xa2_player.refill_source_player()
 
-    def OnLoopEnd(self, this, pBufferContext):
-        pass
-
-    def onVoiceError(self, this, pBufferContext, hresult):
+    def OnVoiceError(self, pBufferContext, hresult):
         raise Exception("Error occurred during audio playback.", hresult)
 
 
@@ -362,24 +350,18 @@ class IXAudio2MasteringVoice(IXAudio2Voice):
 class IXAudio2EngineCallback(com.Interface):
     _methods_ = [
         ('OnProcessingPassStart',
-         com.METHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
         ('OnProcessingPassEnd',
-         com.METHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
         ('OnCriticalError',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulong)),
+         com.VOIDMETHOD(HRESULT)),
     ]
 
 
 class XA2EngineCallback(com.COMObject):
     _interfaces_ = [IXAudio2EngineCallback]
 
-    def OnProcessingPassStart(self):
-        pass
-
-    def OnProcessingPassEnd(self):
-        pass
-
-    def OnCriticalError(self, this, hresult):
+    def OnCriticalError(self, hresult):
         raise Exception("Critical Error:", hresult)
 
 

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/media/player.py

@@ -109,7 +109,9 @@ class Player(pyglet.event.EventDispatcher):
         self._playlists = deque()
         self._audio_player = None
 
+        self._context = pyglet.gl.current_context
         self._texture = None
+
         # Desired play state (not an indication of actual state).
         self._playing = False
 
@@ -455,9 +457,12 @@ class Player(pyglet.event.EventDispatcher):
 
         image = source.get_next_video_frame()
         if image is not None:
-            if self._texture is None:
-                self._create_texture()
-            self._texture.blit_into(image, 0, 0, 0)
+
+            with self._context:
+                if self._texture is None:
+                    self._create_texture()
+                self._texture.blit_into(image, 0, 0, 0)
+
         elif bl.logger is not None:
             bl.logger.log("p.P.ut.1.8")
 

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/model/__init__.py

@@ -87,25 +87,12 @@ def load(filename, file=None, decoder=None, batch=None, group=None):
 
 
 def get_default_shader():
-    try:
-        return pyglet.gl.current_context.model_default_plain_shader
-    except AttributeError:
-        vert_shader = shader.Shader(MaterialGroup.default_vert_src, 'vertex')
-        frag_shader = shader.Shader(MaterialGroup.default_frag_src, 'fragment')
-        default_shader_program = shader.ShaderProgram(vert_shader, frag_shader)
-        pyglet.gl.current_context.model_default_plain_shader = default_shader_program
-        return pyglet.gl.current_context.model_default_plain_shader
-
+    return pyglet.gl.current_context.create_program((MaterialGroup.default_vert_src, 'vertex'),
+                                                    (MaterialGroup.default_frag_src, 'fragment'))
 
 def get_default_textured_shader():
-    try:
-        return pyglet.gl.current_context.model_default_textured_shader
-    except AttributeError:
-        vert_shader = shader.Shader(TexturedMaterialGroup.default_vert_src, 'vertex')
-        frag_shader = shader.Shader(TexturedMaterialGroup.default_frag_src, 'fragment')
-        default_shader_program = shader.ShaderProgram(vert_shader, frag_shader)
-        pyglet.gl.current_context.model_default_textured_shader = default_shader_program
-        return current_context.model_default_textured_shader
+    return pyglet.gl.current_context.create_program((TexturedMaterialGroup.default_vert_src, 'vertex'),
+                                                    (TexturedMaterialGroup.default_frag_src, 'fragment'))
 
 
 class Model:

{pyglet-2.0.9 → 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.
@@ -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,7 +657,7 @@ 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:
@@ -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,
@@ -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),
@@ -1286,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),
@@ -1449,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.
@@ -1527,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):
@@ -1771,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):
@@ -1805,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
@@ -1826,7 +1870,7 @@ 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:
@@ -1846,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.9 → 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.9 → 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.9 → 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)