pyglet 2.1.dev5__tar.gz → 2.1.dev6__tar.gz

{pyglet-2.1.dev5 → pyglet-2.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglet
-Version: 2.1.dev5
+Version: 2.1.dev6
 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.dev5 → pyglet-2.1.dev6}/RELEASE_NOTES

@@ -1,3 +1,30 @@
+pyglet 2.0.17
+
+Changes and Improvements
+------------------------
+- image: Use dedicated shader for blitting to fix blending issues. (#1170)
+- shapes: Add a way to set blend mode on initialization and after.
+- shapes: Add a get_shape_group function.
+- shapes: Add a way to change shape shader program.
+- pyglet.experimental: Add multi-texture sprite support. (#1166)
+- graphics.vertexbuffer: (internal) Rename buffer object `sub_data` to `commit` to better reflect it's usage. (#1186)
+- gui: Add on_mouse_enter/leave event handler to WidgetBase and use it in Buttons (#1190)
+- graphics.vertexdomain: Update program migration to its own function: update_shader.
+- graphics.vertexdomain: Changing programs no longer requires batch, as that doesn't change with a program change.
+- graphics.vertexdomain: Allow migration of shaders through deleting vertex lists.
+- graphics.vertexdomain: Remove `isinstance` check for VertexList and go off the class variable that is set.
+
+Bugfixes
+--------
+- image: Fix Texture3D.create_for_images method.
+- typing: Fix pyglet.options type checking.
+- shader: Fix UBO arrays. (#1168)
+- sprite: Fix paused animation frame index. (#1180)
+- window: win32: Fix Window.set_icon.best_icon. (#1183)
+- options: Fix audio and vsync env vars. (#1185)
+- audio: Remove `PreciseStreamingSource`; Move audio buffering back into Players. (#1175)
+
+
 pyglet 2.0.16
 
 Changes and Improvements

{pyglet-2.1.dev5 → pyglet-2.1.dev6}/doc/conf.py

@@ -119,7 +119,7 @@ skip_modules = {"pyglet": {
                      "pyglet.lib": None,
                      "pyglet.libs": None,
                      "pyglet.app": implementations,
-                     "pyglet.canvas": implementations + ["xlib_vidmoderestore"],
+                     "pyglet.display": implementations + ["xlib_vidmoderestore"],
                      "pyglet.extlibs": None,
                      "pyglet.font": ["quartz",
                                      "win32",

pyglet-2.1.dev5/doc/modules/canvas.rst → pyglet-2.1.dev6/doc/modules/display.rst

@@ -1,7 +1,7 @@
-pyglet.canvas
-=============
+pyglet.display
+==============
 
-.. automodule:: pyglet.canvas
+.. automodule:: pyglet.display
   :members:
   :undoc-members:
 

{pyglet-2.1.dev5 → pyglet-2.1.dev6}/doc/programming_guide/context.rst

@@ -11,7 +11,7 @@ Displays, screens, configs and contexts
 
 .. figure:: img/context_flow.png
 
-    Flow of construction, from the abstract Canvas to a newly
+    Flow of construction, from the abstract Display to a newly
     created Window with its Context.
 
 Contexts and configs
@@ -65,32 +65,32 @@ X11 remotely: the display device will support different configurations than the
 local driver.  Even a single video card on the local computer may support
 different configs for two monitors plugged in.
 
-In pyglet, a :class:`~pyglet.canvas.Display` is a collection of "screens"
+In pyglet, a :class:`~pyglet.display.Display` is a collection of "screens"
 attached to a single display device.  On Linux, the display device corresponds
 to the X11 display being used.  On Windows and Mac OS X, there is only one
 display (as these operating systems present multiple video cards as a single
 virtual device).
 
-The :mod:`pyglet.canvas` module provides access to the display(s). Use the
-:func:`~pyglet.canvas.get_display` function to get the default display::
+The :mod:`pyglet.display` module provides access to the display(s). Use the
+:func:`~pyglet.display.get_display` function to get the default display::
 
-    >>> display = pyglet.canvas.get_display()
+    >>> display = pyglet.display.get_display()
 
 .. note::
 
-    On X11, you can use the :class:`~pyglet.canvas.Display` class directly to
+    On X11, you can use the :class:`~pyglet.display.Display` class directly to
     specify the display string to use, for example to use a remotely connected
     display.  The name string is in the same format as used by the ``DISPLAY``
     environment variable::
 
-        >>> display = pyglet.canvas.Display(name=':1')
+        >>> display = pyglet.display.Display(name=':1')
 
     If you have multiple physical screens and you're using Xinerama, see
     :ref:`guide_screens` to select the desired screen as you would for Windows
     and Mac OS X. Otherwise, you can specify the screen number via the
     ``x_screen`` argument::
 
-        >>> display = pyglet.canvas.Display(name=':1', x_screen=1)
+        >>> display = pyglet.display.Display(name=':1', x_screen=1)
 
 .. _guide_screens:
 
@@ -112,11 +112,11 @@ In the following example the screens of a dual-head workstation are listed::
     XlibScreen(screen=0, x=0, y=0, width=1280, height=1024, xinerama=1)
 
 Because this workstation is running Linux, the returned screens are
-``XlibScreen``, a subclass of :class:`~pyglet.canvas.Screen`. The
+``XlibScreen``, a subclass of :class:`~pyglet.display.Screen`. The
 ``screen`` and ``xinerama`` attributes are specific to Linux, but the
-:attr:`~pyglet.canvas.Screen.x`, :attr:`~pyglet.canvas.Screen.y`,
-:attr:`~pyglet.canvas.Screen.width` and
-:attr:`~pyglet.canvas.Screen.height` attributes are present on all screens,
+:attr:`~pyglet.display.Screen.x`, :attr:`~pyglet.display.Screen.y`,
+:attr:`~pyglet.display.Screen.width` and
+:attr:`~pyglet.display.Screen.height` attributes are present on all screens,
 and describe the screen's geometry, as shown below.
 
 .. figure:: img/screens.png
@@ -126,11 +126,11 @@ and describe the screen's geometry, as shown below.
     particular user's preference.
 
 There is always a "default" screen, which is the first screen returned by
-:meth:`~pyglet.canvas.Display.get_screens`.  Depending on the operating system,
+:meth:`~pyglet.display.Display.get_screens`.  Depending on the operating system,
 the default screen is usually the one that contains the taskbar (on Windows) or
 menu bar (on OS X).
 You can access this screen directly using
-:meth:`~pyglet.canvas.Display.get_default_screen`.
+:meth:`~pyglet.display.Display.get_default_screen`.
 
 
 .. _guide_glconfig:
@@ -291,10 +291,10 @@ For example, to create a window with an alpha channel::
 
 It is sometimes necessary to create the context yourself, rather than letting
 the :class:`~pyglet.window.Window` constructor do this for you.  In this case
-use :meth:`~pyglet.canvas.Screen.get_best_config` to obtain a "complete"
+use :meth:`~pyglet.display.Screen.get_best_config` to obtain a "complete"
 config, which you can then use to create the context::
 
-    display = pyglet.canvas.get_display()
+    display = pyglet.display.get_display()
     screen = display.get_default_screen()
 
     template = pyglet.gl.Config(alpha_size=8)
@@ -308,7 +308,7 @@ Note that you cannot create a context directly from a template (any
 above to create the context if a template config is given.
 
 Not all configs will be possible on all machines.  The call to
-:meth:`~pyglet.canvas.Screen.get_best_config` will raise
+:meth:`~pyglet.display.Screen.get_best_config` will raise
 :class:`~pyglet.window.NoSuchConfigException` if the hardware does not
 support the requested attributes.  It will never return a config that does not
 meet or exceed the attributes you specify in the template.
@@ -333,7 +333,7 @@ sufficient for most applications, however some complex programs may want to
 specify their own algorithm for selecting a set of OpenGL attributes.
 
 You can enumerate a screen's configs using the
-:meth:`~pyglet.canvas.Screen.get_matching_configs` method. You must supply a
+:meth:`~pyglet.display.Screen.get_matching_configs` method. You must supply a
 template as a minimum specification, but you can supply an "empty" template
 (one with no attributes set) to get a list of all configurations supported by
 the screen.
@@ -341,7 +341,7 @@ the screen.
 In the following example, all configurations with either an auxiliary buffer
 or an accumulation buffer are printed::
 
-    display = pyglet.canvas.get_display()
+    display = pyglet.display.get_display()
     screen = display.get_default_screen()
 
     for config in screen.get_matching_configs(gl.Config()):

{pyglet-2.1.dev5 → pyglet-2.1.dev6}/doc/programming_guide/migration.rst

@@ -43,14 +43,14 @@ Shapes
 For consistency with the rest of the library, it was decided to represent
 all angles in degrees instead of radians. Previously we had a mix of both,
 which lead to some confusion. Using degrees also makes the API consistent
-with Sprites and other rotatable objects.
+with Sprites and other rotatable objects, which have long used degrees.
 
 The arguments for :py:class:`~pyglet.shapes.Line` have changed slightly.
 Instead of "width", we now use "thickness". This matches with other shapes
 that are made up of line segments. For example the :py:class:`~pyglet.shapes.Box`
 shape, which already uses "width" (and height) to mean it's overall size.
 Going forward, any shape that is made up of lines should use `thickness`
-for the width of those lines.
+for the thickness/width of those lines.
 
 Controllers
 -----------
@@ -77,12 +77,18 @@ You now get a Vec2 instead of booleans that can be used directly::
         # Easily normalize for diagonal values:
         player_position += vector.normalize() * PLAYER_SPEED
 
+This should be more efficient in most cases. If you want to access the values
+as booleans for a quick workaround when migrating, you can do something like this::
+
+    dpleft, dpright, dpup, dpdown = vector.x < 0, vector.x > 0, vector.y > 0 vector.y < 0
+
+
 Vectors can also be useful for analog sticks, because it gives an easy way to
-calculate dead-zones using `abs`. For example::
+calculate dead-zones using `.length()`. For example::
 
     @controller.event
     def on_stick_motion(controller, name, vector):
-        if abs(vector) <= DEADZONE:
+        if vector.length() <= DEADZONE:
             return
         elif name == "leftstick":
             # Do something with the 2D vector
@@ -101,7 +107,6 @@ attributes. See :py:class:`~pyglet.math.Vec2` for more details on vector types.
 
 Gui
 ---
-
 All widget events now dispatch the widget instance itself as the first argument.
 This is similar to how Controller/Joystick events are implemented. In cases where
 the same handler function is set to multiple widgets, this gives a way to determine
@@ -115,19 +120,33 @@ Math module
 -----------
 In the :py:mod:`~pyglet.math` module, vector types (:py:class:`~pyglet.math.Vec2`,
 :py:class:`~pyglet.math.Vec3`, :py:class:`~pyglet.math.Vec4`) are now
-immutable; all operations will return a new object. In addition, all vector
-objects are now hashable. This has performance benefits, and matches how the Matrix
-types are implemented. For all intents and purposes, the Vec types can be treated
-as tuples.
+immutable; all operations will return a new object. In addition, all vector objects
+are now hashable. This has performance and usability benefits. For most purposes,
+the Vec types can be treated as (named) tuples.
+
+The :py:class:`~pyglet.math.Mat3` & :py:class:`~pyglet.math.Mat4` class have been
+changed to be ``NamedTuple`` subclasses instead of ``tuple`` subclasses. This is
+consistent with the vector types, and makes for a cleaner code base. There is one
+small change due to this. Previously, creating a matrix from values required
+passing in a list or tuple of values. Now, you simply provide the values (the same
+way as vectors). For example:
+
+    # old way:
+    my_mat4 = pyglet.math.Mat4([1, 2, 3, 4, 5, ...])
+    # new way:
+    my_mat4 = pyglet.math.Mat4(1, 2, 3, 4, 5, ...)
+
+Matrix objects are generally created via their helper methods, so this change should
+hopefully not require any code updates for most users.
 
 Canvas module
 -------------
-The `pyglet.canvas` module has been renamed to `pyglet.display`, as the canvas
-concept was never fully fleshed out. The canvas concept appears to have been
-meant to allow arbitrary renderable areas. This can now be easily accomplished
-with Framebuffers. The name `display` is a more accurate representation of what
-the code in the module actually relates to. The usage is the same, minus the
-name change::
+The `pyglet.canvas` module has been renamed to `pyglet.display`. The "canvas"
+concept was a work-in-progress in legacy pyglet, and was never fully fleshed out.
+It appears to have been meant to allow arbitrary renderable areas, but this type
+of functionality can now be easily accomplished with Framebuffers. The name `display`
+is a more accurate representation of what the code in the module actually relates to.
+The usage is the same, with just the name change::
 
     my_display = pyglet.canvas.get_display()     # old pyglet 2.0
     my_display = pyglet.display.get_display()    # new pyglet 2.1

{pyglet-2.1.dev5 → pyglet-2.1.dev6}/doc/programming_guide/windowing.rst

@@ -44,10 +44,12 @@ ways to control the context that is created:
       window = pyglet.window.Window(context=context)
 
 * Supply a complete :py:class:`~pyglet.gl.Config` obtained from a
-  :py:class:`~pyglet.canvas.Screen` using the ``config``
+  :py:class:`~pyglet.display.Screen` using the ``config``
   argument.  The context will be created from this config and will share object
   space with the most recently created existing context::
 
+      display = pyglet.display.get_display()
+      screen = display.get_default_screen()
       config = screen.get_best_config(template)
       window = pyglet.window.Window(config=config)
 
@@ -58,14 +60,15 @@ ways to control the context that is created:
       config = gl.Config(double_buffer=True)
       window = pyglet.window.Window(config=config)
 
-* Specify a :py:class:`~pyglet.canvas.Screen` using the ``screen`` argument.
+* Specify a :py:class:`~pyglet.display.Screen` using the ``screen`` argument.
   The context will use a config created from default template configuration
   and this screen::
 
+      display = pyglet.display.get_display()
       screen = display.get_screens()[screen_number]
       window = pyglet.window.Window(screen=screen)
 
-* Specify a :py:class:`~pyglet.canvas.Display` using the ``display`` argument.
+* Specify a :py:class:`~pyglet.display.Display` using the ``display`` argument.
   The default screen on this display will be used to obtain a context using
   the default template configuration::
 
@@ -73,7 +76,7 @@ ways to control the context that is created:
       window = pyglet.window.Window(display=display)
 
 If a template :py:class:`~pyglet.gl.Config` is given, a
-:py:class:`~pyglet.canvas.Screen` or :py:class:`~pyglet.canvas.Display`
+:py:class:`~pyglet.display.Screen` or :py:class:`~pyglet.display.Display`
 may also be specified; however any other combination of parameters
 overconstrains the configuration and some parameters will be ignored.
 

pyglet-2.1.dev6/examples/dpi_scaled_window.py

@@ -0,0 +1,93 @@
+import pyglet
+
+pyglet.options["debug_gl"] = False
+pyglet.options.dpi_scaling = "scaled"
+
+window = pyglet.window.Window(800, 600, caption="DPI Test", resizable=True)
+batch = pyglet.graphics.Batch()
+
+print("Window DPI", window.dpi, "Window Scale", window.scale)
+
+hello_label = pyglet.text.Label('Hello, world',
+                                font_name='Times New Roman',
+                                font_size=36,
+                                x=window.width // 2, y=window.height // 2,
+                                anchor_x='center', anchor_y='center',
+                                batch=batch,
+                                dpi=window.dpi)
+
+mouse_enter_label = pyglet.text.Label(f"enter: x={0}, y={0}", x=10, y=110, font_size=12,
+                                      dpi=window.dpi, batch=batch)
+mouse_leave_label = pyglet.text.Label(f"leave: x={0}, y={0}", x=10, y=85, font_size=12,
+                                      dpi=window.dpi, batch=batch)
+mouse_motion_label = pyglet.text.Label(f"motion: x={0}, y={0} dx={0}, dy={0}", x=10, y=60, font_size=12,
+                                       dpi=window.dpi, batch=batch)
+mouse_drag_label = pyglet.text.Label(f"drag: x={0}, y={0} dx={0}, dy={0}", x=10, y=35, font_size=12,
+                                     dpi=window.dpi, batch=batch)
+mouse_press_label = pyglet.text.Label(f"press: x={0}, y={0}", x=10, y=10, font_size=12,
+                                      dpi=window.dpi, batch=batch)
+labels = [hello_label, mouse_enter_label, mouse_leave_label, mouse_motion_label, mouse_drag_label, mouse_press_label]
+
+dinosaur = pyglet.resource.animation("programming_guide/dinosaur.gif")
+
+sprite = pyglet.sprite.Sprite(dinosaur, x=100, y=140, batch=batch)
+if pyglet.options.dpi_scaling != "real":
+    sprite.scale = window.scale
+
+
+@window.event
+def on_draw():
+    window.clear()
+    batch.draw()
+
+
+@window.event
+def on_mouse_motion(x, y, dx, dy):
+    mouse_motion_label.text = f"motion: x={x:.2f}, y={y:.2f} dx={dx:.2f}, dy={dy:.2f}"
+
+
+@window.event
+def on_mouse_press(x, y, button, modifier):
+    mouse_press_label.text = f"press: x={x:.2f}, y={y:.2f}"
+
+
+@window.event
+def on_mouse_enter(x, y):
+    mouse_enter_label.text = f"enter: x={x:.2f}, y={y:.2f}"
+
+
+@window.event
+def on_mouse_leave(x, y):
+    mouse_leave_label.text = f"leave: x={x:.2f}, y={y:.2f}"
+
+
+@window.event
+def on_mouse_drag(x, y, dx, dy, button, modifier):
+    mouse_drag_label.text = f"drag: x={x:.2f}, y={y:.2f} dx={dx:.2f}, dy={dy:.2f}"
+
+
+@window.event
+def on_resize(width, height):
+    hello_label.position = (window.width // 2, window.height // 2, 0)
+
+
+@window.event
+def on_key_press(symbol, modifiers):
+    if symbol == pyglet.window.key.SPACE:
+        window.set_size(500, 300)
+
+
+@window.event
+def on_scale(scale, dpi):
+    print("--- on scale")
+    print("SCALE_X", scale, dpi)
+    print("Window Size:", window.get_size())
+    print("Window Scale Ratio:", window.scale)
+    print("Window Frame Buffer Size:", window.get_framebuffer_size())
+    if pyglet.options.dpi_scaling != "real":
+        for label in labels:
+            label.dpi = dpi
+        sprite.scale = window.scale
+
+
+pyglet.app.run()