pyglet 2.1.3__tar.gz → 2.1.5__tar.gz

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

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

{pyglet-2.1.3 → pyglet-2.1.5}/RELEASE_NOTES

@@ -1,3 +1,24 @@
+pyglet 2.1.5
+
+Changes
+-------
+- docs: Add shape guide crossrefs (#1291)
+- Updated the opengl torus example to work with the material updates in 3.1 (#1281)
+- Add homebrew lib search location for Apple Silicon.
+- Bump Qt example to use PySide6 and PyQt6 (#1305)
+
+Bugfixes
+--------
+- shapes.earcut: Fix int casting bug for large polygons (#1282)
+- Linux: Use dotclock instead of rate in xlib vidmoderestore (#1285)
+- tests: Fix many interactive tests, and other test fixes
+- app: Fix run(None) crashing on macOS
+- docs: Correct the docstring for the start_angle of an arc to indicate it is in degrees and not radians (#1290)
+- controller: Fix dpad bias for controller.min > 0 (#1296)
+- controller: Only use 0x1 desktop page axis for controller indexing on macOS (#1297)
+- gui: Fix the position range of the slider knob when repositioning the slider (#1299)
+
+
 pyglet 2.1.3
 
 Changes

{pyglet-2.1.3 → pyglet-2.1.5}/contrib/qt_sprite_preview.py

@@ -1,44 +1,45 @@
 """An example sprite previewer using Qt and pyglet together.
 
 It allows you to edit the fragment and vertex shaders, then compile them
-to get a live view. Errors and success will be printed to the console.
-A brief feature overview is located after the license notes below.
-
+to get a live view. Errors and success will be printed to the console. Users
+running GNOME on Linux may need the --use-qt-file-dialog flag to prevent invisible
+window issues. A brief feature overview is located after the license notes below.
 
 Important license notes:
 
 1. Libraries can use licenses which impose requirements beyond those of
    pyglet's BSD-style style license.
-2. This example defaults to using PySide2 by default, but can also use
-   PyQt5 due to their nearly-identical APIs.
-3. PySide2 uses the LGPL license while PyQt5 uses a GPL / commercial
+2. This example defaults to using PySide6 by default, but can also use
+   PyQt6 due to their nearly-identical APIs.
+3. PySide6 uses the LGPL license while PyQt6 uses a GPL / commercial
    dual-license approach.
 
 To the best knowledge of the contributors, this example and derivatives
 are only obligated to meet the restrictions of the LGPL because it does
-not use any PyQt5-specific features. Please see the following for more
+not use any PyQt6-specific features. Please see the following for more
 information:
 
 * The licenses and documentation for the libraries you plan to use
-* https://www.pythonguis.com/faq/pyqt5-vs-pyside2/
+* This guide for prior versions of PySide and PyQt:
+  thttps://www.pythonguis.com/faq/pyqt5-vs-pyside2/
 
-If you need additional certainty, please consult a legal professional.
+For additional certainty, please consult a legal professional.
 
 
 Example features:
 
 You can choose the current Qt binding in two ways:
 
-1. Add PySide2 or PyQt5 as the first argument after the launch command
+1. Add PySide6 or PyQt6 as the first argument after the launch command
    when running the script in the terminal
-2. Set the PYGLET_QT_BACKEND environment variable to either PySide2 or
-   PyQt5.
+2. Set the PYGLET_QT_BACKEND environment variable to either PySide6 or
+   PyQt6.
 
 The priority order is:
 
 1. positional argument
 2. environment variable
-3. default to PySide2
+3. default to PySide6
 
 To load images, choose File -> Open Image.
 
@@ -65,17 +66,17 @@ from typing import TYPE_CHECKING, Final, Mapping
 # Constants for choosing a Qt backend and summarizing their licensing
 ENV_VARIABLE: Final[str] = 'PYGLET_QT_BACKEND'
 
-PYSIDE2: Final[str] = 'PySide2'
-PYQT5: Final[str] = 'PyQt5'
+PYSIDE6: Final[str] = 'PySide6'
+PYQT6: Final[str] = 'PyQt6'
 
 valid_backends: Final[dict[str, str]] = {
-    PYSIDE2: "LGPL; may allow releasing under non-GPL licenses",
-    PYQT5: "Dual GPL / Commercial license; requires GPL or a fee",
+    PYSIDE6: "LGPL; may allow releasing under non-GPL licenses",
+    PYQT6: "Dual GPL / Commercial license; requires GPL or a fee",
 }
 
-# Default to PySide2 as part of allowing non-GPL licenses
+# Default to PySide6 as part of allowing non-GPL licenses
 # This is necessary but not sufficient to allow this.
-DEFAULT: Final[str] = PYSIDE2
+DEFAULT: Final[str] = PYSIDE6
 
 
 # Argument parser for run-time config as __main__
@@ -83,8 +84,8 @@ parser = argparse.ArgumentParser(
     description=dedent("""\
     A sprite & shader previewer using Qt and pyglet together.
 
-    It defaults to PySide2, but can run on PyQt5. The details of how may
-    be helpful to users who want to avoid spreading PyQt5's GPL license
+    It defaults to PySide6, but can run on PyQt6. The details of how may
+    be helpful to users who want to avoid spreading PyQt6's GPL license
     while using it as a fallback. See the docstrings and comments in the
     source to learn more.
     """),
@@ -138,19 +139,21 @@ print(f"Selected {backend} as the Qt binding from the {reason}'s value.")
 # Perform UI imports according to the detected configuration
 import pyglet
 
-# Use PySide2 for type checking, static analysis, tests, and linting
-# to help avoid infection by PyQt5's GPL license since tools will mark
-# uses of PyQt5-specific features as missing. For example, pyright is
+# Use PySide6 for type checking, static analysis, tests, and linting
+# to help avoid infection by PyQt6's GPL license since tools will mark
+# uses of PyQt6-specific features as missing. For example, pyright is
 # one of the strict type checking and linting tools which can help.
-if TYPE_CHECKING or backend == PYSIDE2:
-    from PySide2 import QtCore, QtWidgets
-    from PySide2.QtGui import QWheelEvent
-    from PySide2.QtWidgets import QFileDialog, QOpenGLWidget
-
-elif backend == PYQT5:
-    from PyQt5 import QtCore, QtWidgets
-    from PyQt5.QtGui import QWheelEvent
-    from PyQt5.QtWidgets import QFileDialog, QOpenGLWidget
+if TYPE_CHECKING or backend == PYSIDE6:
+    from PySide6 import QtCore, QtWidgets, QtGui
+    from PySide6.QtGui import QWheelEvent
+    from PySide6.QtWidgets import QFileDialog
+    from PySide6.QtOpenGLWidgets import QOpenGLWidget
+
+elif backend == PYQT6:
+    from PyQt6 import QtCore, QtWidgets, QtGui
+    from PyQt6.QtGui import QWheelEvent
+    from PyQt6.QtWidgets import QFileDialog
+    from PyQt6.QtOpenGLWidgets import QOpenGLWidget
 
 else:  # Handle import edge cases
     raise ValueError(
@@ -348,7 +351,7 @@ class Ui_MainWindow:
         self.sprite = None
         self.program = None
 
-    def get_file_dialog_options(self) -> QFileDialog.Options:
+    def get_file_dialog_options(self) -> QFileDialog.Option:
         """Convert instance attributes to a file dialog options object.
 
         At the moment, it supports choosing which dialog to use. This is
@@ -358,9 +361,9 @@ class Ui_MainWindow:
         You may want to expand on this in your own application with
         additional options.
         """
-        options = QFileDialog.Options()
+        options = QFileDialog.Option()
         if not self.use_native_file_dialog:
-            options |= QFileDialog.DontUseNativeDialog
+            options |= QFileDialog.Option.DontUseNativeDialog
 
         return options
 
@@ -383,7 +386,10 @@ class Ui_MainWindow:
         self.verticalLayout = QtWidgets.QVBoxLayout()
         self.verticalLayout.setObjectName("verticalLayout")
         self.label = QtWidgets.QLabel(self.centralwidget)
-        self.label.setAlignment(QtCore.Qt.AlignLeading | QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
+        self.label.setAlignment(
+            QtCore.Qt.AlignmentFlag.AlignLeading
+            | QtCore.Qt.AlignmentFlag.AlignLeft
+            | QtCore.Qt.AlignmentFlag.AlignVCenter)
         self.label.setObjectName("label")
         self.verticalLayout.addWidget(self.label)
         self.vertex_source_edit = QtWidgets.QTextEdit(self.centralwidget)
@@ -428,23 +434,23 @@ class Ui_MainWindow:
         MainWindow.setStatusBar(self.statusbar)
 
         # Add menu bar menus, entries, and hotkeys
-        self.actionOpen_Image = QtWidgets.QAction(MainWindow)
+        self.actionOpen_Image = QtGui.QAction(MainWindow)
         self.actionOpen_Image.setObjectName("actionOpen_Image")
         self.actionOpen_Image.triggered.connect(self.loadImages)
         self.actionOpen_Image.setShortcut("Ctrl+I")
 
-        self.actionOpen_Shader = QtWidgets.QAction(MainWindow)
+        self.actionOpen_Shader = QtGui.QAction(MainWindow)
         self.actionOpen_Shader.setObjectName("actionOpen_Shader")
         self.actionOpen_Shader.triggered.connect(self.loadShaders)
         self.actionOpen_Shader.setShortcut("Ctrl+O")
 
-        self.actionSave_Shader = QtWidgets.QAction(MainWindow)
+        self.actionSave_Shader = QtGui.QAction(MainWindow)
         self.actionSave_Shader.setObjectName("actionSave_Shader")
         self.actionSave_Shader.triggered.connect(self.saveShaders)
         self.actionSave_Shader.setStatusTip('Saves both Shader Files')
         self.actionSave_Shader.setShortcut("Ctrl+S")
 
-        self.actionExit = QtWidgets.QAction(MainWindow)
+        self.actionExit = QtGui.QAction(MainWindow)
         self.actionExit.triggered.connect(self.closeProgram)
         self.actionExit.setObjectName("actionExit")
         self.menuFile.addAction(self.actionOpen_Image)
@@ -457,7 +463,7 @@ class Ui_MainWindow:
 
         self.imageMenu = QtWidgets.QMenu(self.menubar)
         self.imageMenu.setObjectName("imageMenu")
-        self.noImageAction = QtWidgets.QAction(MainWindow)
+        self.noImageAction = QtGui.QAction(MainWindow)
         self.noImageAction.setDisabled(True)
         self.imageMenu.addAction(self.noImageAction)
 
@@ -518,7 +524,7 @@ class Ui_MainWindow:
             if not self.images:
                 self.imageMenu.removeAction(self.noImageAction)
 
-            action = QtWidgets.QAction(self._window)
+            action = QtGui.QAction(self._window)
             shader_name = f"sprite_texture{len(self.images)}"
             action.setText(f"{os.path.basename(fileName)} ({shader_name})")
             action.fileName = fileName
@@ -565,7 +571,7 @@ class Ui_MainWindow:
             vert_filename.write_text(self.vertex_source_edit.toPlainText())
             frag_filename.write_text(self.fragSourceEdit.toPlainText())
 
-    def removeImage(self, actionWidget: QtWidgets.QAction) -> None:
+    def removeImage(self, actionWidget: QtGui.QAction) -> None:
         if self.imageMenu:
             self.imageMenu.removeAction(actionWidget)
 
@@ -775,4 +781,4 @@ if __name__ == "__main__":
     sys.excepthook = excepthook
 
     # Start the application and return its exit code
-    sys.exit(app.exec_())
+    sys.exit(app.exec())

{pyglet-2.1.3 → pyglet-2.1.5}/doc/programming_guide/mouse.rst

@@ -6,6 +6,8 @@ All pyglet windows can receive input from a 3 button mouse with a
 operating system, but you can override this and request either a different
 cursor shape or provide your own image or animation.
 
+.. _guide_mouse_events:
+
 Mouse events
 ------------
 

pyglet-2.1.5/doc/programming_guide/shapes.rst

@@ -0,0 +1,162 @@
+Drawing Shapes
+==============
+
+.. _guide_shapes:
+
+
+The :py:mod:`~pyglet.shapes` module is an easy to use option for creating
+and manipulating colored shapes, such as rectangles, circles, and
+lines. Shapes can be resized, positioned, and rotated where applicable,
+and their color and opacity can be changed. All shapes are implemented
+using OpenGL primitives, so they can be drawn efficiently with :ref:`guide_batched-rendering`.
+In the following examples `Batch` will be ommitted for brevity, but in
+general you always want to use Batched rendering for performance.
+
+For drawing more complex shapes, see the :ref:`guide_graphics` module.
+
+
+Creating a Shape
+----------------
+
+Various shapes can be constructed with a specific position, size, and color::
+
+    circle = shapes.Circle(x=100, y=150, radius=100, color=(50, 225, 30))
+    square = shapes.Rectangle(x=200, y=200, width=200, height=200, color=(55, 55, 255))
+
+You can also change the color, or set the opacity after creation. The opacity
+can be set on a scale of 0-255, for various levels of transparency::
+
+    circle.opacity = 120
+
+The size of Shapes can also be adjusted after creation::
+
+    square.width = 200
+    circle.radius = 99
+
+
+Anchor Points
+^^^^^^^^^^^^^
+
+Similar to images in pyglet, the "anchor point" of a Shape can be set.
+This relates to the center of the shape on the x and y axis. For Circles,
+the default anchor point is the center of the circle. For Rectangles,
+it is the bottom left corner. Depending on how you need to position your
+Shapes, this can be changed. For Rectangles this is especially useful if
+you will rotate it, since Shapes will rotate around the anchor point. In
+this example, a Rectangle is created, and the anchor point is then set to
+the center::
+
+    rectangle = shapes.Rectangle(x=400, y=400, width=100, height=50)
+    rectangle.anchor_x = 50
+    rectangle.anchor_y = 25
+    # or, set at the same time:
+    rectangle.anchor_position = 50, 25
+
+    # The rectangle is then rotated around its anchor point:
+    rectangle.rotation = 45
+
+If you plan to create a large number of shapes, you can optionally set the
+default anchor points::
+
+    shapes.Rectangle._anchor_x = 100
+    shapes.Rectangle._anchor_y = 50
+
+Advanced Operation
+------------------
+
+.. _guide_shapes-bounding:
+
+Shape Bounding Checks
+^^^^^^^^^^^^^^^^^^^^^
+
+Some shapes can check whether an instance contains a 2D point via Python's ``in`` operator.
+
+The point can be any :py:class:`tuple` of two numbers:
+
+.. code-block:: python
+
+    from pyglet.shapes import Circle
+
+    # Create a circle
+    circle = shapes.Circle(x=100, y=100, radius=50)
+
+    # Turn the circle red if (200, 200) is inside it
+    if (200, 200) in circle:
+        circle.color = (255, 0, 0)
+
+
+Bounding Checks Are In World Space
+""""""""""""""""""""""""""""""""""
+
+If you move or alter your viewport, you must account for this when
+checking coordinates from :ref:`mouse events <guide_mouse_events>`.
+You may find :py:class:`~pyglet.math.Vec2` helpful for this since
+it is a subclass of :py:class:`tuple`.
+
+.. _guide_shapes-bounding-supported:
+
+Which Shapes Support Bounding Checks?
+"""""""""""""""""""""""""""""""""""""
+
+Instances of the following shape classes support the ``in`` operator:
+
+- :py:class:`~pyglet.shapes.Circle`
+- :py:class:`~pyglet.shapes.Ellipse`
+- :py:class:`~pyglet.shapes.Sector`
+- :py:class:`~pyglet.shapes.Line`
+- :py:class:`~pyglet.shapes.Rectangle`
+- :py:class:`~pyglet.shapes.BorderedRectangle`
+- :py:class:`~pyglet.shapes.Triangle`
+- :py:class:`~pyglet.shapes.Polygon`
+- :py:class:`~pyglet.shapes.Star`
+  (acts like a :py:class:`~pyglet.shapes.Circle`
+  with a radius of ``(outer_radius + inner_radius) / 2``).
+
+
+.. _guide_shapes-bounding-details:
+
+How Does It Work?
+"""""""""""""""""
+
+Each of these classes implements a :py:meth:`~object.__contains__` method which
+accounts for an instance's:
+
+* :py:attr:`~pyglet.shapes.ShapeBase.rotation` angle
+* :py:attr:`~pyglet.shapes.ShapeBase.anchor_position`
+
+
+.. _guide_shapes-custom:
+
+Custom Shapes
+^^^^^^^^^^^^^
+
+.. tip:: For complex features and performance, please see :ref:`guide_graphics`.
+
+You can import and subclass :py:class:`~pyglet.shapes.ShapeBase` to create
+custom shapes:
+
+.. code-block:: python
+
+   from pyglet.shapes import ShapeBase
+
+
+   class MyCustomShape(ShapeBase):
+       """A custom shape class. Implementation details omitted."""
+       ...
+
+
+This is the base class for shapes in the :py:mod:`~pyglet.shapes` module,
+which means you can use the other shapes in the module as reference. Please
+note that this class has the following caveats:
+
+* The ``in`` operator requires you to add a :py:meth:`~object.__contains__` method which:
+
+  * accounts for the following values on an instance:
+
+    * :py:attr:`~pyglet.shapes.ShapeBase.rotation` angle
+    * :py:attr:`~pyglet.shapes.ShapeBase.anchor_position`
+
+  * returns a :py:class:`bool`
+
+* It will conflict with other metaclass-based helpers due to using :py:class:`abc.ABC`
+

{pyglet-2.1.3 → pyglet-2.1.5}/examples/opengl/torus.py

@@ -114,13 +114,13 @@ def create_torus(radius, inner_radius, slices, inner_slices, shader, batch):
     emission = [0.0, 0.0, 0.0, 1.0]
     shininess = 50
 
-    material = pyglet.model.Material("custom", diffuse, ambient, specular, emission, shininess)
+    material = pyglet.model.SimpleMaterial("custom", diffuse, ambient, specular, emission, shininess)
     group = pyglet.model.MaterialGroup(material=material, program=shader)
 
     vertex_list = shader.vertex_list_indexed(len(vertices) // 3, GL_TRIANGLES, indices, batch, group,
-                                             position=('f', vertices),
-                                             normals=('f', normals),
-                                             colors=('f', material.diffuse * (len(vertices) // 3)))
+                                             POSITION=('f', vertices),
+                                             NORMAL=('f', normals),
+                                             COLOR_0=('f', material.diffuse * (len(vertices) // 3)))
 
     return pyglet.model.Model([vertex_list], [group], batch)
 

{pyglet-2.1.3 → pyglet-2.1.5}/examples/text/advanced_font.py

@@ -9,7 +9,8 @@ if os.name == "nt":
     # On Windows, it's possible to change the font anti-aliasing mode.
     # Uncomment the below lines to set the options:
     #
-    from pyglet.font.directwrite import DirectWriteGlyphRenderer
+    from pyglet.font.dwrite import DirectWriteGlyphRenderer
+
     D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = 0
     D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = 1 # not working?
     D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = 2 # same as default
@@ -25,15 +26,15 @@ batch = pyglet.graphics.Batch()
 float_font_size = pyglet.text.Label("Hello World on size 15.1", font_name="Arial", font_size=15.1, x=30, y=500, batch=batch)
 float_font_size_1 = pyglet.text.Label("Hello World on size 15", font_name="Arial", font_size=15, x=270, y=500, batch=batch)
 
-arial_bold = pyglet.text.Label("Hello World 👽", font_name="Arial", bold=True, font_size=25, x=50, y=400, batch=batch)
-arial_black = pyglet.text.Label("Hello World 👾", font_name="Arial", bold="black", font_size=25, x=50, y=350, batch=batch)
-arial_narrow = pyglet.text.Label("Hello World 🤖", font_name="Arial", bold=False, stretch="condensed", font_size=25, x=50, y=300, batch=batch)
+arial_bold = pyglet.text.Label("Hello World 👽", font_name="Arial", weight="normal", font_size=25, x=50, y=400, batch=batch)
+arial_black = pyglet.text.Label("Hello World 👾", font_name="Arial", weight="black", font_size=25, x=50, y=350, batch=batch)
+arial_narrow = pyglet.text.Label("Hello World 🤖", font_name="Arial", weight="normal", stretch="condensed", font_size=25, x=50, y=300, batch=batch)
 arial = pyglet.text.Label("Hello World 👀", font_name="Arial", font_size=25, x=50, y=250, batch=batch)
 
-segoe_ui_black = pyglet.text.Label("Hello World ☂️", font_name="Segoe UI", bold="black", font_size=25, x=50, y=200, batch=batch)
-segoe_ui_semilbold = pyglet.text.Label("Hello World ⚽️", font_name="Segoe UI", bold="semibold", font_size=25, x=50, y=150, batch=batch)
-segoe_ui_semilight = pyglet.text.Label("Hello World 🎱", font_name="Segoe UI", bold="semilight", font_size=25, x=50, y=100, batch=batch)
-segoe_ui_light = pyglet.text.Label("Hello World 🥳👍", font_name="Segoe UI", bold="light", font_size=25, x=50, y=50, batch=batch)
+segoe_ui_black = pyglet.text.Label("Hello World ☂️", font_name="Segoe UI", weight="black", font_size=25, x=50, y=200, batch=batch)
+segoe_ui_semilbold = pyglet.text.Label("Hello World ⚽️", font_name="Segoe UI", weight="semibold", font_size=25, x=50, y=150, batch=batch)
+segoe_ui_semilight = pyglet.text.Label("Hello World 🎱", font_name="Segoe UI", weight="semilight", font_size=25, x=50, y=100, batch=batch)
+segoe_ui_light = pyglet.text.Label("Hello World 🥳👍", font_name="Segoe UI", weight="light", font_size=25, x=50, y=50, batch=batch)
 segoe_ui = pyglet.text.Label("Hello World 😀✌", font_name="Segoe UI", font_size=25, x=50, y=10, batch=batch)
 
 if os.name == "nt":

pyglet-2.1.5/examples/text/user_bitmap_font.py

@@ -0,0 +1,92 @@
+"""This example demonstrates how to create a compatible font with Pyglets layout system using images."""
+from __future__ import annotations
+
+import pyglet
+from pyglet.font.user import UserDefinedMappingFont, get_scaled_user_font
+
+# Add our resource path that includes the font atlas.
+pyglet.resource.path.append('../../tests/data/fonts')
+pyglet.resource.reindex()
+
+# Create Window
+window = pyglet.window.Window()
+
+# Create a graphics batch to batch render our objects.
+batch = pyglet.graphics.Batch()
+
+atlas_image = pyglet.resource.image("action_man_atlas.png")
+
+# You can use whatever method you want, but you just need to map your ImageData instances to the character
+atlas_characters = """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.: '"/?!@#$%^&*()"""
+rows = 5
+columns = 16
+
+# Ensure the data is image data, as it is needed to blit into a Texture.
+image_data = atlas_image.get_image_data()
+
+# Create image grid based on how many glyphs.
+grid = pyglet.image.ImageGrid(image_data, rows=rows, columns=columns)
+
+# Map characters to image data. A -> ImageData
+# The mapping can be a dictionary lookup, or it can be an object that behaves like a dictionary.
+mapping = {}
+char = 0
+for row in range(rows):
+    for column in range(columns):
+        y_prime = (rows - 1) - row
+        new_index = column + y_prime * columns
+        # This chooses values based on the top left. Pyglet uses bottom left indexing.
+        glyph = grid[new_index]
+        mapping[atlas_characters[char]] = glyph
+        char += 1
+
+class ActionManMappedFont(UserDefinedMappingFont):
+    glyph_fit = len(atlas_characters)
+
+
+# Create your font instance.
+action_man_font = ActionManMappedFont("custom_action_man1",  # Custom unique name to not clash with others.
+                                      default_char=" ",  # Default character to use if a character is not mapped.
+                                      size=13,  # The size you want your font to be considered at base size.
+                                      mappings=mapping)  # The mapping object containing your character -> glyphs.
+
+# Add the font to usable fonts.
+pyglet.font.add_user_font(action_man_font)
+
+# Create a label like normal!
+label = pyglet.text.Label("Hello World!",
+                          font_size=13,
+                          font_name="custom_action_man1",
+                          x=window.width // 2,
+                          y=window.height // 2,
+                          anchor_x="center",
+                          anchor_y="center",
+                          batch=batch)
+
+# As an optional dependency with Pillow installed, you can scale your bitmap font.
+try:
+    # Create the size you want it to be scaled to.
+    # Only create new font sizes from the original user font object.
+    # !! Note that the size will be calculated in relation to your original size.
+    action_scaled_32 = get_scaled_user_font(action_man_font, 32)
+    pyglet.font.add_user_font(action_scaled_32)
+
+    scaled_label = pyglet.text.Label("Scaled Hello World!",
+                              font_size=32,
+                              font_name="custom_action_man1",
+                              x=window.width // 2,
+                              y=window.height // 3,
+                              anchor_x="center",
+                              anchor_y="center",
+                              batch=batch)
+except ImportError:
+    print("Warning: PIL was not detected, scaled font will not be shown.")
+
+
+@window.event
+def on_draw():
+    window.clear()
+    batch.draw()
+
+
+pyglet.app.run()

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

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.3'
+version = '2.1.5'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -110,6 +110,10 @@ class Options:
     debug_trace_depth: int = 1
     debug_trace_flush: bool = True
 
+    debug_com: bool = False
+    """If ``True``, prints information on COM calls. This can potentially help narrow down issues with certain libraries
+    that utilize COM calls. Only applies to the Windows platform."""
+
     debug_win32: bool = False
     """If ``True``, prints error messages related to Windows library calls. Usually get's information from
     ``Kernel32.GetLastError``. This information is output to a file called ``debug_win32.log``."""
@@ -175,6 +179,11 @@ class Options:
     .. versionadded:: 2.0
     """
 
+    text_antialiasing: bool = True
+    """If ``True``, font renderers will improve text quality by adding antialiasing to the rendered characters. If
+    ``False``, text quality will appear pixelated.
+    """
+
     headless: bool = False
     """If ``True``, visible Windows are not created and a running desktop environment is not required. This option
     is useful when running pyglet on a headless server, or compute cluster. OpenGL drivers with ``EGL`` support are
@@ -186,14 +195,17 @@ class Options:
     GPU to use. This is only useful on multi-GPU systems.
     """
 
-    win32_disable_shaping: bool = False
-    """If ``True``, will disable the shaping process for the default Windows font renderer to offer a performance
-    speed up. If your font is simple, monospaced, or you require no advanced OpenType features, this option may be
-    useful. You can try enabling this to see if there is any impact on clarity for your font. The advance will be
-    determined by the glyph width.
+    text_shaping: Literal["platform", "harfbuzz", False] = 'platform'
+    """Determines how text is processed and displayed based on features of the font.
 
-    .. note:: Shaping is the process of determining which character glyphs to use and specific placements of those
-       glyphs when given a full string of characters.
+    Valid option names are:
+
+     * ``False``, Disables the shaping process for text. This may increase performance as it reduces the amount
+        of calls during rendering. If your font is simple, monospaced, or you require no advanced OpenType features,
+        this option may be useful.
+     * ``'platform'``, Uses platform's font system for shaping. Supported by Windows (DirectWrite) and Mac (CoreText).
+     * ``'harfbuzz'``, Utilize the harfbuzz library for font shaping. This requires an optional dependency, if not
+     found, it will fallback to platform shaping.
 
     .. versionadded:: 2.0
     """
@@ -270,7 +282,7 @@ class Options:
     rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the extent
     of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
     `window.get_framebuffer_size()`.
-    
+
     `'platform'`: A DPI aware window is created, however window sizing and framebuffer sizing is not interfered with
     by Pyglet. Final sizes are dictated by the platform the window was created on. It is up to the user to make any
     platform adjustments themselves such as sizing on a platform, mouse coordinate adjustments, or framebuffer size

{pyglet-2.1.3 → pyglet-2.1.5}/pyglet/__init__.pyi

@@ -49,15 +49,17 @@ class Options:
     debug_win32: bool
     debug_input: bool
     debug_x11: bool
+    debug_com: bool
     shadow_window: bool
     vsync: bool | None
     xsync: bool
     xlib_fullscreen_override_redirect: bool
     search_local_libs: bool
     win32_gdi_font: bool
+    text_antialiasing: bool
     headless: bool
     headless_device: int
-    win32_disable_shaping: bool
+    text_shaping: Literal["platform", "harfbuzz", False]
     dw_legacy_naming: bool
     win32_disable_xinput: bool
     com_mta: bool