pyglet 3.0.dev4__tar.gz → 3.0.dev6__tar.gz

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: pyglet
-Version: 3.0.dev4
+Version: 3.0.dev6
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Project-URL: Home, https://pyglet.org

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/contrib/dist_field/renderfield.py

@@ -33,7 +33,7 @@ class DistFieldGroup(pyglet.sprite.SpriteGroup):
     def __init__(self, texture: Texture, blend_src: BlendFactor, blend_dest: BlendFactor, program: ShaderProgram,
                  parent: Group | None = None) -> None:
         super().__init__(texture, blend_src, blend_dest, program, parent)
-        self.add_state(DepthFieldUniforms(program))
+        self.set_state(DepthFieldUniforms(program))
 
 
 class DistFieldSprite(pyglet.sprite.Sprite):

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/contrib/svg/svg_test.py

@@ -246,7 +246,7 @@ class SVG:
         shader_group = ShaderGroup(self.shader)
         self.line_group = Group(parent=shader_group)
         self.line_group.set_blend(BlendFactor.SRC_ALPHA, BlendFactor.ONE_MINUS_SRC_ALPHA)
-        self.line_group.add_state(LineSmoothState())
+        self.line_group.set_state(LineSmoothState())
 
         dom = xml.dom.minidom.parse(filename)
         svg_tag = dom.documentElement

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/doc/index.rst

@@ -42,6 +42,7 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/installation
    programming_guide/quickstart
    programming_guide/windowing
+   programming_guide/camera
    programming_guide/keyboard
    programming_guide/mouse
    programming_guide/input
@@ -53,6 +54,7 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/resources
    programming_guide/texture
    programming_guide/rendering
+   programming_guide/camera
    programming_guide/events
    programming_guide/gui
    programming_guide/time

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/doc/modules/window.rst

@@ -6,6 +6,7 @@ pyglet.window
 .. toctree::
    :maxdepth: 1
 
+   window_camera
    dialog
    window_key
    window_mouse
@@ -89,6 +90,7 @@ Classes
   .. autoattribute:: context
   .. autoattribute:: display
   .. autoattribute:: dpi
+  .. autoattribute:: default_camera
   .. autoattribute:: fullscreen
   .. autoattribute:: has_exit
   .. autoattribute:: height

pyglet-3.0.dev6/doc/programming_guide/camera.rst

