pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → pyglet-2.0.10}/examples/model/fpscamera.py

@@ -1,6 +1,6 @@
 import weakref
 
-from math import atan2, cos, sin, radians, pi
+from math import cos, sin, radians
 
 import pyglet
 
@@ -8,12 +8,18 @@ from pyglet.gl import glEnable, GL_DEPTH_TEST, GL_CULL_FACE
 from pyglet.math import Vec2, Vec3, Mat4, clamp
 
 
-window = pyglet.window.Window(width=720, height=480, resizable=True)
-batch = pyglet.graphics.Batch()
-time = 0
+class FPSCamera:
+    """A 3D projection "first person" camera example.
 
+    Windows in pyglet contain `view` and `projection` matrices,
+    which are shared with all default shaders in a `WindowBlock` UBO.
+    This Camera class handles events from the mouse & keyboard and
+    Controller, and updates these Window matrices.
 
-class FPSCamera:
+    Note mouse input will be captured once you click on the Window,
+    which sets the mouse as exclusive. Pressing ESC once will set
+    the mouse as non-exclusive.
+    """
     def __init__(self, window, position=Vec3(0, 0, 0), target=Vec3(0, 0, -1), up=Vec3(0, 1, 0)):
         self.position = position
         self.target = target
@@ -32,6 +38,8 @@ class FPSCamera:
                           pyglet.window.key.A: "left",
                           pyglet.window.key.D: "right"}
 
+        self.inputs = {direction : False for direction in self.input_map.values()}
+
         self.mouse_look = Vec2()
         self.keybord_move = Vec3()
         self.controller_look = Vec2()
@@ -40,7 +48,8 @@ class FPSCamera:
         self._window = weakref.proxy(window)
         self._window.view = Mat4.look_at(position, target, up)
         self._window.push_handlers(self)
-        self._window.set_exclusive_mouse(True)
+
+        self._exclusive_mouse = False
 
     def on_deactivate(self):
         # Prevent input from getting "stuck"
@@ -48,7 +57,7 @@ class FPSCamera:
 
     def on_resize(self, width, height):
         self._window.viewport = (0, 0, width, height)
-        self._window.projection = Mat4.perspective_projection(window.aspect_ratio, z_near=0.1, z_far=100, fov=45)
+        self._window.projection = Mat4.perspective_projection(self._window.aspect_ratio, z_near=0.1, z_far=100, fov=45)
         return pyglet.event.EVENT_HANDLED
 
     def on_refresh(self, dt):
@@ -60,12 +69,12 @@ class FPSCamera:
             self.yaw = self.yaw + self.controller_look.x
             self.pitch = clamp(self.pitch + self.controller_look.y, -89.0, 89.0)
 
-        if abs(self.mouse_look) > 0:
+        if abs(self.mouse_look) > 0.0:
             # Reset the vector back to 0 each time, because there is no event
             # for when the mouse stops moving. It will get "stuck" otherwise.
             self.yaw += self.mouse_look.x * 0.1
             self.pitch = clamp(self.pitch + self.mouse_look.y * 0.1, -89.0, 89.0)
