pyglet-desper 0.10.0__tar.gz

pyglet_desper-0.10.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Francesco Mistri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyglet_desper-0.10.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: pyglet-desper
+Version: 0.10.0
+Summary: Extension package for desper and pyglet interoperation
+Home-page: https://github.com/Ball-Man/pyglet-desper
+Author: Francesco Mistri
+Author-email: franc.mistri@gmail.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: desper>=1.1.1
+Requires-Dist: pyglet<2.1,>=2.0.0
+
+![desper logo](https://github.com/Ball-Man/pyglet-desper/blob/master/assets/desper-logo-raw.png?raw=true)
+
+# Desper + Pyglet interoperation
+Combine resource and logic management of [desper](https://github.com/Ball-Man/desper]) with [pyglet](https://github.com/pyglet/pyglet)'s rendering and media.
+
+## Installation
+Simple installation from PyPi (recommended):
+```
+pip install pyglet-desper
+```
+Or installation from master branch:
+```
+git clone https://github.com/Ball-Man/pyglet-desper
+cd pyglet-desper
+pip install .
+```
+
+
+## Project status
+Docs and a user guide are in the making.

pyglet_desper-0.10.0/README.md

@@ -0,0 +1,20 @@
+![desper logo](https://github.com/Ball-Man/pyglet-desper/blob/master/assets/desper-logo-raw.png?raw=true)
+
+# Desper + Pyglet interoperation
+Combine resource and logic management of [desper](https://github.com/Ball-Man/desper]) with [pyglet](https://github.com/pyglet/pyglet)'s rendering and media.
+
+## Installation
+Simple installation from PyPi (recommended):
+```
+pip install pyglet-desper
+```
+Or installation from master branch:
+```
+git clone https://github.com/Ball-Man/pyglet-desper
+cd pyglet-desper
+pip install .
+```
+
+
+## Project status
+Docs and a user guide are in the making.

pyglet_desper-0.10.0/pyglet_desper/__init__.py

@@ -0,0 +1,3 @@
+from .loop import *             # NOQA
+from .logic import *            # NOQA
+from .model import *            # NOQA

pyglet_desper-0.10.0/pyglet_desper/logic/__init__.py

@@ -0,0 +1,279 @@
+import math
+from typing import Optional
+
+import desper
+import pyglet
+from pyglet.gl import GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
+
+from .sync import *             # NOQA
+
+ON_CAMERA_DRAW_EVENT_NAME = 'on_camera_draw'
+
+
+@desper.event_handler('on_switch_in', 'on_switch_out', 'on_add')
+class Sprite(pyglet.sprite.Sprite):
+    """Specialized sprite for better integration into desper.
+
+    In particular, it listens to some events in order to schedule
+    animations correctly. See module :mod:`pyglet.sprite` to know
+    more about sprites.
+
+    This assumes that the default event workflow is being followed.
+    That is: world dispatching is disabled after creation and
+    enabled just when it is used as current world (i.e. with
+    :func:`desper.switch`).
+    """
+
+    def __init__(self,
+                 img, x=0, y=0, z=0,
+                 blend_src=GL_SRC_ALPHA,
+                 blend_dest=GL_ONE_MINUS_SRC_ALPHA,
+                 batch=None,
+                 group=None,
+                 subpixel=False):
+        super().__init__(img, x, y, z, blend_src, blend_dest, batch, group,
+                         subpixel)
+        # Pause at creation to prevent global clock from scheduling it
+        if self._animation is not None:
+            self.paused = True
+
+    __init__.__doc__ = pyglet.sprite.Sprite.__init__.__doc__
+
+    def on_add(self, entity, world: desper.World):
+        """Start animation."""
+        if self._animation is not None:
+            self.paused = False
+
+    def on_switch_in(self, world_from: desper.World, world_to: desper.World):
+        """Start animation."""
+        if self._animation is not None:
+            self.paused = False
+
+    def on_switch_out(self, world_from: desper.World, world_to: desper.World):
+        """Stop animation."""
+        if self._animation is not None:
+            self.paused = True
+
+
+@desper.event_handler('on_switch_in', 'on_switch_out', 'on_add')
+class AdvancedSprite(pyglet.sprite.AdvancedSprite):
+    """Specialized advanced sprite for better integration into desper.
+
+    Being an advanced sprite, it is possible to specify its shader
+    program at any time through the :attr:`program` attribute (see
+    :class:`pyglet.sprite.AdvancedSprite`).
+
+    In particular, it listens to some events in order to schedule
+    animations correctly. See module :mod:`pyglet.sprite` to know
+    more about sprites.
+
+    This assumes that the default event workflow is being followed.
+    That is: world dispatching is disabled after creation and
+    enabled just when it is used as current world (i.e. with
+    :func:`desper.switch`).
+    """
+
+    def __init__(self,
+                 img, x=0, y=0, z=0,
+                 blend_src=GL_SRC_ALPHA,
+                 blend_dest=GL_ONE_MINUS_SRC_ALPHA,
+                 batch=None,
+                 group=None,
+                 subpixel=False,
+                 program=None):
+        super().__init__(img, x, y, z, blend_src, blend_dest, batch, group,
+                         subpixel, program)
+        # Pause at creation to prevent global clock from scheduling it
+        if self._animation is not None:
+            self.paused = True
+
+    __init__.__doc__ = pyglet.sprite.Sprite.__init__.__doc__
+
+    def on_add(self, entity, world: desper.World):
+        """Start animation."""
+        if self._animation is not None:
+            self.paused = False
+
+    def on_switch_in(self, world_from: desper.World, world_to: desper.World):
+        """Start animation."""
+        if self._animation is not None:
+            self.paused = False
+
+    def on_switch_out(self, world_from: desper.World, world_to: desper.World):
+        """Stop animation."""
+        if self._animation is not None:
+            self.paused = True
+
+
+@desper.event_handler(ON_CAMERA_DRAW_EVENT_NAME)
+class Camera:
+    """Render content of a :class:`pyglet.graphics.Batch`.
+
+    Apply the given projection and viewport before rendering. If
+    omitted, projection and viewport will be set as window defaults
+    (from pyglet), that is:
+
+    - orthogonal projection that maps to the window pixel size, with
+        origin (0, 0) at the bottom-left corner
+    - viewport equal to: ``0, 0, window.width, window.height``
+
+    A projection matrix can be easily obtained through
+    :meth:`desper.math.Mat4.orthogonal_projection` (2D) or through
+    :meth:`desper.math.Mat4.perspective_projection` (3D).
+
+    Viewport can be manually constructed and shall be a tuple in the
+    form ``(x, y, width, height)`` (:class:`desper.math.Vec4` is
+    supported).
+
+    A :class:`pyglet.window.Window` can be specified and shall be taken
+    as target of these transformations. In case of single window
+    applications this is unnecessary and the main window will be
+    automatically retrieven.
+    """
+
+    def __init__(self, batch: pyglet.graphics.Batch,
+                 projection: Optional[desper.math.Mat4] = None,
+                 viewport: Optional[tuple[int, int, int, int]] = None,
+                 window: Optional[pyglet.window.Window] = None):
+        self.batch = batch
+
+        self.window: pyglet.window.Window = window
+        if window is None:
+            assert len(pyglet.app.windows), (
+                'Unable to find an open window')
+            self.window = next(iter(pyglet.app.windows))
+
+        self.projection: desper.math.Mat4 = projection
+        if projection is None:
+            self.projection = self.window.projection
+
+        self.viewport: tuple[int, int, int, int] = viewport
+        if viewport is None:
+            self.viewport = self.window.viewport
+
+        # View transformation matrix
+        self.view = desper.math.Mat4()
+
+    def on_camera_draw(self):
+        """Event handler: apply projection, view and viewport, render."""
+        self.window.projection = self.projection
+        self.window.viewport = self.viewport
+        self.window.view = self.view
+
+        self.batch.draw()
+
+
+@desper.event_handler('on_draw')
+class CameraProcessor(desper.Processor):
+    """Render all cameras (:class:`Camera`).
+
+    Despite being a :class:`desper.Processor` subclass, no action
+    is done during :meth:`process`. The possibility to add it as a
+    processor in a :class:`World` is pure convenience, but adding it
+    as component in an entity (any entity) works just fine.
+
+    All the logic take place in the
+    :meth:`on_draw` method, which is a handler for the homonymous pyglet
+    connected event.
+
+    Rendering is done by dispatchment of
+    :attr:`ON_CAMERA_DRAW_EVENT_NAME` event. :class:`Camera` and
+    eventual custom objects handle this event and render accordingly.
+
+    A :class:`pyglet.window.Window` can be specified and shall be taken
+    as target of these transformations. In case of single window
+    applications this is unnecessary and the main window will be
+    automatically retrieven.
+    """
+
+    def __init__(self, window: Optional[pyglet.window.Window] = None):
+        self.window = window
+        if window is None:
+            assert len(pyglet.app.windows), (
+                'Unable to find an open window')
+            self.window = next(iter(pyglet.app.windows))
+
+    def on_draw(self):
+        """Event handler: clear window and render all cameras.
+
+        Rendering is done by dispatchment of
+        :attr:`ON_CAMERA_DRAW_EVENT_NAME`.
+        """
+        self.window.clear()
+        self.world.dispatch(ON_CAMERA_DRAW_EVENT_NAME)
+
+    def process(self, dt):
+        """No implementation needed."""
+        pass
+
+
+@desper.event_handler(desper.ON_POSITION_CHANGE_EVENT_NAME,
+                      desper.ON_ROTATION_CHANGE_EVENT_NAME,
+                      desper.ON_SCALE_CHANGE_EVENT_NAME)
+class CameraTransform2D(desper.Controller):
+    """Synchronize :class:`Camera` with :class:`desper.Transform2D`.
+
+    A :class:`Camera`s internal :attr:`Camera.view` matrix is updated
+    based on the entity's :class:`desper.Transform2D`.
+    Requires to be in the same desper entity of both the camera and the
+    transform component.
+    """
+    transform: desper.Transform2D = desper.ComponentReference(
+        desper.Transform2D)
+    camera: Camera = desper.ComponentReference(Camera)
+
+    # Cached matrices for faster recalculations
+    _translation_matrix = desper.math.Mat4()
+    _rotation_matrix = desper.math.Mat4()
+    _scale_matrix = desper.math.Mat4()
+
+    def on_add(self, entity, world):
+        """Setup transform event handling."""
+        super().on_add(entity, world)
+
+        assert self.transform is not None and self.camera is not None, (
+            'Both a Transform component and a Camera component '
+            'are required to be in the same entity in order for '
+            f'{type(self)} to work.')
+
+        transform = self.transform
+        transform.add_handler(self)
+
+        self._translation_matrix = desper.math.Mat4.from_translation(
+            (*-transform.position, 0.))
+        self._rotation_matrix = desper.math.Mat4.from_rotation(
+            math.radians(transform.rotation), (0., 0., 1.))
+        self._scale_matrix = desper.math.Mat4.from_scale(
+            (*transform.scale, 1.))
+
+        self.camera.view = self.get_view_matrix()
+
+    def get_view_matrix(self) -> desper.math.Mat4:
+        """Compute view matrix.
+
+        Each query computes the matrix product between rotation,
+        translation and scale matrix.
+        """
+        return (self._scale_matrix @ self._translation_matrix
+                @ self._rotation_matrix)
+
+    def on_position_change(self, new_position: desper.math.Vec2):
+        """Event handler: update translation matrix and camera."""
+        self._translation_matrix = desper.math.Mat4.from_translation(
+            (*-new_position, 0.))
+
+        self.camera.view = self.get_view_matrix()
+
+    def on_rotation_change(self, new_rotation: float):
+        """Event handler: update rotation matrix and camera."""
+        self._rotation_matrix = desper.math.Mat4.from_rotation(
+            math.radians(new_rotation), (0., 0., 1.))
+
+        self.camera.view = self.get_view_matrix()
+
+    def on_scale_change(self, new_scale: desper.math.Vec2):
+        """Event handler: update scale matrix and camera."""
+        self._scale_matrix = desper.math.Mat4.from_scale(
+            (*new_scale, 1.))
+
+        self.camera.view = self.get_view_matrix()

pyglet_desper-0.10.0/pyglet_desper/logic/sync.py

@@ -0,0 +1,293 @@
+"""Synchronize pyglet graphics with desper ``Transform`` components.
+
+High level graphic abstractions in pyglet (e.g. ``Sprite``) make use
+of specific properties to handle and transform vertices. Most commonly,
+positional properties (``Sprite.x``, ``Sprite.y``, etc.).
+Due to the variety of existing graphical classes, the risk in handling
+these properties directly is the injection in the project's
+structure of strong dependencies based on pyglet objects and types.
+
+To prevent this, a connection (or synchronization) between pyglet
+classes and :class:`desper.Transform2D` is proposed (as pyglet
+abstractions are mostly 2D, 3D support will be discussed in the future).
+"""
+import desper
+import pyglet
+
+
+@desper.event_handler(desper.ON_REMOVE_EVENT_NAME)
+class GraphicSync2D(desper.Controller):
+    """Base class for pyglet graphical components synchronization.
+
+    It encapsules management of position, rotation and scale by using
+    the most common related pyglet properites, synchronizing them
+    with the :class:`desper.Transform2D`. In particular:
+
+    - ``x`` and ``y`` for updating position.
+    - ``rotation`` for updating rotation.
+    - ``scale_x`` and ``scale_y`` for updating scale.
+
+    Even though all these interactions are defined, they are not
+    enabled. In fact, this component does nothing on its own, but
+    defines base behaviours that can be exploited by specialized
+    subclasses. This is done since not all the graphical components
+    support the same transformations. Actually, most of them only
+    support repositioning with ``x`` and ``y``, or with
+    the ``position`` tuple.
+
+    In particular, to enable a connection
+    with :class:`desper.Transform2D` it is advisable to subclass this
+    component and apply to it the :func:`desper.event_handler`
+    decorator, enabling the desired event connections (any of
+    :attr:`desper.ON_POSITION_CHANGE_EVENT_NAME`,
+    :attr:`desper.ON_ROTATION_CHANGE_EVENT_NAME`,
+    :attr:`desper.ON_SCALE_CHANGE_EVENT_NAME`, i.e.
+    ``'on_position_change'``, ``'on_rotation_change'``,
+    ``'on_scale_change'``). Override homonymous methods to define
+    custom behaviour.
+
+    Moreover, the :attr:`desper.ON_REMOVE_EVENT_NAME`
+    (i.e. ``'on_remove'``) event is automatically handled, calling on
+    the referred graphical component the :func:`delete` method
+    (e.g. :meth:`pyglet.Sprite.delete`), which is fundamental to
+    correctly delete vertices of graphical components when removed in
+    real time.
+    """
+    deleted = False
+
+    def __init__(self, component_type: type):
+        self.component_type = component_type
+
+    def on_add(self, entity, world: desper.World):
+        """Subscribe to :class:`desper.Transform2D` for events."""
+        super().on_add(entity, world)
+
+        transform = world.get_component(entity, desper.Transform2D)
+        assert transform is not None, (
+            'A Transform2D component must be added first '
+            f'for {self.__class__} to work')
+        transform.add_handler(self)
+
+        # Apply immediately supported transformations
+        if desper.ON_POSITION_CHANGE_EVENT_NAME in self.__events__:
+            self.on_position_change(transform.position)
+
+        if desper.ON_ROTATION_CHANGE_EVENT_NAME in self.__events__:
+            self.on_rotation_change(transform.rotation)
+
+        if desper.ON_SCALE_CHANGE_EVENT_NAME in self.__events__:
+            self.on_scale_change(transform.scale)
+
+    def on_remove(self, entity, world: desper.World):
+        """Clear vertices from memory."""
+        if not self.deleted:
+            self.deleted = True
+            self.get_component(self.component_type).delete()
+
+    def on_position_change(self, new_position: desper.math.Vec2):
+        """Event handler: update graphical component position."""
+        self.get_component(self.component_type).position = new_position
+
+    def on_rotation_change(self, new_rotation: float):
+        """Event handler: update graphical component rotation."""
+        self.get_component(self.component_type).rotation = new_rotation
+
+    def on_scale_change(self, new_scale: desper.math.Vec2):
+        """Event handler: update graphical component's scale.
+
+        Possibly only supported by :class:`pyglet.sprite.Sprite`.
+        """
+        self.get_component(self.component_type).update(scale_x=new_scale[0],
+                                                       scale_y=new_scale[1])
+
+
+@desper.event_handler(desper.ON_POSITION_CHANGE_EVENT_NAME,
+                      desper.ON_ROTATION_CHANGE_EVENT_NAME,
+                      desper.ON_SCALE_CHANGE_EVENT_NAME)
+class SpriteSync(GraphicSync2D):
+    """Synchronize :class:`desper.Transform2D` with pyglet ``Sprite``.
+
+    Handles all transformation events.
+
+    The :attr:`desper.ON_REMOVE_EVENT_NAME`
+    (i.e. ``'on_remove'``) event is automatically handled, calling on
+    the referred ``Sprite`` component the :func:`delete` method,
+    which is fundamental to correctly delete vertices of graphical
+    components when removed in real time.
+
+    This also means that ideally a ``Sprite`` instance and its
+    associated ``SpriteSync`` shall be added, removed from the world in
+    an entangled fashion.
+
+    Target class (``component_type``) defaults to
+    :class:`pyglet.sprite.Sprite`, but can be specialized to get
+    extra performance during component resolution (e.g. by specifying
+    :class:`pyglet-desper.Sprite`).
+
+    See :class:`GraphicSync2D` for more info.
+    """
+
+    def __init__(self, component_type: type = pyglet.sprite.Sprite):
+        super().__init__(component_type)
+
+    def on_add(self, entity, world):
+        """Custom handler for better performance."""
+        self.entity = entity
+        self.world = world
+
+        transform = world.get_component(entity, desper.Transform2D)
+        assert transform is not None, (
+            'A Transform2D component must be added first '
+            f'for {self.__class__} to work')
+        transform.add_handler(self)
+
+        # Apply immediately supported transformations
+        # Stack them and apply in one go for better performance
+        transformations = {}
+
+        transformations['x'] = transform.position[0]
+        transformations['y'] = transform.position[1]
+
+        transformations['rotation'] = transform.rotation
+
+        transformations['scale_x'] = transform.scale[0]
+        transformations['scale_y'] = transform.scale[1]
+
+        self.get_component(self.component_type).update(**transformations)
+
+    def on_position_change(self, new_position: desper.math.Vec2):
+        """Event handler: update graphical component position."""
+        self.get_component(self.component_type).position = (*new_position, 0.)
+
+
+@desper.event_handler(desper.ON_POSITION_CHANGE_EVENT_NAME)
+class PositionSync2D(GraphicSync2D):
+    """Synchronize :class:`desper.Transform2D` position with graphics.
+
+    Handles the :attr:`desper.ON_POSITION_CHANGE_EVENT_NAME` event.
+
+    The :attr:`desper.ON_REMOVE_EVENT_NAME`
+    (i.e. ``'on_remove'``) event is automatically handled, calling on
+    the referred graphical component the :func:`delete` method,
+    which is fundamental to correctly delete vertices of graphical
+    components when removed in real time.
+
+    This also means that ideally a graphical instance and its
+    associated ``PositionSync2D`` shall be added, removed from the world
+    in an entangled fashion.
+
+    See :class:`GraphicSync2D` for more info.
+    """
+
+
+@desper.event_handler(desper.ON_POSITION_CHANGE_EVENT_NAME,
+                      desper.ON_ROTATION_CHANGE_EVENT_NAME)
+class PositionRotationSync2D(GraphicSync2D):
+    """Same as :class:`PositionSync2D` but also synchronizes rotation.
+
+    See :class:`PositionSync2D`.
+    """
+
+
+def arc_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Arc`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Arc)
+
+
+def circle_sync_component() -> PositionSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Circle`s.
+
+    See :class:`PositionSync2D`.
+    """
+    return PositionSync2D(pyglet.shapes.Circle)
+
+
+def ellipse_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Ellipse`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Ellipse)
+
+
+def sector_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Sector`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Sector)
+
+
+def line_sync_component() -> PositionSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Line`s.
+
+    See :class:`PositionSync2D`.
+    """
+    return PositionSync2D(pyglet.shapes.Line)
+
+
+def rectangle_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Rectangle`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Rectangle)
+
+
+def borderedrectangle_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.BorderedRectangle`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.BorderedRectangle)
+
+
+def triangle_sync_component() -> PositionSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Triangle`s.
+
+    See :class:`PositionSync2D`.
+    """
+    return PositionSync2D(pyglet.shapes.Triangle)
+
+
+def star_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Star`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Star)
+
+
+def polygon_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.shapes.Polygon`s.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.shapes.Polygon)
+
+
+def htmllabel_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.text.HTMLLabel`.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.text.HTMLLabel)
+
+
+def documentlabel_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.text.DocumentLabel`.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.text.DocumentLabel)
+
+
+def label_sync_component() -> PositionRotationSync2D:
+    """Get a sync component for :class:`pyglet.text.Label`.
+
+    See :class:`PositionRotationSync2D`.
+    """
+    return PositionRotationSync2D(pyglet.text.Label)