@@ -0,0 +1,131 @@
+.. _guide_camera:
+
+Cameras and Views
+=================
+
+Pyglet provides camera scopes in :py:mod:`pyglet.window.camera` for 2D and 3D rendering.
+For common 2D workflows, use :py:class:`~pyglet.window.camera.Camera2D`. By default, the
+window is created with a 2D camera.
+
+Default camera behavior
+-----------------------
+
+Every window has a default camera at :py:attr:`pyglet.window.Window.default_camera`.
+The :py:attr:`~pyglet.window.Window.projection`, :py:attr:`~pyglet.window.Window.view`,
+and :py:attr:`~pyglet.window.Window.viewport` properties proxy directly to it.
+
+The default camera is initialized with the window context creation and applies itself
+automatically.
+
+Creating a camera
+-----------------
+
+Create cameras from a window, and optionally configure scroll/zoom behavior::
+
+    window = pyglet.window.Window()
+
+    world_camera = pyglet.window.camera.Camera2D(
+        window,
+        scroll_speed=5,
+        min_zoom=1,
+        max_zoom=4,
+    )
+    gui_camera = pyglet.window.camera.Camera2D(window)
+
+    world_camera.zoom += 0.25
+    world_camera.move(1, 0)
+    world_camera.position = (50, 0)
+
+
+Creating views
+--------------
+
+A camera can have multiple views. Views let you scope additional transforms and scissor
+areas inside one camera.
+
+Use ``camera.create_view()`` for additional view scopes. This is useful for parallax
+layers, minimaps, and nested local transforms::
+
+    window = pyglet.window.Window()
+
+    ui_camera = pyglet.window.camera.Camera2D(window)
+    inherited_view = ui_camera.create_view(inherit=True)      # Inherits parent transform chain.
+    independent_view = ui_camera.create_view(inherit=False)   # Parented to camera root view.
+
+Views share the camera's viewport/projection behavior and can be used anywhere a camera
+scope is expected.
+
+Views can also be created from other views. For example::
+
+    ui_camera = pyglet.window.camera.Camera2D(window)
+    scroll_box_a = ui_camera.create_view()
+    scroll_box_b = scroll_box_a.create_view()
+
+If ``scroll_box_a`` moves or zooms, ``scroll_box_b`` inherits those changes.
+
+Using camera scopes with batches
+--------------------------------
+
+Cameras can be used to target a specific batch instead of groups::
+
+    @window.event
+    def on_draw():
+        window.clear()
+
+        with world_batch.draw_with_options() as options:
+            options.camera = world_camera
+
+        with gui_batch.draw_with_options() as options:
+            options.camera = gui_camera
+
+
+Using camera scopes in groups
+-----------------------------
+
+Attach camera scopes to groups with ``Group.set_camera``::
+
+    world_group = pyglet.graphics.Group(order=0)
+    world_group.set_camera(world_camera)
+
+    ui_group = pyglet.graphics.Group(order=1)
+    ui_group.set_camera(window.default_camera)
+
+    pyglet.sprite.Sprite(world_image, batch=batch, group=world_group)
+    pyglet.text.Label("HUD", batch=batch, group=ui_group)
+
+
+.. note:: ``Group.set_camera`` applies camera state at draw entry by calling ``begin()``.
+          It does not call ``end()`` during group unsetting.
+
+Viewport
+--------
+
+Each camera has a ``viewport`` in framebuffer coordinates::
+
+    world_camera.viewport = (0, 0, window.width // 2, window.height)
+
+By default, viewport follows the full framebuffer and updates on resize/scale events.
+Setting a tuple makes viewport explicit, and will no longer update automatically. In those
+cases you will have to update your viewport coordinates explicitly.
+
+Scissor
+-------
+
+Scissor clipping can be set on both cameras and views.
+
+Use ``set_scissor_area(...)`` for fixed window-space clipping::
+
+    world_camera.set_scissor_area(0, 0, window.width // 2, window.height)
+
+Use ``set_scissor_area_relative(...)`` when clipping should move with the
+camera/view transform::
+
+    moving_panel = ui_camera.create_view(inherit=True)
+    moving_panel.set_scissor_area_relative(40, 40, 280, 160)
+    moving_panel.offset_x += 16   # Scissor follows the moved view
+
+When a camera/view is applied through ``Group.set_camera``, pyglet automatically applies
+matching scissor state for that group.
+
+For nested views, the effective scissor is the intersection of all scissor areas in the
+view chain.

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/doc/programming_guide/eventloop.rst

@@ -120,14 +120,13 @@ for the following reasons:
 With that out of the way, a manual event loop usually has the following form::
 
     while True:
-        pyglet.clock.tick()
+        dt = pyglet.clock.tick()
         pyglet.app.platform_event_loop.step(timeout)
 
         for window in pyglet.app.windows:
             window.switch_to()
             window.dispatch_events()
-            window.dispatch_event('on_draw')
-            window.flip()
+            window.draw(dt)
 
 The call to :py:func:`pyglet.clock.tick` is required for ensuring scheduled
 functions are called, including the internal data pump functions for playing

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/doc/programming_guide/migration.rst

@@ -98,6 +98,30 @@ Instead, to draw an image, create a py:class:`~pyglet.sprite.Sprite` and constru
 Additionally, ``ImageData.get_data`` and ``ImageData.set_data`` have been removed after being deprecated. Use
 ``ImageData.get_bytes`` and ``ImageData.set_bytes`` instead (the same applies to ``ImageDataRegion``).
 
+Removed image buffer APIs
+-------------------------
+The legacy ``pyglet.image`` buffer API has been removed.
+
+The following names have been removed:
+
+* ``pyglet.image.BufferManager``
+* ``pyglet.image.get_buffer_manager``
+* ``pyglet.image.BufferImage``
+* ``pyglet.image.ColorBufferImage``
+* ``pyglet.image.DepthBufferImage``
+* ``pyglet.image.BufferImageMask``
+
+For explicit framebuffer objects, use
+:py:class:`pyglet.graphics.framebuffer.Framebuffer`.
+
+For screenshots, replace this pattern::
+
+    pyglet.image.get_buffer_manager().get_color_buffer().save('screenshot.png')
+
+With::
+
+    pyglet.graphics.framebuffer.get_screenshot().save("screenshot.png")
+
 
 Resource Image and Texture Loading
 ----------------------------------

{pyglet-3.0.dev4 → pyglet-3.0.dev6}/doc/requirements.txt

@@ -1,5 +1,5 @@
-sphinx==9.1.0
+sphinx==9.0.4
 sphinx_rtd_theme==3.1.0
 readthedocs-sphinx-search==0.3.2
-sphinx-autodoc-typehints==3.10.2
+sphinx-autodoc-typehints==3.6.1
 pytest

pyglet-3.0.dev6/examples/graphics/uniform_buffer_object.py

@@ -0,0 +1,152 @@
+"""Uniform Buffer Object region example.
+
+This example uses one shader program with three material UBO regions. Each
+group binds a different region before its shape is drawn.
+"""
+
+from __future__ import annotations
+
+import math
+
+import pyglet
+from pyglet.enums import GeometryMode, GraphicsAPI
+
+
+if pyglet.options.backend != GraphicsAPI.OPENGL:
+    raise RuntimeError("This example uses OpenGL 3.3 shader syntax. Run it with the OpenGL backend.")
+
+
+window = pyglet.window.Window(width=720, height=480, caption="Uniform Buffer Object", resizable=True)
+batch = pyglet.graphics.Batch()
+
+
+vertex_source = """#version 330 core
+    in vec2 position;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    layout(std140) uniform MaterialBlock
+    {
+        vec4 color;
+        vec4 offset_scale;
+    } material;
+
+    out vec4 vertex_color;
+
+    void main()
+    {
+        vec2 scaled_position = position * material.offset_scale.zw;
+        vec2 world_position = scaled_position + material.offset_scale.xy;
+        gl_Position = window.projection * window.view * vec4(world_position, 0.0, 1.0);
+        vertex_color = material.color;
+    }
+"""
+
+fragment_source = """#version 330 core
+    in vec4 vertex_color;
+    out vec4 final_color;
+
+    void main()
+    {
+        final_color = vertex_color;
+    }
+"""
+
+program = pyglet.graphics.ShaderProgram(
+    pyglet.graphics.Shader(vertex_source, "vertex"),
+    pyglet.graphics.Shader(fragment_source, "fragment"),
+)
+
+material_block = program.uniform_blocks["MaterialBlock"]
+
+
+def create_material(color: tuple[float, float, float, float],
+                    offset_scale: tuple[float, float, float, float]):
+    region = material_block.create_ubo_region()
+    # When creating the material, ensure it has some initial data.
+    with region as material_region:
+        material_region.color[:] = color
+        material_region.offset_scale[:] = offset_scale
+    return region
+
+
+triangle_vertices = (
+    -0.6, -0.5,
+     0.6, -0.5,
+     0.0,  0.6,
+)
+
+quad_vertices = (
+    -0.5, -0.5,
+     0.5, -0.5,
+     0.5,  0.5,
+    -0.5,  0.5,
+)
+
+materials = [
+    create_material((0.95, 0.30, 0.22, 1.0), (160.0, 240.0, 100.0, 100.0)),
+    create_material((0.18, 0.64, 0.96, 1.0), (360.0, 240.0, 120.0, 120.0)),
+    create_material((0.90, 0.82, 0.28, 1.0), (560.0, 240.0, 90.0, 90.0)),
+]
+elapsed_time = 0.0
+
+groups = []
+# Give each separate material its own group, so the dirty regions can be committed during draw.
+for material in materials:
+    group = pyglet.graphics.ShaderGroup(program)
+    group.set_uniform_buffer(material)
+    groups.append(group)
+
+triangle_1 = program.vertex_list(
+    3,
+    GeometryMode.TRIANGLES,
+    batch=batch,
+    group=groups[0],
+    position=("f", triangle_vertices),
+)
+triangle_2 = program.vertex_list_indexed(
+    4,
+    GeometryMode.TRIANGLES,
+    indices=(0, 1, 2, 0, 2, 3),
+    batch=batch,
+    group=groups[1],
+    position=("f", quad_vertices),
+)
+triangle_3 = program.vertex_list(
+    3,
+    GeometryMode.TRIANGLES,
+    batch=batch,
+    group=groups[2],
+    position=("f", triangle_vertices),
+)
+
+
+def update_materials(dt: float) -> None:
+    global elapsed_time
+    elapsed_time += dt
+
+    for index, region in enumerate(materials):
+        angle = elapsed_time * 1.6 + index * 2.1
+        center_x = 360.0 + math.cos(angle) * (120.0 + index * 18.0)
+        center_y = 240.0 + math.sin(angle * 0.8) * (70.0 + index * 12.0)
+
+        with region as material_region:
+            material_region.offset_scale[0] = center_x
+            material_region.offset_scale[1] = center_y
+
+
+@window.event
+def on_draw() -> None:
+    window.clear()
+    batch.draw()
+
+
+pyglet.clock.schedule_interval(update_materials, 1 / 60)
+
+
+if __name__ == "__main__":
+    pyglet.app.run()

pyglet-3.0.dev6/examples/model/fpscamera.py

@@ -0,0 +1,293 @@
+"""A basic first-person camera example using :mod:`pyglet.window.camera`."""
+
+from __future__ import annotations
+
+import random
+import weakref
+
+import pyglet
+from pyglet.math import Vec2, Vec3
+from pyglet.window import key as _key
+from pyglet.window.camera import FPSCamera
+
+
+class FPSCameraControls:
+    """First-person controls from the old example, driving a camera object."""
+
+    def __init__(self, window: pyglet.window.Window, camera: FPSCamera) -> None:
+        """Initialize the controls."""
+        self._window = weakref.proxy(window)
+        self.camera = camera
+        self._exclusive_mouse = False
+
+        # Input from keyboard and controller
+        self.keyboard_move = Vec2()
+        self.mouse_look = Vec2()
+
+        self.controller_move = Vec2()
+        self.controller_look = Vec2()
+        self.dead_zone = 0.1
+        self._elevation = 0.0
+
+        # Keyboard input maps
+        self.input_map = {  # Look up direction based on key symbol
+            _key.W: "forward",
+            _key.S: "backward",
+            _key.A: "left",
+            _key.D: "right",
+            _key.E: "up",
+            _key.Q: "down",
+        }
+        # Stores the direction string and the state of the direction
+        self.inputs = {direction: False for direction in self.input_map.values()}
+
+        self._window.push_handlers(self)
+        self.on_refresh(0.0)
+
+    @property
+    def position(self) -> Vec3:
+        return self.camera.position
+
+    @position.setter
+    def position(self, value: Vec3) -> None:
+        self.camera.position = value
+
+    @property
+    def pitch(self) -> float:
+        return self.camera.pitch
+
+    @pitch.setter
+    def pitch(self, value: float) -> None:
+        self.camera.pitch = value
+
+    @property
+    def yaw(self) -> float:
+        return self.camera.yaw
+
+    @yaw.setter
+    def yaw(self, value: float) -> None:
+        self.camera.yaw = value
+
+    @property
+    def field_of_view(self) -> float:
+        return self.camera.field_of_view
+
+    @field_of_view.setter
+    def field_of_view(self, value: float) -> None:
+        self.camera.field_of_view = value
+
+    @property
+    def near(self) -> float:
+        return self.camera.near
+
+    @near.setter
+    def near(self, value: float) -> None:
+        self.camera.near = value
+
+    @property
+    def far(self) -> float:
+        return self.camera.far
+
+    @far.setter
+    def far(self, value: float) -> None:
+        self.camera.far = value
+
+    @property
+    def walk_speed(self) -> float:
+        return self.camera.walk_speed
+
+    @walk_speed.setter
+    def walk_speed(self, value: float) -> None:
+        self.camera.walk_speed = value
+
+    @property
+    def look_speed(self) -> float:
+        return self.camera.look_speed
+
+    @look_speed.setter
+    def look_speed(self, value: float) -> None:
+        self.camera.look_speed = value
+
+    def on_refresh(self, delta_time: float) -> None:
+        """Called before the window content is drawn.
+
+        Runs every frame applying the camera movement.
+        """
+        look_speed = self.look_speed * delta_time
+
+        # Rotation - mouse
+        if self.mouse_look:
+            self.yaw += self.mouse_look.x * look_speed
+            self.pitch += self.mouse_look.y * look_speed
+            # Reset the relative mouse movement when done.
+            self.mouse_look = Vec2()
+
+        # Rotation - controller
+        if self.controller_look:
+            self.yaw += self.controller_look.x * look_speed * 20
+            self.pitch += self.controller_look.y * look_speed * 20
+
+        movement = Vec2()
+
+        # Translation - keyboard
+        if self.keyboard_move:
+            movement += self.keyboard_move
+
+        # Translation - controller
+        if self.controller_move:
+            movement += self.controller_move
+
+        if movement:
+            movement = movement.normalize()
+
+        self.camera.apply_movement_input(movement, self._elevation, delta_time)
+
+    def on_deactivate(self) -> None:
+        """Reset the movement states when the window loses focus."""
+        self.controller_look = Vec2()
+        self.controller_move = Vec2()
+
+    def teleport(self, position: Vec3, target: Vec3 | None = None) -> None:
+        """Teleport the camera to a new position."""
+        self.camera.teleport(position, target)
+
+    # --- Mouse input ---
+
+    def on_mouse_motion(self, _x: int, _y: int, dx: int, dy: int) -> None:
+        """Read the mouse input and update the camera's yaw and pitch."""
+        if not self._exclusive_mouse:
+            return
+
+        self.mouse_look = Vec2(dx, dy)
+
+    def on_mouse_press(self, _x: int, _y: int, _button: int, _modifiers: int) -> None:
+        """Capture the mouse input when the window is clicked."""
+        if not self._exclusive_mouse:
+            self._exclusive_mouse = True
+            self._window.set_exclusive_mouse(True)
+
+    # --- Keyboard input ---
+
+    def on_key_press(self, symbol: int, _modifiers: int) -> bool:
+        """Handle keyboard input."""
+        if direction := self.input_map.get(symbol):
+            self.inputs[direction] = True
+            forward, backward, left, right, up, down = self.inputs.values()
+            self.keyboard_move = Vec2(-float(left) + float(right), float(forward) + -float(backward)).normalize()
+            self._elevation = float(up) + -float(down)
+            return pyglet.event.EVENT_HANDLED
+
+        if symbol == pyglet.window.key.ESCAPE:
+            if not self._exclusive_mouse:
+                pyglet.app.exit()
+            self._exclusive_mouse = False
+            self._window.set_exclusive_mouse(False)
+            return pyglet.event.EVENT_HANDLED
+
+        return False
+
+    def on_key_release(self, symbol: int, _modifiers: int) -> bool:
+        """Handle keyboard input release."""
+        if direction := self.input_map.get(symbol):
+            self.inputs[direction] = False
+            forward, backward, left, right, up, down = self.inputs.values()
+            self.keyboard_move = Vec2(-float(left) + float(right), float(forward) + -float(backward)).normalize()
+            self._elevation = float(up) + -float(down)
+            return pyglet.event.EVENT_HANDLED
+
+        return False
+
+    # --- Controller input ---
+
+    def on_leftstick_motion(self, _controller: pyglet.input.Controller, vector: Vec2) -> None:
+        """Right Controller stick controlls the camera position."""
+        if vector.length() < self.dead_zone:
+            self.controller_move = Vec2()
+        else:
+            self.controller_move = vector
+
+    def on_rightstick_motion(self, _controller: pyglet.input.Controller, vector: Vec2) -> None:
+        """Right Controller stick controlls the camera rotation."""
+        if vector.length() >= self.dead_zone:
+            self.controller_look = vector
+        else:
+            self.controller_look = Vec2()
+
+    def on_lefttrigger_motion(self, _controller: pyglet.input.Controller, value: float) -> None:
+        """Left trigger lowers the elevation."""
+        self._elevation = -value
+
+    def on_righttrigger_motion(self, _controller: pyglet.input.Controller, value: float) -> None:
+        """Right trigger raises the elevation."""
+        self._elevation = value
+
+
+window = pyglet.window.Window(resizable=True)
+batch = pyglet.graphics.Batch()
+
+# These .obj files only have a single model in the scene:
+logo_model = pyglet.resource.scene("logo3d.obj").create_models(batch=batch)[0]
+box_model = pyglet.resource.scene("box.obj").create_models(batch=batch)[0]
+
+# You have to make at least one instance of a model for it to appear:
+box_instance = box_model.create_instance(translation=Vec3(2.0, 0.0, 0.0))
+
+# You can make as many instances as you want, with their own translation:
+logo_instances = []
+for _ in range(500):
+    x, y, z = random.uniform(-100, 100), random.uniform(1.0, 5.0), random.uniform(-100, 100)
+    logo_instances.append(logo_model.create_instance(translation=Vec3(x, y, z)))
+
+# Create some sphere shapes (their centers are at y==0.0):
+sphere_model = pyglet.model.Sphere(4.0, color=(0.3, 0.3, 1.0, 0.3), batch=batch)
+sphere_instances = []
+for _ in range(500):
+    x = random.uniform(-100, 100)
+    y = random.uniform(1.0, 5.0)
+    z = random.uniform(-100, 100)
+    sphere_instances.append(sphere_model.create_instance(translation=Vec3(x, y, z)))
+
+# Create some capsule shapes (their bottoms start at y==0.0):
+capsule_model = pyglet.model.Capsule(1.0, height=3.0, batch=batch)
+capsule_instances = []
+for _ in range(500):
+    x = random.uniform(-100, 100)
+    y = random.uniform(0.0, 5.0)
+    z = random.uniform(-100, 100)
+    capsule_instances.append(capsule_model.create_instance(translation=Vec3(x, y, z)))
+
+# Make a "floor", positioned so its top is at y==0.0:
+floor_model = pyglet.model.Cube(width=999, height=1.0, depth=999, batch=batch)
+floor_instance = floor_model.create_instance(translation=Vec3(0.0, -1.5, 0.0))
+
+# Create the FPSCamera instance, which controls the global projection & view matrixes.
+# Start with the position a bit back, and looking at the center of the scene:
+# Click the window to capture the mouse. Use WASD to move, E/Q for vertical movement,
+# and Esc to release the mouse or exit when the mouse is already released.
+camera = FPSCamera(
+    window,
+    position=Vec3(0.0, 1.0, 6.0),
+    target=Vec3(0.0, 1.0, 0.0),
+)
+controls = FPSCameraControls(window, camera)
+if controllers := pyglet.input.get_controllers():
+    controller = controllers[0]
+    controller.open()
+    controller.push_handlers(controls)
+
+# def update(dt):
+#     update.elapsed += dt
+#     box_instance.rotation = Quaternion.from_rotation(0.1 * update.elapsed, Vec3(1.0, 0.0, 0.0))
+# 
+# 
+# update.elapsed = 0.0
+# 
+# pyglet.clock.schedule_interval(update, 1/33)
+
+@window.event
+def on_draw() -> None:
+    window.clear()
+    with batch.draw_with_options() as options:
+        options.camera = camera
+
+pyglet.app.run()