-            self.mouse_look[:] = 0, 0
+            self.mouse_look[:] = 0.0, 0.0
 
         self.target = Vec3(cos(radians(self.yaw)) * cos(radians(self.pitch)),
                            sin(radians(self.pitch)),
@@ -78,6 +87,15 @@ class FPSCamera:
         if abs(self.controller_move) > self.deadzone:
             self.position += self.controller_move * speed
 
+        if self.inputs["forward"]:
+            self.position += (self.target * speed)
+        if self.inputs["backward"]:
+            self.position -= (self.target * speed)
+        if self.inputs["left"]:
+            self.position -= (self.target.cross(self.up).normalize() * speed)
+        if self.inputs["right"]:
+            self.position += (self.target.cross(self.up).normalize() * speed)
+
         if abs(self.keybord_move) > 0:
             self.position += self.keybord_move * speed
 
@@ -86,38 +104,31 @@ class FPSCamera:
     # Mouse input
 
     def on_mouse_motion(self, x, y, dx, dy):
+        if not self._exclusive_mouse:
+            return
         self.mouse_look[:] = dx, dy
 
+    def on_mouse_press(self, x, y, button, modifiers):
+        if not self._exclusive_mouse:
+            self._exclusive_mouse = True
+            self._window.set_exclusive_mouse(True)
+
     # Keyboard input
 
     def on_key_press(self, symbol, mod):
-        if symbol in self.input_map:
+        if symbol == pyglet.window.key.ESCAPE:
+            self._exclusive_mouse = False
+            self._window.set_exclusive_mouse(False)
+            return pyglet.event.EVENT_HANDLED
 
+        if symbol in self.input_map:
             direction = self.input_map[symbol]
-
-            if direction == 'forward':
-                self.keybord_move += self.target
-            elif direction == 'backward':
-                self.keybord_move -= self.target
-            elif direction == 'left':
-                self.keybord_move -= self.target.cross(self.up).normalize()
-            elif direction == 'right':
-                self.keybord_move += self.target.cross(self.up).normalize()
-
+            self.inputs[direction] = True
 
     def on_key_release(self, symbol, mod):
         if symbol in self.input_map:
-
             direction = self.input_map[symbol]
-
-            if direction == 'forward':
-                self.keybord_move -= self.target
-            elif direction == 'backward':
-                self.keybord_move += self.target
-            elif direction == 'left':
-                self.keybord_move += self.target.cross(self.up).normalize()
-            elif direction == 'right':
-                self.keybord_move -= self.target.cross(self.up).normalize()
+            self.inputs[direction] = False
 
     # Controller input
 
@@ -126,25 +137,26 @@ class FPSCamera:
             self.controller_move = self.target * yvalue + self.target.cross(self.up).normalize() * xvalue
 
         elif stick == "rightstick":
-            self.controller_look[:] = xvalue, yvalue, 0
+            self.controller_look[:] = xvalue, yvalue
 
 
 
-@window.event
-def on_draw():
-    window.clear()
-    batch.draw()
+if __name__ == "__main__":
+    window = pyglet.window.Window(width=964, height=540, resizable=True)
+    batch = pyglet.graphics.Batch()
 
+    @window.event
+    def on_draw():
+        window.clear()
+        batch.draw()
 
-if __name__ == "__main__":
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_CULL_FACE)
 
     model_logo = pyglet.model.load("logo3d.obj", batch=batch)
     model_box = pyglet.model.load("box.obj", batch=batch)
 
-    # Set the application wide view matrix (camera):
-    # window.view = Mat4.look_at(position=Vec3(0, 0, 5), target=Vec3(0, 0, 0), up=Vec3(0, 1, 0))
+    # Camera controls the global projection & view matrixes:
     camera = FPSCamera(window, position=Vec3(0, 0, 5))
 
     if controllers := pyglet.input.get_controllers():

pyglet-2.0.10/examples/net/client.py

@@ -0,0 +1,18 @@
+from pyglet.experimental import net
+
+
+client = net.Client(address='localhost', port=1234)
+
+
+@client.event
+def on_receive(message):
+    print(f"Received: {message}")
+
+
+@client.event
+def on_disconnect(message):
+    print(f"Received: {message}")
+
+
+client.send(b'ping')
+

pyglet-2.0.10/examples/net/server.py

@@ -0,0 +1,25 @@
+import pyglet
+
+from pyglet.experimental import net
+
+
+server = net.Server(address='0.0.0.0', port=1234)
+
+
+def pong(connection, message):
+    print(f"Received '{message}' from '{connection}'")
+    connection.send(b'pong')
+
+
+@server.event
+def on_connection(connection):
+    print(f"New client connected: {connection}")
+    connection.set_handler('on_receive', pong)
+
+
+@server.event
+def on_disconnection(connection):
+    print(f"Client disconnected: {connection}")
+
+
+pyglet.app.run()

pyglet-2.0.10/examples/opengl/compute_shader.py

@@ -0,0 +1,39 @@
+"""Minimal Compute Shader example.
+
+This example creates a Compute Shader from source,
+attached a texture to it, and writes into the texture.
+The texture is then saved to disk as a .png file.
+"""
+
+import pyglet
+
+from pyglet.gl import GL_RGBA32F, GL_ALL_BARRIER_BITS
+
+
+compute_src = """#version 430 core
+layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+
+layout(rgba32f) uniform image2D img_output;
+
+void main() {
+    vec4 value = vec4(0.0, 0.0, 0.0, 1.0);
+    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);
+    value.r = float(texel_coord.x)/(gl_NumWorkGroups.x);
+    value.g = float(texel_coord.y)/(gl_NumWorkGroups.y);
+
+    imageStore(img_output, texel_coord, value);
+}
+"""
+
+program = pyglet.graphics.shader.ComputeShaderProgram(compute_src)
+
+# Create a Texture, and bind it to the shader
+out_texture = pyglet.image.Texture.create(540, 540, internalformat=GL_RGBA32F)
+out_texture.bind_image_texture(unit=program.uniforms['img_output'].location)
+
+
+with program:
+    program.dispatch(out_texture.width, out_texture.height, 1, barrier=GL_ALL_BARRIER_BITS)
+
+
+out_texture.save('compute_output.png')

{pyglet-2.0.8/examples/graphics → pyglet-2.0.10/examples}/shapes.py

