pyglet 2.1.dev3__tar.gz → 2.1.dev4__tar.gz

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglet
-Version: 2.1.dev3
+Version: 2.1.dev4
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8
@@ -128,10 +128,14 @@ code, is a bug that deserves to be reported on a ticket.
 
 ## Building Docs
 
+[Documentation and Type Hints]: https://pyglet.readthedocs.io/en/latest/internal/doc.html
+
+To get started quickly:
+
     pip install -r doc/requirements.txt
-    python setup.py build_sphinx
+    python make.py docs
 
-Please check [the README.md file in the doc directory](doc/README.md) for more details.
+Please check [Documentation and Type Hints][] guide to learn more.
 
 ## Testing
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/README.md

@@ -119,10 +119,14 @@ code, is a bug that deserves to be reported on a ticket.
 
 ## Building Docs
 
+[Documentation and Type Hints]: https://pyglet.readthedocs.io/en/latest/internal/doc.html
+
+To get started quickly:
+
     pip install -r doc/requirements.txt
-    python setup.py build_sphinx
+    python make.py docs
 
-Please check [the README.md file in the doc directory](doc/README.md) for more details.
+Please check [Documentation and Type Hints][] guide to learn more.
 
 ## Testing
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/RELEASE_NOTES

@@ -2,13 +2,37 @@ pyglet 2.0.16
 
 Changes and Improvements
 ------------------------
