pyglet 3.0.dev1__tar.gz → 3.0.dev2__tar.gz

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pyglet
-Version: 3.0.dev1
+Version: 3.0.dev2
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Project-URL: Home, https://pyglet.org
 
 [![pypi](https://badge.fury.io/py/pyglet.svg)](https://pypi.python.org/pypi/pyglet) [![rtd](https://readthedocs.org/projects/pyglet/badge/?version=latest)](https://pyglet.readthedocs.io) [![PyTest](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml/badge.svg)](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml)

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/contrib/toys/follow_mouse.py

@@ -17,7 +17,7 @@ import sys
 
 import pyglet
 from pyglet.config import OpenGLConfig
-from pyglet.graphics import GeometryMode
+from pyglet.enums import GeometryMode
 
 from pyglet.graphics.api.gl import (
     GL_BLEND,

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/doc/programming_guide/examplegame.rst

@@ -8,7 +8,7 @@ clone. It is assumed that the reader is familiar with writing and running
 Python programs. This is not a programming tutorial, but it should hopefully
 be clear enough to follow even if you're a beginner. If you get stuck,
 first have a look at the relevant sections of the programming guide.
-The full source code can also be found in the `examples/game/` folder
+The full source code can also be found in the ``examples/game/`` folder
 of the pyglet source directory, which you can follow along with.
 If anything is still not clear, let us know!
 
@@ -24,11 +24,11 @@ Setting up
 
 First things first, make sure you have pyglet installed. Then, we will set
 up the folder structure for our project.  Since this example game is written
-in stages, we will have several `version` folders at various stages of
+in stages, we will have several ``version`` folders at various stages of
 development.  We will also have a shared resource folder with the images,
-called ‘resources,’ outside of the example folders.  Each `version` folder
-contains a Python file called `asteroid.py` which runs the game, as well as
-a sub-folder named `game` where we will place additional modules; this is
+called '``resources``', outside of the example folders.  Each ``version`` folder
+contains a Python file called ``asteroid.py`` which runs the game, as well as
+a sub-folder named ``game`` where we will place additional modules; this is
 where most of the logic will be. Your folder structure should look like this::
 
     game/
@@ -42,8 +42,8 @@ where most of the logic will be. Your folder structure should look like this::
 Getting a window
 ^^^^^^^^^^^^^^^^
 
-To set up a window, simply `import pyglet`, create a new instance of
-:class:`pyglet.window.Window`, and call `pyglet.app.run()`::
+To set up a window, simply ``import pyglet``, create a new instance of
+:class:`pyglet.window.Window`, and call ``pyglet.app.run()``::
 
     import pyglet
     game_window = pyglet.window.Window(800, 600)
@@ -51,9 +51,8 @@ To set up a window, simply `import pyglet`, create a new instance of
     if __name__ == '__main__':
         pyglet.app.run()
 
-If you run the code above, you should see a window full of junk that
-goes away when you press Esc. (What you are seeing is raw uninitialized
-graphics memory).
+If you run the code above, you should see a window full of random graphical junk (or just a blank window)
+that goes away when you press Esc. (What you are seeing is raw uninitialized graphics memory).
 
 Loading and displaying an image
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -68,42 +67,50 @@ directory, we need to tell pyglet where to find them::
 pyglet's :mod:`pyglet.resource` module takes all of the hard work out of
 finding and loading game resources such as images, sounds, etc..  All that
 you need to do is tell it where to look, and reindex it. In this example
-game, the resource path starts with `../` because the resources folder is
-on the same level as the `version1` folder.  If we left it off, pyglet
-would look inside `version1/` for the `resources/` folder.
+game, the resource path starts with ``../`` because the resources folder is
+on the same level as the ``version1`` folder.  If we left it off, pyglet
+would look inside ``version1/`` for the ``resources/`` folder.
 
 Now that pyglet’s resource module is initialized, we can easily load the images
-with the :func:`~pyglet.resource.image` function of the resource module::
+with the :func:`~pyglet.resource.texture` function of the resource module::
 
-    player_image = pyglet.resource.image("player.png")
-    bullet_image = pyglet.resource.image("bullet.png")
-    asteroid_image = pyglet.resource.image("asteroid.png")
+    player_texture = pyglet.resource.texture("player.png")
+    bullet_texture = pyglet.resource.texture("bullet.png")
+    asteroid_texture = pyglet.resource.texture("asteroid.png")
 
-Centering the images
+If you are unfamiliar with the term, a "``texture``" is basically an image that
+has been loaded into GPU memory. You may see the terms used interchangeably, but
+essentially the image data is loaded from disk (and decoded), and then uploaded
+to the GPU memory where it exists as a texture.
+
+.. note:: You must create a Window before loading any GPU related resources.
+
+
+Centering the textures
 ^^^^^^^^^^^^^^^^^^^^
 
-Pyglet will draw and position all images from their lower left corner by
-default.  We don’t want this behavior for our images, which need to rotate
+pyglet will draw and position all textures from their lower left corner by
+default.  We don’t want this behavior for our textures, which need to rotate
 around their centers.  All we have to do to achieve this is to set their
 anchor points.  Lets create a function to simplify this::
 
-    def center_image(image):
-        """Sets an image's anchor point to its center"""
-        image.anchor_x = image.width // 2
-        image.anchor_y = image.height // 2
+    def center_texture(texture):
+        """Sets an texture's anchor point to its center"""
+        texture.anchor_x = texture.width // 2
+        texture.anchor_y = texture.height // 2
 
-Now we can just call center_image() on all of our loaded images::
+Now we can just call center_texture() on all of our loaded textures::
 
-    center_image(player_image)
-    center_image(bullet_image)
-    center_image(asteroid_image)
+    center_texture(player_texture)
+    center_texture(bullet_texture)
+    center_texture(asteroid_texture)
 
-Remember that the center_image() function must be defined before it can be
+Remember that the center_texture() function must be defined before it can be
 called at the module level.  Also, note that zero degrees points directly
-to the right in pyglet, so the images are all drawn with their front
+to the right in pyglet, so the textures are all drawn with their front
 pointing to the right.
 
-To access the images from asteroid.py, we need to use something like
+To access the textures from asteroid.py, we need to use something like
 `from game import resources`, which we’ll get into in the next section.
 
 Initializing objects
@@ -167,7 +174,7 @@ like so::
 
     from game import resources
     ...
-    player_ship = pyglet.sprite.Sprite(img=resources.player_image, x=400, y=300)
+    player_ship = pyglet.sprite.Sprite(img=resources.player_texture, x=400, y=300)
 
 To get the player to draw on the screen, add a line to `on_draw()`::
 
@@ -189,7 +196,7 @@ player.  Let’s put the loading code in a new game submodule called load.py::
         for i in range(num_asteroids):
             asteroid_x = random.randint(0, 800)
             asteroid_y = random.randint(0, 600)
-            new_asteroid = pyglet.sprite.Sprite(img=resources.asteroid_image,
+            new_asteroid = pyglet.sprite.Sprite(img=resources.asteroid_texture,
                                                 x=asteroid_x, y=asteroid_y)
             new_asteroid.rotation = random.randint(0, 360)
             asteroids.append(new_asteroid)
@@ -223,7 +230,7 @@ the z value, so we just use a throwaway variable for that::
                 asteroid_x = random.randint(0, 800)
                 asteroid_y = random.randint(0, 600)
             new_asteroid = pyglet.sprite.Sprite(
-                img=resources.asteroid_image, x=asteroid_x, y=asteroid_y)
+                img=resources.asteroid_texture, x=asteroid_x, y=asteroid_y)
             new_asteroid.rotation = random.randint(0, 360)
             asteroids.append(new_asteroid)
         return asteroids
@@ -292,7 +299,7 @@ each new sprite. Update the function::
 
     def asteroids(num_asteroids, player_position, batch=None):
         ...
-        new_asteroid = pyglet.sprite.Sprite(img=resources.asteroid_image,
+        new_asteroid = pyglet.sprite.Sprite(img=resources.asteroid_texture,
                                             x=asteroid_x, y=asteroid_y,
                                             batch=batch)
 
@@ -324,7 +331,7 @@ and scale, and append it to the return list::
     def player_lives(num_icons, batch=None):
         player_lives = []
         for i in range(num_icons):
-            new_sprite = pyglet.sprite.Sprite(img=resources.player_image,
+            new_sprite = pyglet.sprite.Sprite(img=resources.player_texture,
                                               x=785-i*30, y=585, batch=batch)
             new_sprite.scale = 0.5
             player_lives.append(new_sprite)
@@ -382,10 +389,10 @@ they just wrapped around the screen. Here is a simple function that
 accomplishes the goal::
 
     def check_bounds(self):
-        min_x = -self.image.width / 2
-        min_y = -self.image.height / 2
-        max_x = 800 + self.image.width / 2
-        max_y = 600 + self.image.height / 2
+        min_x = -self.texture.width / 2
+        min_y = -self.texture.height / 2
+        max_x = 800 + self.texture.width / 2
+        max_y = 600 + self.texture.height / 2
         if self.x < min_x:
             self.x = max_x
         elif self.x > max_x:
@@ -450,7 +457,7 @@ periodically or at some specified time in the future.  The one we want is
     pyglet.clock.schedule_interval(update, 1/120.0)
 
 Putting this line above `pyglet.app.run()` in the if `__name__ == '__main__'`
-block tells pyglet to call `update()` 120 times per second.  Pyglet will pass
+block tells pyglet to call `update()` 120 times per second.  pyglet will pass
 in the elapsed time, i.e. `dt`, as the only parameter.
 
 Now when you run asteroid.py, you should see your formerly static asteroids
@@ -470,10 +477,10 @@ importing the appropriate modules, and subclassing `PhysicalObject`::
     class Player(physicalobject.PhysicalObject):
 
         def __init__(self, *args, **kwargs):
-            super().__init__(img=resources.player_image, *args, **kwargs)
+            super().__init__(img=resources.player_texture, *args, **kwargs)
 
 So far, the only difference between a Player and a PhysicalObject is that a
-Player will always have the same image.  But Player objects need a couple
+Player will always have the same texture.  But Player objects need a couple
 more attributes.  Since the ship will always thrust with the same force in
 whatever direction it points, we’ll need to define a constant for the
 magnitude of that force.  We should also define a constant for the ship’s
@@ -482,7 +489,7 @@ rotation speed::
         self.thrust = 300.0
         self.rotate_speed = 200.0
 
-Now we need to get the class to respond to user input.  Pyglet uses an
+Now we need to get the class to respond to user input.  pyglet uses an
 event-based approach to input, sending key press and key release events
 to registered event handlers.  But we want to use a polling approach in
 this example, checking periodically if a key is down.  One way to accomplish
@@ -627,7 +634,7 @@ thrusting forward or not, especially for an observer just watching someone
 else play the game.  One way to provide visual feedback is to show an engine
 flame behind the player while the player is thrusting.
 
-Loading the flame image
+Loading the flame texture
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 The player will now be made of two sprites.  There’s nothing preventing us
@@ -636,31 +643,31 @@ engine_sprite attribute and update it every frame. For our purposes,
 this approach will be the simplest and most scalable.
 
 To make the flame draw in the correct position, we could either do some
-complicated math every frame, or we could just move the image’s anchor point.
-First, load the image in resources.py::
+complicated math every frame, or we could just move the texture’s anchor point.
+First, load the texture in resources.py::
 
-    engine_image = pyglet.resource.image("engine_flame.png")
+    engine_texture = pyglet.resource.texture("engine_flame.png")
 
-To get the flame to draw behind the player, we need to move the flame image’s
-center of rotation to the right, past the end of the image.
+To get the flame to draw behind the player, we need to move the flame texture’s
+center of rotation to the right, past the end of the texture.
 To do that, we just set its `anchor_x` and `anchor_y` attributes::
 
-    engine_image.anchor_x = engine_image.width * 1.5
-    engine_image.anchor_y = engine_image.height / 2
+    engine_texture.anchor_x = engine_texture.width * 1.5
+    engine_texture.anchor_y = engine_texture.height / 2
 
-Now the image is ready to be used by the player class.  If you’re still
-confused about anchor points, experiment with the values for engine_image’s
+Now the texture is ready to be used by the player class.  If you’re still
+confused about anchor points, experiment with the values for engine_texture’s
 anchor point when you finish this section.
 
 Creating and drawing the flame
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The engine sprite needs to be initialized with all the same arguments as
-Player, except that it needs a different image and must be initially invisible.
+Player, except that it needs a different texture and must be initially invisible.
 The code for creating it belongs in `Player.__init__()` and is very
 straightforward::
 
-    self.engine_sprite = pyglet.sprite.Sprite(img=resources.engine_image, *args, **kwargs)
+    self.engine_sprite = pyglet.sprite.Sprite(img=resources.engine_texture, *args, **kwargs)
     self.engine_sprite.visible = False
 
 To make the engine sprite appear only while the player is thrusting, we need
@@ -777,7 +784,7 @@ Remember to call from util import distance in load.py.  Now we can write
 `PhysicalObject.collides_with()` without duplicating code::
 
     def collides_with(self, other_object):
-        collision_distance = self.image.width/2 + other_object.image.width/2
+        collision_distance = self.texture.width/2 + other_object.texture.width/2
         actual_distance = util.distance(self.position, other_object.position)
 
         return (actual_distance <= collision_distance)
@@ -891,7 +898,7 @@ subclass of PhysicalObject::
 
         def __init__(self, *args, **kwargs):
             super().__init__(
-                resources.bullet_image, *args, **kwargs)
+                resources.bullet_texture, *args, **kwargs)
 
 To get bullets to disappear after a time, we could keep track of our own
 age and lifespan attributes, or we could let pyglet do all the work for us.
@@ -906,7 +913,7 @@ We can do this as soon as the object is initialized by adding a call to
 :meth:`pyglet.clock.schedule_once` to the constructor::
 
     def __init__(self, *args, **kwargs):
-        super().__init__(resources.bullet_image, *args, **kwargs)
+        super().__init__(resources.bullet_texture, *args, **kwargs)
         pyglet.clock.schedule_once(self.die, 0.5)
 
 There’s still more work to be done on the Bullet class, but before we
@@ -924,7 +931,7 @@ to its constructor::
 
     class Player(physicalobject.PhysicalObject):
         def __init__(self, *args, **kwargs):
-            super().__init__(img=resources.player_image, *args, **kwargs)
+            super().__init__(img=resources.player_texture, *args, **kwargs)
             ...
             self.bullet_speed = 700.0
 
@@ -949,7 +956,7 @@ As usual, convert to radians and reverse the direction::
 
 Next, calculate the bullet’s position and instantiate it::
 
-    ship_radius = self.image.width/2
+    ship_radius = self.texture.width/2
     bullet_x = self.x + math.cos(angle_radians) * ship_radius
     bullet_y = self.y + math.sin(angle_radians) * ship_radius
     new_bullet = bullet.Bullet(bullet_x, bullet_y, batch=self.batch)
@@ -1058,14 +1065,14 @@ Writing the asteroid class
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create a new submodule of game called asteroid.py.  Write the usual constructor
-to pass a specific image to the superclass, passing along any other parameters::
+to pass a specific texture to the superclass, passing along any other parameters::
 
     import pyglet
     from . import resources, physicalobject
 
     class Asteroid(physicalobject.PhysicalObject):
         def __init__(self, *args, **kwargs):
-            super().__init__(resources.asteroid_image, *args, **kwargs)
+            super().__init__(resources.asteroid_texture, *args, **kwargs)
 
 Now we need to write a new `handle_collision_with()` method.  It should create
 a random number of new, smaller asteroids with random velocities.  However,
@@ -1107,7 +1114,7 @@ rotation every frame.
 Add the attribute in the constructor::
 
     def __init__(self, *args, **kwargs):
-        super().__init__(resources.asteroid_image, *args, **kwargs)
+        super().__init__(resources.asteroid_texture, *args, **kwargs)
         self.rotate_speed = random.random() * 100.0 - 50.0
 
 Then write the update() method::
@@ -1137,7 +1144,7 @@ Next steps
 ----------
 
 So instead of walking you through a standard refactoring session,
-I’m going to leave it as an exercise for you to do the following::
+I’m going to leave it as an exercise for you to do the following:
 
 * Make the Score counter mean something
 * Let the player restart the level if they die

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/examples/graphics/instancing.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 import random
 
 import pyglet
-from pyglet.graphics import GeometryMode
-
+from pyglet.enums import GeometryMode
 
 window = pyglet.window.Window(width=540, height=540, resizable=True)
 

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/examples/opengl/minimal_shader.py

@@ -13,8 +13,8 @@ The code shown here illustrates:
 """
 import pyglet
 
-from pyglet.enums import BlendFactor
-from pyglet.graphics import Shader, ShaderProgram, Group, GeometryMode
+from pyglet.enums import BlendFactor, GeometryMode
+from pyglet.graphics import Shader, ShaderProgram, Group
 
 ###################################
 # Create a Window, and render Batch

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/examples/opengl/opengl_core.py

@@ -1,8 +1,7 @@
 """This is a simple example that visually confirms """
 
 import pyglet
-from pyglet.graphics import GeometryMode
-
+from pyglet.enums import GeometryMode
 
 window = pyglet.window.Window(width=540, height=540, resizable=True)
 batch = pyglet.graphics.Batch()

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/examples/opengl/torus.py

@@ -17,7 +17,7 @@ from math import pi, sin, cos
 
 import pyglet
 from pyglet.config import OpenGLConfig
-from pyglet.graphics import GeometryMode
+from pyglet.enums import GeometryMode
 
 from pyglet.graphics.api.gl import (
     glEnable,

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/__init__.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev1'
+version = '3.0.dev2'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/enums.py

@@ -10,6 +10,15 @@ class GraphicsAPI(Enum):
     WEBGL = auto()
 
 
+class GeometryMode(Enum):
+    POINTS = auto()
+    LINES = auto()
+    LINE_STRIP = auto()
+    TRIANGLES = auto()
+    TRIANGLE_STRIP = auto()
+    TRIANGLE_FAN = auto()
+
+
 class BlendFactor(Enum):
     ZERO = "ZERO"
     ONE = "ONE"
@@ -86,11 +95,13 @@ class CompareOp(Enum):
     GREATER_OR_EQUAL = auto()
     ALWAYS = auto()
 
+
 class FramebufferTarget(Enum):
     FRAMEBUFFER = auto()
     DRAW = auto()
     READ = auto()
 
+
 class FramebufferAttachment(Enum):
     COLOR0 = auto()
     COLOR1 = auto()
@@ -114,7 +125,6 @@ class FramebufferAttachment(Enum):
     DEPTH_STENCIL = auto()
 
 
-
 class Weight(str, Enum):
     """An :py:class:`~enum.Enum` of known cross-platform font weight strings.
 

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/experimental/geoshader_sprite.py

@@ -4,7 +4,7 @@ import sys
 
 import pyglet
 from pyglet import clock, event, graphics, image
-from pyglet.graphics import GeometryMode
+from pyglet.enums import GeometryMode
 from pyglet.graphics.api.gl import *
 
 _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/experimental/particles.py

@@ -7,8 +7,7 @@ import time
 
 import pyglet
 from pyglet import clock, event, graphics, image
-from pyglet.graphics import GeometryMode
-from pyglet.graphics.api.gl import *
+from pyglet.enums import BlendFactor, GeometryMode
 
 _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
@@ -186,6 +185,9 @@ def get_default_shader():
 
 
 class EmitterGroup(graphics.Group):
+    blend_src: BlendFactor
+    blend_dest: BlendFactor
+
     def __init__(self, texture, blend_src, blend_dest, program, parent=None):
         super().__init__(parent=parent)
         self.texture = texture
@@ -203,15 +205,14 @@ class Emitter(event.EventDispatcher):
     _animation = None
     _frame_index = 0
     _paused = False
-    _rotation = 0
     _visible = True
     _vertex_list = None
     group_class = EmitterGroup
 
     def __init__(self, img, x, y, z, count, velocity, spread,
                  color_start=(255, 255, 255, 255), color_end=(255, 255, 255, 255),
-                 scale_start=(1.0, 1.0), scale_end=(1.0, 1.0),
-                 blend_src=GL_SRC_ALPHA, blend_dest=GL_ONE_MINUS_SRC_ALPHA,
+                 scale_start=(1.0, 1.0), scale_end=(1.0, 1.0), rotation=0.0,
+                 blend_src=BlendFactor.SRC_ALPHA, blend_dest=BlendFactor.ONE_MINUS_SRC_ALPHA,
                  batch=None, group=None, program=None):
 
         self._img = img
@@ -225,6 +226,7 @@ class Emitter(event.EventDispatcher):
         self._color_end = color_end
         self._scale_start = scale_start
         self._scale_end = scale_end
+        self._rotation = rotation
 
         if isinstance(img, image.Animation):
             self._animation = img
@@ -274,7 +276,7 @@ class Emitter(event.EventDispatcher):
                                        program,
                                        self._user_group)
         if (self._batch and
-                self._batch.update_shader(self._vertex_list, GL_POINTS, self._group, program)):
+                self._batch.update_shader(self._vertex_list, GeometryMode.POINTS, self._group, program)):
             # Exit early if changing domain is not needed.
             return
 
@@ -290,7 +292,8 @@ class Emitter(event.EventDispatcher):
         """
         if self._animation:
             clock.unschedule(self._animate)
-        self._vertex_list.delete()
+        if self._vertex_list:
+            self._vertex_list.delete()
         self._vertex_list = None
         self._texture = None
         self._group = None
@@ -357,47 +360,36 @@ class ParticleManager:
     def __init__(self, img, lifespan, count, velocity,
                  spread=(10.0, 10.0),
                  color_start=(255, 255, 255, 255), color_end=(255, 255, 255, 255),
-                 scale_start=(1.0, 1.0), scale_end=(1.0, 1.0),
+                 scale_start=(1.0, 1.0), scale_end=(1.0, 1.0), rotation=0.0,
                  batch=None, group=None):
 
         self._img = img
-        self._lifespan = lifespan
-        self._count = count
-        self._velocity = velocity
-        self._spread = spread
-        self._color_start = color_start
-        self._color_end = color_end
-        self._scale_start = scale_start
-        self._scale_end = scale_end
+        self.lifespan = lifespan
+        self.count = count
+        self.velocity = velocity
+        self.spread = spread
+        self.color_start = color_start
+        self.color_end = color_end
+        self.scale_start = scale_start
+        self.scale_end = scale_end
+        self.rotation = rotation
 
         self._batch = batch
         self._group = group
         self._program = get_default_shader()
         clock.schedule_interval(self._update_shader_time, 1 / 60)
 
-        # TODO: remove debug
-        self.total_number = 0
-        self.total_label = pyglet.text.Label("particles: 0", 10, 10, dpi=256, color=(10, 200, 10), batch=batch)
-
     def _update_shader_time(self, dt):
         self._program['time'] = time.perf_counter()
 
-    def _delete_callback(self, dt, emitter):
+    @staticmethod
+    def _delete_callback(dt, emitter):
         emitter.delete()
 
-        # TODO: remove debug
-        self.total_number -= 1
-        self.total_label.text = f"particles: {self.total_number * self._count * 8!s}"
-
     def create_emitter(self, x, y, z=0):
-        emitter = Emitter(self._img, x, y, z, self._count, self._velocity, self._spread,
-                          color_start=self._color_start, color_end=self._color_end,
-                          scale_start=self._scale_start, scale_end=self._scale_end,
+        emitter = Emitter(self._img, x, y, z, self.count, self.velocity, self.spread,
+                          color_start=self.color_start, color_end=self.color_end,
+                          scale_start=self.scale_start, scale_end=self.scale_end, rotation=self.rotation,
                           batch=self._batch, group=self._group)
-        pyglet.clock.schedule_once(self._delete_callback, self._lifespan, emitter)
-
-        # TODO: remove debug
-        self.total_number += 1
-        self.total_label.text = f"particles: {self.total_number * self._count * 8!s}"
-
+        pyglet.clock.schedule_once(self._delete_callback, self.lifespan, emitter)
         return emitter

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/__init__.py

@@ -8,8 +8,6 @@ See the :ref:`guide_graphics` for details on how to use this graphics API.
 """
 from __future__ import annotations
 
-
-from pyglet.graphics.base import GeometryMode  # noqa: F401
 from pyglet.graphics import api  # noqa: F401
 from pyglet.graphics.draw import Group, ShaderGroup  # noqa: F401
 from pyglet.graphics.state import State  # noqa: F401

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/api/gl/draw.py

@@ -14,7 +14,7 @@ from pyglet.graphics.state import State
 _debug_graphics_batch = pyglet.options.debug_graphics_batch
 
 if TYPE_CHECKING:
-    from pyglet.graphics import GeometryMode
+    from pyglet.enums import GeometryMode
     from pyglet.graphics.api.gl2.shader import ShaderProgram
     from pyglet.graphics.api.gl.vertexdomain import VertexList, IndexedVertexList
 

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/api/gl/enums.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from pyglet.graphics import GeometryMode
 from pyglet.graphics.api.gl import (
     GL_LINEAR, GL_NEAREST, GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, \
     GL_TEXTURE_CUBE_MAP, \
@@ -15,7 +14,7 @@ from pyglet.graphics.api.gl import (
     GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL,
     GL_GEQUAL, GL_ALWAYS)
 
-from pyglet.enums import BlendFactor, TextureFilter, TextureType, TextureWrapping, CompareOp
+from pyglet.enums import BlendFactor, TextureFilter, TextureType, TextureWrapping, CompareOp, GeometryMode
 
 geometry_map = {
     GeometryMode.POINTS: GL_POINTS,

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/api/gl/shader.py

@@ -42,7 +42,7 @@ from pyglet.graphics.shader import ShaderSource, ShaderType, ShaderBase, Attribu
 from pyglet.graphics.shader import ShaderException
 
 from pyglet.graphics.api.gl.buffer import BufferObject
-from pyglet.graphics import GeometryMode
+from pyglet.enums import GeometryMode
 
 if TYPE_CHECKING:
     from _weakref import CallableProxyType

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/api/gl/vertexdomain.py

@@ -64,7 +64,8 @@ from pyglet.graphics.vertexdomain import (
 if TYPE_CHECKING:
     from ctypes import Array
     from pyglet.graphics.shader import AttributeView
-    from pyglet.graphics import GeometryMode, Group
+    from pyglet.graphics import Group
+    from pyglet.enums import GeometryMode
     from pyglet.graphics.shader import Attribute
     from pyglet.customtypes import CType, DataTypes
 

{pyglet-3.0.dev1 → pyglet-3.0.dev2}/pyglet/graphics/api/gl2/draw.py

@@ -23,7 +23,7 @@ _debug_graphics_batch = pyglet.options.debug_graphics_batch
 
 if TYPE_CHECKING:
     from pyglet.graphics.state import State
-    from pyglet.graphics import GeometryMode
+    from pyglet.enums import GeometryMode
     from pyglet.graphics.api.gl2.shader import ShaderProgram