@@ -43,6 +43,8 @@ class ShapesDemo(pyglet.window.Window):
 
         self.polygon = shapes.Polygon([400, 100], [500, 10], [600, 100], [550, 175], [450, 150], batch=self.batch)
 
+        self.box = shapes.Box(60, 40, 200, 100, thickness=2, color=(244, 55, 55), batch=self.batch)
+
     def on_draw(self):
         """Clear the screen and draw shapes"""
         self.clear()
@@ -54,6 +56,7 @@ class ShapesDemo(pyglet.window.Window):
         self.square.rotation = self.time * 15
         self.rectangle.y = 200 + math.sin(self.time) * 190
         self.circle.radius = 75 + math.sin(self.time * 1.17) * 25
+        self.triangle.rotation = self.time * 15
 
         self.line.x = 360 + math.sin(self.time * 0.81) * 360
         self.line.x2 = 360 + math.sin(self.time * 1.34) * 360

{pyglet-2.0.8 → pyglet-2.0.10}/examples/window/fixed_resolution.py

@@ -4,28 +4,32 @@ size, but rendering to the full screen.
 
 The method used in this example is:
 
-1. Create a Framebuffer object, and a Texture of the desired resolution
-2. Attach the Texture to the Framebuffer.
-2. Bind the Framebuffer as the current render target.
-3. Render the scene using any OpenGL functions (here, just a shape).
-4. Unbind the Framebuffer, and blit the Texture scaled to fill the screen.
+1. Create a Framebuffer object, a Texture, and a depth buffer.
+2. Attach the Texture and depth buffer to the Framebuffer.
+3. Bind the Framebuffer as the current render target.
+4. Render the scene using any OpenGL functions (here, just a shape).
+5. Unbind the Framebuffer, and blit the Texture scaled to fill the screen.
 """
 
-from pyglet.gl import *
 import pyglet
 
+from pyglet.gl import *
+
 
 class FixedResolution:
     def __init__(self, window, width, height):
         self.window = window
+        self.window.set_minimum_size(width, height)
         self.width = width
         self.height = height
 
         self._target_area = 0, 0, 0, 0, 0
 
         self.framebuffer = pyglet.image.Framebuffer()
-        self.texture = pyglet.image.Texture.create(width, height, min_filter=GL_NEAREST, mag_filter=GL_NEAREST)
-        self.framebuffer.attach_texture(self.texture)
+        self._color_buffer = pyglet.image.Texture.create(width, height, min_filter=GL_NEAREST, mag_filter=GL_NEAREST)
+        self._depth_buffer = pyglet.image.buffer.Renderbuffer(width, height, GL_DEPTH_COMPONENT)
+        self.framebuffer.attach_texture(self._color_buffer)
+        self.framebuffer.attach_renderbuffer(self._depth_buffer, attachment=GL_DEPTH_ATTACHMENT)
 
         self.window.push_handlers(self)
 
@@ -52,7 +56,7 @@ class FixedResolution:
 
     def __exit__(self, *unused):
         self.framebuffer.unbind()
-        self.texture.blit(*self._target_area)
+        self._color_buffer.blit(*self._target_area)
 
     def begin(self):
         self.__enter__()
@@ -65,37 +69,36 @@ class FixedResolution:
 # Simple program using the Viewport:
 ###################################
 
-window = pyglet.window.Window(960, 540, resizable=True)
-
-# Create an instance of the FixedResolution class. Use
-# 320x180 resolution to make the effect completely obvious:
-fixed_res = FixedResolution(window, width=320, height=180)
-
+if __name__ == '__main__':
+    window = pyglet.window.Window(960, 540, resizable=True)
 
-def update(dt):
-    global rectangle
-    rectangle.rotation += dt * 10
+    # Create an instance of the FixedResolution class. Use
+    # 320x180 resolution to make the effect completely obvious:
+    fixed_res = FixedResolution(window, width=320, height=180)
 
 
-@window.event
-def on_draw():
-    window.clear()
+    @window.event
+    def on_draw():
+        window.clear()
 
-    # The FixedResolution instance can be used as a context manager:
-    with fixed_res:
-        rectangle.draw()
+        # The FixedResolution instance can be used as a context manager:
+        with fixed_res:
+            rectangle.draw()
 
-    # # Alternatively, you can do it manually:
-    # fixed_res.begin()
-    # rectangle.draw()
-    # fixed_res.end()
+        # # Alternatively, you can do it manually:
+        # fixed_res.begin()
+        # rectangle.draw()
+        # fixed_res.end()
 
 
-# Create a simple Rectangle to show the effect
-rectangle = pyglet.shapes.Rectangle(x=160, y=90, color=(200, 50, 50), width=100, height=100)
-rectangle.anchor_position = 50, 50
+    # Create a simple Rectangle to show the effect
+    rectangle = pyglet.shapes.Rectangle(x=160, y=90, color=(200, 50, 50), width=100, height=100)
+    rectangle.anchor_position = 50, 50
 
-# Schedule the update function at 60fps
-pyglet.clock.schedule_interval(update, 1/60)
-pyglet.app.run()
+    def update(dt):
+        global rectangle
+        rectangle.rotation += dt * 10
 
+    # Schedule the update function at 60fps
+    pyglet.clock.schedule_interval(update, 1 / 60)
+    pyglet.app.run()

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/__init__.py

@@ -9,7 +9,7 @@ import sys
 from typing import TYPE_CHECKING
 
 #: The release version
-version = '2.0.8'
+version = '2.0.10'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -31,8 +31,10 @@ _enable_optimisations = not __debug__
 if getattr(sys, 'frozen', None):
     _enable_optimisations = True
 
-#: Global dict of pyglet options.  To change an option from its default, you
-#: must import ``pyglet`` before any sub-packages.  For example::
+#: Global dict of pyglet options.
+#:
+#: To change an option from its default, you must import
+#: ``pyglet`` before any sub-packages.  For example::
 #:
 #:      import pyglet
 #:      pyglet.options['debug_gl'] = False
@@ -48,14 +50,21 @@ if getattr(sys, 'frozen', None):
 #: The non-development options are:
 #:
 #: audio
-#:     A sequence of the names of audio modules to attempt to load, in
-#:     order of preference.  Valid driver names are:
+#:     A :py:class:`~typing.Sequence` of valid audio modules names. They will
+#:     be tried from first to last until either a driver loads or no entries
+#:     remain. See :ref:`guide-audio-driver-order` for more information.
+#:
+#:     Valid driver names are:
+#:
+#:     * ``'xaudio2'``, the Windows Xaudio2 audio module (Windows only)
+#:     * ``'directsound'``, the Windows DirectSound audio module (Windows only)
+#:     * ``'pulse'``, the :ref:`guide-audio-driver-pulseaudio` module
+#:        (Linux only, otherwise nearly ubiquitous. Limited features; use
+#:        ``'openal'`` for more.)
+#:     * ``'openal'``, the :ref:`guide-audio-driver-openal` audio module
+#:       (A library may need to be installed on Windows and Linux)
+#:     * ``'silent'``, no audio
 #:
-#:     * xaudio2, the Windows Xaudio2 audio module (Windows only)
-#:     * directsound, the Windows DirectSound audio module (Windows only)
-#:     * pulse, the PulseAudio module (Linux only)
-#:     * openal, the OpenAL audio module
-#:     * silent, no audio
 #: debug_lib
 #:     If True, prints the path of each dynamic library loaded.
 #: debug_gl
@@ -336,6 +345,7 @@ if TYPE_CHECKING:
     from . import app
     from . import canvas
     from . import clock
+    from . import customtypes
     from . import event
     from . import font
     from . import gl
@@ -356,6 +366,7 @@ else:
     app = _ModuleProxy('app')
     canvas = _ModuleProxy('canvas')
     clock = _ModuleProxy('clock')
+    customtypes = _ModuleProxy('customtypes')
     event = _ModuleProxy('event')
     font = _ModuleProxy('font')
     gl = _ModuleProxy('gl')

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/app/base.py

@@ -122,12 +122,24 @@ class EventLoop(event.EventDispatcher):
     def run(self, interval=1/60):
         """Begin processing events, scheduled functions and window updates.
 