-- library-wide overhaul of docstrings, and addition of type hints (#1084)
+- library-wide overhaul of docstrings, and addition of type hints. (#1084)
+- sprite: Add `blend_mode` property to change BLEND_MODE without needing to re-create the Sprite.
+- sprite: Deprecate `AdvancedSprite`, and merge functionality into default `Sprite` class.
+- sprite: Add `get_sprite_group` method, allowing easy usage of custom SpriteGroups in subclasses.
+- image: Code for `Texture.blit` has been inlined. (#1109)
+- shapes: Concave polygon can be drawn by earcutting a polygon. (#1121)
+- shapes: Add Rounded Rectangle shape. (#1131)
+- shapes: Add `thickness` property to `Box` shapes.
+- libs: Add `pyglet.libs.ioctl` module, to consolidate shared code on Linux.
+- gui: Add a pseudo "nine-path" Sprite-like class for variable sized windows.
+- math: Add `match` statement support to Vec classes.
+- graphics: Don't re-create a Shader each call to `draw` or `draw_indexed`.
+- pyglet.options: Add runtime typing enforcement to user-set options.
+- pyglet.experimental: Add simple GPU-based particle system in `particles` module.
+- text.layout: Update `on_style_text` to be more efficient.
 
 Bugfixes
 --------
-- resource: Fix indexing of directories inside of Zip files. Remove broken code for multi-part archives.
+- window.macos: Fix constant appearance of blinking caret on M1 based Macs. (#1160)
+- window.xlib: Avoid XSet/UnsetICFocus calls when _have_utf8 is False. (#1049)
+- window.win32: Fix application not updating timers and redrawing during moves. (#1125)
 - shapes: Add missing `thickness` property to Box.
 - shapes: Add missing docstrings to `Arc` `thickness` property.
+- shapes: Fix ShapeBase.group setter to only migrate batch when batch is not None. (#1090)
+- shapes: BezierCurve: fix miter artifacts from #1134. (#1155)
+- examples: Fix "more" button outline in soundspace example. (#1085)
+- tests: Fix a rarely-failing audio time test. (#1092)
+- input.controller: Fix accidentially missed mappings.
+- graphics.shader: Add missing parent program reference in Uniforms (#1103)
+- graphics.domain: Fix VertexList.resize method.
+- text.directwrite: Fix crash with dw_legacy_naming. Check if a custom collection exists before find a font with it.
 
 
 pyglet 2.0.15

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/contrib/toys/follow_mouse.py

@@ -16,7 +16,17 @@ import sys
 import random
 
 import pyglet
-from pyglet.gl import *
+from pyglet.gl import (
+    glEnable,
+    glBlendFunc,
+    glFlush,
+    Config,
+    GL_BLEND,
+    GL_LINE_SMOOTH,
+    GL_LINES,
+    GL_SRC_ALPHA,
+    GL_ONE_MINUS_SRC_ALPHA,
+)
 
 # open a single-buffered window so we can do cheap accumulation
 config = Config(double_buffer=False)

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/doc/index.rst

@@ -61,6 +61,7 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/time
    programming_guide/context
    programming_guide/gl
+   programming_guide/opengles
    programming_guide/math
    programming_guide/eventloop
    programming_guide/examplegame

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/doc/internal/doc.rst

@@ -191,7 +191,8 @@ some helper functions for common build and distribution related tasks. For docs,
    ./make.py docs --open
 
 
-If the build succeeds, the generated static web pages will be in ``doc/_build/html``.
+If the build succeeds, a browser window will open. You can skip this by omitting `--open`.
+The generated static web pages will be in ``doc/_build/html``.
 
 You can also build the documentation by using Sphinx's ``Makefile``:
 
@@ -202,6 +203,35 @@ You can also build the documentation by using Sphinx's ``Makefile``:
     make.bat html   # Windows
 
 
+Note that there are also additional build targets beyond HTML, but
+they may require installing additional dependencies. Run ``make help``
+to see a list of them:
+
+.. code:: console
+
+   $ make help
+   Please use `make <target>' where <target> is one of
+   html       to make standalone HTML files
+   dirhtml    to make HTML files named index.html in directories
+   singlehtml to make a single large HTML file
+   pickle     to make pickle files
+   json       to make JSON files
+   htmlhelp   to make HTML files and a HTML help project
+   qthelp     to make HTML files and a qthelp project
+   devhelp    to make HTML files and a Devhelp project
+   epub       to make an epub
+   latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+   latexpdf   to make LaTeX files and run them through pdflatex
+   text       to make text files
+   man        to make manual pages
+   texinfo    to make Texinfo files
+   info       to make Texinfo files and run them through makeinfo
+   gettext    to make PO message catalogs
+   changes    to make an overview of all changed/added/deprecated items
+   linkcheck  to check all external links for integrity
+   doctest    to run all doctests embedded in the documentation (if enabled)
+
+
 auto-generated details
 ^^^^^^^^^^^^^^^^^^^^^^
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/doc/programming_guide/events.rst

@@ -17,7 +17,7 @@ your own classes easily.
 Even handlers are simply functions or methods that are written to accept the same
 arguments as the dispatched event. Event handlers can be registered or unregistered
 during runtime. More than one handler can be registered to receive the same events,
-which is described in the following sections. Event dispatchers can _optionally_ have
+which is described in the following sections. Event dispatchers can *optionally* have
 default handlers for some of their events. Your own handlers can replace these entirely,
 or just be added on.
 

pyglet-2.1.dev4/doc/programming_guide/math.rst

@@ -0,0 +1,115 @@
+.. _guide_math:
+
+Matrix and Vector Math
+======================
+
+Modern OpenGL depends on matrixes for projection, translation, and other things. To
+provide out-of-the-box functionality, pyglet's :py:mod:`~pyglet.math` module includes
+the necessary Matrix and Vector types to cover common use cases. Provided types are:
+:py:class:`~pyglet.math.Vec2`, :py:class:`~pyglet.math.Vec3`, :py:class:`~pyglet.math.Vec4`,
+:py:class:`~pyglet.math.Mat3`, and :py:class:`~pyglet.math.Mat4`.
+
+See the :py:mod:`~pyglet.math` API documentation for a full list of methods and operations
+that these objects support.
+
+.. note:: Matrix and Vector types are ``tuple`` subclasses. They are therefore
+          immutable - all operations return a **new** object; they are not updated in-place.
+
+
+Creating a Matrix
+-----------------
+A Matrix can be created with no arguments, or by passing the initial values::
+
+    my_matrix = Mat4()
+    # or
+    my_matrix = Mat4(1.0, 0.0, 0.0, 0.0,
+                     0.0, 1.0, 0.0, 0.0,
+                     0.0, 0.0, 1.0, 0.0,
+                     0.0, 0.0, 0.0, 1.0)
+
+If no arguments are given on creation, an "identity" matrix will be created by default.
+(1.0 on the main diagonal, as shown here).
+
+More conveniently, you can also create matrixes from one of their helper class methods.
+
+
+Matrix Helper Methods
+---------------------
+When working with 3D graphics in OpenGL, A common operation is setting a perspective
+projection matrix. The ``Mat4`` class includes a helper method for this task. The arguments
+are similar to what you will find in popular OpenGL math libraries::
+
+    # Perspective (3D) projection matrix:
+    projection = Mat4.perspective_projection(aspect_ratio, z_near=0.1, z_far=255, fov=60)
+
+For setting a projection matrix on the current OpenGL context, pyglet Windows have
+a ``projection`` property. This points to a projection matrix used by all of pyglet's
+built-in classes, and can be set as follows::
+
+    my_matrix = Mat4.perspective_projection(aspect_ratio, z_near=0.1, z_far=255)
+    window.projection = my_matrix
+
+For working with 2D graphics, a helper method also exists for creating orthogonal projection
+matrixes, which is created and set in a similar way::
+
+    # Orthographic (2D) projection matrix:
+    my_matrix = Mat4.orthogonal_projection(0, width, 0, height, z_near=-255, z_far=255)
+    window.projection = my_matrix
+
+By default, pyglet is already set up with an orthographic projection matrix. It automatically
+updates this 2D matrix whenever a Window is created or resized. This is done inside of the
+Window's ``on_resize`` event handler. If you plan to set your own 3D or 2D projection matrix,
+a useful pattern is to override the default ``on_resize`` event handler with your own::
+
+    @window.event
+    def on_resize(width, height):
+        # window.viewport = (0, 0, width, height)
+        window.projection = Mat4.perspective_projection(window.aspect_ratio, z_near=0.1, z_far=255)
+        return pyglet.event.EVENT_HANDLED   # Don't call the default handler
+
+
+In addition to the ``projection`` property, pyglet Windows also contain a ``view`` property that
+points to another matrix that is used internally by pyglet's built-in classes. The view matrix
+gets multiplied with the projection matrix, controlling the final positioning and rendering of
+pyglet's built-in objects like Sprites, Shapes, and text. Unlike the projection matrix the view
+matrix defaults to an indentity matrix, and therefore has no effect initially. This makes it useful
+for users to set their own matrix on it, and controll zooming or translating (panning) a "camera".
+The ``Mat4`` class contains helper methods for creating these types of matrixes::
+
+    # translate the camera +100 on the X axis:
+    view_matrix = Mat4.from_translation(vector=Vec3(x=100, y=0, z=0))
+    # or scale by 2X (be careful of the Z values):
+    view_matrix = Mat4.from_scale(vector=Vec3(x=2.0, y=2.0, z=1.0))
+
+    window.view = view_matrix
+
+You can of course create multiple matrixes and multiply them together, such as to zoom and
+then translate, or translate and then zoom, etc. Be careful of multiplication order, as matrix
+multiplication is non-commutative.
+
+See the :py:mod:`~pyglet.math` API documentation for a full list of helper class methods.
+
+
+Matrix Multiplication
+---------------------
+Matrix classes in pyglet use the Python ``matmul`` (``@``) operator for matrix multiplication.
+The ``star`` operator (``*``) is not allowed, and will raise an exception. For example::
+
+    new_matrix = rotation_matrix @ translation_matrix
+
+
+Creating Vectors
+----------------
+pyglet includes classes for 2D, 3D, and 4D vectors: :py:class:`~pyglet.math.Vec2`,
+:py:class:`~pyglet.math.Vec3` and :py:class:`~pyglet.math.Vec4`. These Vec types support
+most mathematical operations, and implement helper methods for most common vector operations.
+Vecs are created with their values.
+
+    myvec2 = Vec2()     # same as Vec(x=0.0, y=0.0)
+    myvec2 = Vec2(-4.5, 3.0)
+    myvec3 = Vec3(100.0, 400.0, 1.0)
+
+
+Vector Operations
+-----------------
+TBD

pyglet-2.1.dev4/doc/programming_guide/opengles.rst

@@ -0,0 +1,94 @@
+.. _programming-guide-opengles:
+
+
+OpenGL ES
+=========
+
+Pyglet has experimental support for OpenGL ES 3.2, with some limitations. Devices like Raspberry Pi 4
+and 5 supports OpenGL ES 3.1 with extensions covering most of the missing 3.2 features (with the
+exception of tessellation shaders). There are likely other devices with ES support that can run Pyglet.
+
+Creating a window / context
+---------------------------
+
+In order to successfully create a context and window with OpenGL ES we first need to:
+
+* Likely disable the shadow window because very few environments supports this
+* Pass in a custom config at window creation specifying OpenGL ES and version
+  
+Example::
+
+    import pyglet
+
+    # Disable shadow window
+    pyglet.options.shadow_window = False
+
+    # Query the best config for the screen
+    display = pyglet.display.get_display()
+    screen = display.get_default_screen()
+    config = screen.get_best_config()
+
+    # Specify that we want to use OpenGL ES 3.1
+    # This is very specific to the Raspberry Pi 4 and 5. Use 3.2 if you can.
+    config.opengl_api = "gles"
+    config.major_version = 3
+    config.minor_version = 1
+
+    # Create the window
+    window = pyglet.window.Window(config=config)
+
+
+Limitations
+-----------
+
+Multisampling
+~~~~~~~~~~~~
+
+Be careful with enabling multisampling on the window. Likely 
+``get_best_config()`` will not have multisampling enabled.
+
+Textures
+~~~~~~~~
+
+Pixel format for textures and images are limited to ``RGBA``. If you try to
+load any other pixel format through pyglet's image loading functions you
+will get an error when they are turned into OpenGL textures later.
+
+The reason for this limitation is that OpenGL ES does not support pixel
+format conversion during pixel transfer, meaning when calling ``glTexImage``
+to upload pixel data to the GPU, the pixel format must match the internalformat.
+In desktop OpenGL an RGB image will be automatically converted to RGBA during
+this transfer. This is not supported in OpenGL ES.
+
+You are, however, free to create your own textures with any pixel format
+using the gl bindings directly.
+
+Compute Shader
+~~~~~~~~~~~~~~
+
+If you are planning to bind textures to image units with the intention of
+using them in a compute shader, you need to create these textures yourself
+using the gl bindings and allocate space using ``glTexStorage``. Pyglet is
+using ``glTexImage`` to allocate space and upload the pixel data for textures.
+
+The difference here is that ``glTexStorage`` creates immutable storage. You can
+only call it once and then fill the allocated space with pixel data using
+``glTexSubImage``. ``glTexImage`` on the other hand can be called multiple times
+reallocating the texture storage each time. Likely OpenGL ES doesn't want to
+deal with the extra complexity of validating the texture storage of images
+every time a compute shader is dispatched.
+
+In short: Create your own textures with immutable storage if you are planning
+to use them in a compute shader.
+
+Shaders
+-------
+
+Pyglet's shader system supports basic conversion between GLSL 1.5/3.3 shaders
+to GLES 3.2 shaders when running in OpenGL ES mode. This is to ensure that
+pyglet's built-in shaders also works with GL ES. This system is not perfect
+and are likely to have some flaws.
+
+Currently the shaders are converted to ES 3.1 shaders as a careful approach
+manually enabling extensions needed for ES 3.2. Precisions qualifiers are
+injected using ``mediump`` by default.

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/doc/programming_guide/quickstart.rst

@@ -8,6 +8,10 @@ when presented with a large amount of reference material to read.
 This chapter gives a very quick introduction to pyglet without going into
 too much detail.
 
+.. Note::
+    If you intend to use OpenGL ES with pyglet on devices like the Raspberry
+    Pi, please read the :ref:`programming-guide-opengles` section first.
+
 Hello, World
 ------------
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/doc/programming_guide/rendering.rst

@@ -5,7 +5,11 @@ Shaders and Rendering
 
 At the lowest level, pyglet uses OpenGL to draw graphics in program windows.
 The OpenGL interface is exposed via the :py:mod:`pyglet.gl` module
-(see :ref:`guide_gl`).
+(see :ref:`guid
+
+.. Note::
+    If you intend to use OpenGL ES with pyglet on devices like the Raspberry
+    Pi, please read the :ref:`programming-guide-opengles` section first.
 
 For new users, however, using the OpenGL interface directly can be daunting.
 The :py:mod:`pyglet.graphics` module provides high level abstractions that
@@ -147,12 +151,12 @@ Then you can set (or get) the value using the uniform name as a key::
     program['time'] = delta_time
 
 
-Uniform Buffer Objects (Uniform Blocks)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Uniform Blocks and Uniform Buffer Objects
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Pyglet also introspects and makes Uniform Blocks (or Interface Blocks) available, including ways to manage and use Uniform Buffer Objects.
 
-Pyglet also offers access to Uniform Buffer Objects or Uniform Blocks. These are special objects that can be used to
-share uniforms between different programs. For example, by default, Pyglet's ``projection`` and ``view`` matrix
-are both contained in the ``WindowBlock`` uniform block. Which looks like this in the vertex shader::
+By default, Pyglet's ``projection`` and ``view`` matrix are both contained in the ``WindowBlock`` uniform block. Which looks like this in the vertex shader::
 
     uniform WindowBlock
     {
@@ -162,8 +166,11 @@ are both contained in the ``WindowBlock`` uniform block. Which looks like this i
 
 You can view what uniform blocks exist in a :py:class:`~pyglet.graphics.shader.ShaderProgram` using the `uniform_blocks`
 property. This is a dictionary containing a Uniform Block name key to a :py:class:`~pyglet.graphics.shader.UniformBlock`
-object value. In the above example, the name would be ``WindowBlock`` while the ``window`` identifier is used in the GLSL
-shader itself.
+object value. In the above example, the name would be ``WindowBlock`` while the ``window`` instance identifier is used in the GLSL shader itself.
+
+Normally with OpenGL, you would have to manually assign a global binding point value to each Uniform Block for each Shader Program, as they are created. With Pyglet, the global binding values and assignments are all taken care of internally.
+
+Uniform Blocks can be a convenient way to update uniforms of multiple Shader Programs at once, as their data is shared. This allows you to access the same information from multiple Shader Programs without having to bind every program using it, just to modify the uniform values. This can be achieved through a :py:class:`~pyglet.graphics.shader.UniformBufferObject`.
 
 To modify the uniforms in a :py:class:`~pyglet.graphics.shader.UniformBlock`, you must first create a
 :py:class:`~pyglet.graphics.shader.UniformBufferObject` using the
@@ -171,12 +178,23 @@ To modify the uniforms in a :py:class:`~pyglet.graphics.shader.UniformBlock`, yo
 
     ubo = program.uniform_blocks['WindowBlock'].create_ubo()
 
-The :py:class:`~pyglet.graphics.shader.UniformBufferObject` can then be used, and acts as a context manager for easy
-access to its uniforms::
+The :py:class:`~pyglet.graphics.shader.UniformBufferObject` can then be used as a context manager for easy
+access to update its uniforms::
 
         with ubo as window_block:
             window_block.projection[:] = new_matrix
 
+You can also create multiple :py:class:`~pyglet.graphics.shader.UniformBufferObject` instances if you need to swap between different sets of data. Calling :py:meth:`~pyglet.graphics.shader.UniformBufferObject.bind` will bind the buffers data to the associated binding point.
+
+There may come a point where you don't want a specific :py:class:`~pyglet.graphics.shader.ShaderProgram`, or a group of them, to use the same uniform data set as the rest of your shaders. At this point, you will have to modify the binding point of those Uniform Blocks to one that is unused. This can be done through :py:meth:`~pyglet.graphics.shader.UniformBlock.set_binding`. Once the binding has been set, you will have to create a new :py:class:`~pyglet.graphics.shader.UniformBufferObject` using the :py:meth:`~pyglet.graphics.shader.UniformBlock.create_ubo` method again and supply it with your new data set.
+
+.. warning:: When assigning custom binding points through py:meth:`~pyglet.graphics.shader.UniformBlock.set_binding`, it is recommended to use an unassigned binding point, as unexpected behavior may occur. A warning will be output if such a collision occurs.
+
+             The maximum binding point value is determined by the hardware. This can be retrieved by calling :py:func:`~pyglet.graphics.shader.get_maximum_binding_count`. It is recommended to use a number
+             higher than the amount of Uniform Blocks in your application to prevent collisions.
+
+.. note:: Binding point 0 cannot be set, as it is used internally for ``WindowBlock``.
+
 
 Creating Vertex Lists
 ^^^^^^^^^^^^^^^^^^^^^

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/events/register_event_type.py

@@ -41,7 +41,7 @@ def create_alarm(dt):
 @register_event_type('on_wake_up')
 class Alarms(EventDispatcher):
     def on_wake_up(self, dt):
-        print('Yet another {} seconds wasted! Wake up!'.format(dt))
+        print(f'Yet another {dt} seconds wasted! Wake up!')
 
 
 alarms = Alarms()

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/events/window_platform_event.py

@@ -10,7 +10,6 @@ A message will be printed to stdout when the following events are caught:
 
 """
 
-from __future__ import print_function
 
 import pyglet
 
@@ -23,7 +22,7 @@ if pyglet.compat_platform.startswith('linux'):
 
 elif pyglet.compat_platform == 'darwin':
     _have_cocoa = True
-    from pyglet.window.cocoa import *
+    # from pyglet.window.cocoa import *
 
 elif pyglet.compat_platform in ('win32', 'cygwin'):
     _have_win32 = True

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version1/asteroid.py

@@ -12,7 +12,7 @@ level_label = pyglet.text.Label(text="Version 1: Static Graphics",
 # Initialize the player sprite
 player_ship = pyglet.sprite.Sprite(img=resources.player_image, x=400, y=300)
 
-# Make three asteroids so we have something to shoot at 
+# Make three asteroids so we have something to shoot at
 asteroids = load.asteroids(3, player_ship.position)
 
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version2/asteroid.py

@@ -17,7 +17,7 @@ player_ship = player.Player(x=400, y=300, batch=main_batch)
 # Make three sprites to represent remaining lives
 player_lives = load.player_lives(2, main_batch)
 
-# Make three asteroids so we have something to shoot at 
+# Make three asteroids so we have something to shoot at
 asteroids = load.asteroids(3, player_ship.position, main_batch)
 
 # Store all objects that update each frame in a list

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version2/game/load.py

@@ -1,4 +1,6 @@
-import pyglet, math, random
+import pyglet
+import math
+import random
 from . import physicalobject, resources
 
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version3/asteroid.py

@@ -17,7 +17,7 @@ player_ship = player.Player(x=400, y=300, batch=main_batch)
 # Make three sprites to represent remaining lives
 player_lives = load.player_lives(2, main_batch)
 
-# Make three asteroids so we have something to shoot at 
+# Make three asteroids so we have something to shoot at
 asteroids = load.asteroids(3, player_ship.position, main_batch)
 
 # Store all objects that update each frame in a list

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version3/game/player.py

@@ -1,4 +1,5 @@
-import pyglet, math
+import pyglet
+import math
 from pyglet.window import key
 from . import physicalobject, resources
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version3/game/resources.py

@@ -21,7 +21,7 @@ center_image(bullet_image)
 asteroid_image = pyglet.resource.image("asteroid.png")
 center_image(asteroid_image)
 
-# The engine flame should not be centered on the ship. Rather, it should be shown 
+# The engine flame should not be centered on the ship. Rather, it should be shown
 # behind it. To achieve this effect, we just set the anchor point outside the
 # image bounds.
 engine_image = pyglet.resource.image("engine_flame.png")

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version4/asteroid.py

@@ -17,7 +17,7 @@ player_ship = player.Player(x=400, y=300, batch=main_batch)
 # Make three sprites to represent remaining lives
 player_lives = load.player_lives(2, main_batch)
 
-# Make three asteroids so we have something to shoot at 
+# Make three asteroids so we have something to shoot at
 asteroids = load.asteroids(3, player_ship.position, main_batch)
 
 # Store all objects that update each frame in a list

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version4/game/player.py

@@ -1,4 +1,5 @@
-import pyglet, math
+import pyglet
+import math
 from pyglet.window import key
 from . import bullet, physicalobject, resources
 

{pyglet-2.1.dev3/examples/game/version5 → pyglet-2.1.dev4/examples/game/version4}/game/resources.py

@@ -21,7 +21,7 @@ center_image(bullet_image)
 asteroid_image = pyglet.resource.image("asteroid.png")
 center_image(asteroid_image)
 
-# The engine flame should not be centered on the ship. Rather, it should be shown 
+# The engine flame should not be centered on the ship. Rather, it should be shown
 # behind it. To achieve this effect, we just set the anchor point outside the
 # image bounds.
 engine_image = pyglet.resource.image("engine_flame.png")

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version5/asteroid.py

@@ -56,7 +56,7 @@ def reset_level(num_lives=2):
     # Make three sprites to represent remaining lives
     player_lives = load.player_lives(num_lives, main_batch)
 
-    # Make some asteroids so we have something to shoot at 
+    # Make some asteroids so we have something to shoot at
     asteroids = load.asteroids(num_asteroids, player_ship.position, main_batch)
 
     # Store all objects that update each frame in a list
@@ -120,7 +120,7 @@ def update(dt):
     for to_remove in [obj for obj in game_objects if obj.dead]:
         if to_remove == player_ship:
             player_dead = True
-        # If the dying object spawned any new objects, add those to the 
+        # If the dying object spawned any new objects, add those to the
         # game_objects list later
         to_add.extend(to_remove.new_objects)
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/game/version5/game/player.py

@@ -1,4 +1,5 @@
-import pyglet, math
+import pyglet
+import math
 from pyglet.window import key
 from . import bullet, physicalobject, resources
 

{pyglet-2.1.dev3/examples/game/version4 → pyglet-2.1.dev4/examples/game/version5}/game/resources.py

@@ -21,7 +21,7 @@ center_image(bullet_image)
 asteroid_image = pyglet.resource.image("asteroid.png")
 center_image(asteroid_image)
 
-# The engine flame should not be centered on the ship. Rather, it should be shown 
+# The engine flame should not be centered on the ship. Rather, it should be shown
 # behind it. To achieve this effect, we just set the anchor point outside the
 # image bounds.
 engine_image = pyglet.resource.image("engine_flame.png")

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/graphics/image_convert.py

@@ -6,7 +6,6 @@ Usage::
 
 """
 
-from __future__ import print_function
 
 import sys
 

{pyglet-2.1.dev3 → pyglet-2.1.dev4}/examples/graphics/image_display.py

@@ -8,12 +8,17 @@ Usage::
 A checkerboard background is visible behind any transparent areas.
 """
 
-from __future__ import print_function
 
 import sys
 
 import pyglet
-from pyglet.gl import *
+from pyglet.gl import (
+    glEnable,
+    glBlendFunc,
+    GL_BLEND,
+    GL_ONE_MINUS_SRC_ALPHA,
+    GL_SRC_ALPHA,
+)
 
 window = pyglet.window.Window(visible=False, resizable=True)