+        :Parameters:
+            `interval` : float or None [default: 1/60]
+                Windows redraw interval, in seconds (framerate).
+                If `interval == 0`, windows will redraw at maximum rate.
+                If `interval is None`, Pyglet will not call its redraw function.
+                The user must schedule (or call on demand) a custom redraw
+                function for each window, allowing a custom framerate per window.
+                (see example in documentation)
+
         This method returns when :py:attr:`has_exit` is set to True.
 
         Developers are discouraged from overriding this method, as the
         implementation is platform-specific.
         """
-        if not interval:
+        if interval is None:
+            # User application will manage a custom _redraw_windows() method
+            pass
+        elif interval == 0:
             self.clock.schedule(self._redraw_windows)
         else:
             self.clock.schedule_interval(self._redraw_windows, interval)

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/canvas/cocoa.py

@@ -78,6 +78,12 @@ class CocoaScreen(Screen):
         self.height = mode.height
 
     def restore_mode(self):
+        match_attrs = ['width', 'height', 'depth', 'rate']
+        current_mode = self.get_mode()
+        if all(getattr(current_mode, attr) == getattr(self._default_mode, attr) for
+               attr in match_attrs):
+            # Already in default mode
+            return
         quartz.CGDisplaySetDisplayMode(self._cg_display_id, self._default_mode.cgmode, None)
         quartz.CGDisplayRelease(self._cg_display_id)