pyglet 3.0.dev3__tar.gz → 3.0.dev5__tar.gz

pyglet-3.0.dev5/.github/workflows/unittests.yml

@@ -0,0 +1,190 @@
+name: PyTest
+
+on: [push, pull_request]
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13', '3.14', 'pypy-3.10' ]
+
+    name: Python ${{ matrix.python-version }} Ubuntu
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest
+          sudo apt-get update
+          sudo apt-get install -y libopenal1 openal-tools
+          sudo apt-get install xvfb ffmpeg
+      - name: Run tests
+        env:
+          ALSOFT_DRIVERS: "null"
+          ALSOFT_LOGLEVEL: 1
+        run: |
+          backend_overrides=(
+            "opengl:4.6"
+            "gl2:2.0"
+            "gles2:2.0"
+            "gles3:3.2"
+          )
+
+          export PYGLET_BACKEND=opengl
+          export MESA_GL_VERSION_OVERRIDE=4.6
+          export MESA_GLES_VERSION_OVERRIDE=4.6
+          openal-info || true
+          xvfb-run --auto-servernum  python3 -m pyglet.info
+          xvfb-run --auto-servernum  pytest tests \
+            --ignore=tests/interactive \
+            --ignore=tests/integration/graphics
+          for backend_override in "${backend_overrides[@]}"; do
+            backend="${backend_override%%:*}"
+            version="${backend_override##*:}"
+            export PYGLET_BACKEND="${backend}"
+            export MESA_GL_VERSION_OVERRIDE="${version}"
+            export MESA_GLES_VERSION_OVERRIDE="${version}"
+            echo "Running backend-sensitive tests for backend=${backend}, version=${version}"
+            xvfb-run --auto-servernum python3 -m pyglet.info
+            xvfb-run --auto-servernum pytest tests/integration/graphics
+          done
+
+  osx:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        python-version: [ '3.10', '3.11', '3.12', '3.13', '3.14']
+    name: Python ${{ matrix.python-version }} macOS
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          pip install pytest
+      - name: Run tests
+        run: |
+          python3 -m pyglet.info
+          pytest tests --ignore=tests/interactive --ignore=tests/integration
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
+
+    name: Python ${{ matrix.python-version }} Windows
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          release: false
+          install: mingw-w64-x86_64-mesa
+      - uses: ssciwr/setup-mesa-dist-win@v2
+      - name: Install dependencies
+        run: |
+          pip install pytest
+      - name: Run tests
+        shell: pwsh
+        run: |
+          $backend_test_args = @(
+            'tests/integration/graphics'
+          )
+
+          $backend_overrides = @(
+            @{ backend = 'opengl'; version = '4.6' },
+            @{ backend = 'gl2'; version = '2.0' },
+            @{ backend = 'gles2'; version = '2.0' }
+          )
+
+          $env:PYGLET_BACKEND = 'opengl'
+          $env:MESA_GL_VERSION_OVERRIDE = '4.6'
+          $env:MESA_GLES_VERSION_OVERRIDE = '4.6'
+          python3 -m pyglet.info
+          pytest tests --ignore=tests/interactive --ignore=tests/integration/graphics
+          foreach ($backend_override in $backend_overrides) {
+            $env:PYGLET_BACKEND = $backend_override.backend
+            $env:MESA_GL_VERSION_OVERRIDE = $backend_override.version
+            $env:MESA_GLES_VERSION_OVERRIDE = $backend_override.version
+            Write-Host "Running backend-sensitive tests for backend=$($backend_override.backend), version=$($backend_override.version)"
+            python3 -m pyglet.info
+            pytest @backend_test_args
+          }
+
+  headless:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ '3.12', '3.13', '3.14', 'pypy-3.10' ]
+
+    name: Python ${{ matrix.python-version }} Ubuntu HEADLESS
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest
+          sudo apt-get update
+          sudo apt-get install --fix-missing libgl1-mesa-dev xvfb
+      - name: Run tests
+        env:
+          PYGLET_HEADLESS: true
+        run: |
+          backend_overrides=(
+            "opengl:4.6"
+            "gles2:2.0"
+            "gles3:3.2"
+          )
+
+          export PYGLET_BACKEND=opengl
+          export MESA_GL_VERSION_OVERRIDE=4.6
+          export MESA_GLES_VERSION_OVERRIDE=4.6
+          python3 -m pyglet.info
+          pytest tests \
+            --ignore=tests/interactive \
+            --ignore=tests/integration/graphics
+          for backend_override in "${backend_overrides[@]}"; do
+            backend="${backend_override%%:*}"
+            version="${backend_override##*:}"
+            export PYGLET_BACKEND="${backend}"
+            export MESA_GL_VERSION_OVERRIDE="${version}"
+            export MESA_GLES_VERSION_OVERRIDE="${version}"
+            echo "Running backend-sensitive tests for backend=${backend}, version=${version}"
+            python3 -m pyglet.info
+            pytest tests/integration/graphics
+          done
+
+  webgl-smoke:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    name: Pyodide WebGL Test
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install playwright
+          python -m playwright install --with-deps chromium
+      - name: Run WebGL test
+        run: |
+          python tools/pyodide/run_webgl_smoke.py --clean --timeout-seconds 300

pyglet-3.0.dev5/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: pyglet
+Version: 3.0.dev5
+Summary: pyglet is a cross-platform games and multimedia package.
+Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
+Requires-Python: >=3.10
+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)
+
+![logo_large.png](https://github.com/pyglet/pyglet/blob/54a8c8b7e701b1692c6a10dd80f94ec837c27bd3/examples/opengl/pyglet.png?raw=true)
+
+# pyglet
+
+*pyglet* is a cross-platform windowing and multimedia library for Python, intended for developing games
+and other visually rich applications. It supports Windowing, input event handling, Controllers & Joysticks,
+OpenGL graphics, loading images and videos, and playing sounds and music. *pyglet* works on Windows, OS X and Linux.
+
+> :exclamation: :exclamation: A major pyglet update has just been released (v2.1). This brings many 
+> new exciting features, but also some necessary breaking changes. If your game/application has suddenly 
+> stopped working, please read the [migration section in the documentation](https://pyglet.readthedocs.io/en/latest/programming_guide/migration.html)
+> The previous version of pyglet is tracked in the `pyglet-2.0-maintenance` branch.
+> **If you want to do a pull request for the previous release, please target the appropriate branch**. 
+
+* pyglet [documentation]
+* pyglet on [PyPI]
+* pyglet [discord] server
+* pyglet [mailing list]
+* pyglet [issue tracker]
+* pyglet [website]
+
+pyglet has an active developer and user community.  If you find a bug or a problem with the documentation,
+please [open an issue](https://github.com/pyglet/pyglet/issues).
+Anyone is welcome to join our [discord] server where a lot of the development discussion is going on.
+It's also a great place to ask for help.
+
+Some features of pyglet are:
+
+* **No external dependencies or installation requirements.** For most application and game requirements, *pyglet*
+  needs nothing else besides Python, simplifying distribution and installation. It's easy to package and distribute
+  your project with [Nuitka](https://nuitka.net) or [PyInstaller](https://pyinstaller.org). 
+* **Take advantage of multiple windows and multi-monitor desktops.** *pyglet* allows you to use multiple
+  platform-native windows, and is fully aware of multi-monitor setups for use with fullscreen games.
+* **Load images, sound, music and video in almost any format.** *pyglet* can optionally use FFmpeg to play back
+  audio formats such as MP3, OGG/Vorbis and WMA, and video formats such as MPEG2, H.264, H.265, WMV and Xvid.
+  Without FFmpeg, *pyglet* contains built-in support for standard formats such as wav, png, bmp, and others.
+* **pyglet is written entirely in pure Python**, and makes use of the *ctypes* module to interface with system
+  libraries. You can modify the codebase or make a contribution without any second language compilation steps or
+  compiler setup. Despite being pure Python, *pyglet* has excellent performance thanks to advanced batching for
+  drawing thousands of objects.
+* **pyglet is provided under the BSD open-source license**, allowing you to use it for both commercial and other
+  open-source projects with very little restriction.
+
+## Requirements
+
+pyglet runs under Python 3.8+. Being written in pure Python, it also works on other Python interpreters such as PyPy. Supported platforms are:
+
+* Windows 7 or later
+* Mac OS X 10.3 or later
+* Linux, with the following libraries (most recent distributions will have
+  these in a default installation):
+  * OpenGL and GLX
+  * GDK 2.0+ or Pillow (required for loading images other than PNG and BMP)
+  * OpenAL or Pulseaudio (required for playing audio)
+
+**As of pyglet 2.0, OpenGL 3.3+ is required**. 
+
+To play a large variety of compressed audio and video files,
+pyglet can optionally take advantage of [FFmpeg](https://ffmpeg.org/).
+
+## Installation
+
+pyglet is installable from PyPI:
+
+    pip install --upgrade --user pyglet
+
+## Installation from source
+
+If you're reading this `README` from a source distribution, you can install pyglet with:
+
+    pip install --upgrade --user .
+    # or
+    python setup.py install --user
+
+You can also install the latest development version directly from Github:
+
+    pip install --upgrade --user https://github.com/pyglet/pyglet/archive/master.zip
+
+For local development install pyglet in editable mode:
+
+```bash
+# with pip
+pip install -e .
+# with setup.py
+python setup.py develop
+```
+
+There are no compilation steps during the installation; if you prefer,
+you can simply add this directory to your `PYTHONPATH` and use pyglet without
+installing it. You can also copy pyglet directly into your project folder.
+
+## Contributing
+
+**A good way to start contributing to a component of pyglet is by its documentation**. When studying the code you
+are going to work with, also read the associated docs. If you don't understand the code with the help of the docs,
+it is a sign that the docs should be improved. If you wish to make large changes to any part of pyglet, it's always
+a good idea to reach out for feedback first. This can avoid wasted effort in cases where someone is already working
+on something similar, or if your idea can't be accepted for any reason. 
+
+A basic outline of how to a contribution is as follows:
+
+* Fork the [official repository](https://github.com/pyglet/pyglet/fork).
+* In your fork, checkout the branch you wish to contribute to (such as *pyglet-1.5-maintenance*).
+* Apply your changes to your fork.
+* Submit a [pull request](https://github.com/pyglet/pyglet/pulls) describing the changes you have made.
+* Alternatively you can create a patch and submit it to the issue tracker.
+
+When making a pull request, check that you have addressed its respective documentation, both within the code docstrings
+and the programming guide (if applicable). It is very important to all of us that the documentation matches the latest
+code and vice versa.
+
+Consequently, an error in the documentation, either because it is hard to understand or because it doesn't match the
+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 make.py docs
+
+Please check [Documentation and Type Hints][] guide to learn more.
+
+## Testing
+
+pyglet makes use of pytest for its test suite.
+
+```bash
+pip install -r tests/requirements.txt --user
+# Only run unittests
+pytest tests/unit
+```
+
+Please check the [testing section in the development guide](https://pyglet.readthedocs.io/en/latest/internal/testing.html)
+for more information about running and writing tests.
+
+## Contact
+
+pyglet is developed by many individual volunteers, and there is no central point of contact. If you have a question
+about developing with pyglet, or you wish to contribute, please join the [discord] server, or [subreddit].
+
+For legal issues, please contact [Alex Holkner](mailto:Alex.Holkner@gmail.com).
+
+[discord]: https://discord.gg/QXyegWe
+[subreddit]: https://www.reddit.com/r/pyglet/
+[documentation]: https://pyglet.readthedocs.io
+[wiki]:  https://github.com/pyglet/pyglet/wiki
+[pypi]:  https://pypi.org/project/pyglet/
+[website]: http://pyglet.org/
+[issue tracker]: https://github.com/pyglet/pyglet/issues
+

pyglet-3.0.dev5/contrib/README.md

@@ -0,0 +1,19 @@
+# Contrib
+
+The `contrib` directory contains supplemental examples, integrations, and recipes for building applications. Many
+of these are contributions by other users who have found useful patterns, and code that may be beneficial for
+others.
+
+Content in this directory is intended to help users learn, and explore integrations to see how specific features
+can be implemented.
+
+---
+
+# Contribution Rules
+
+- Keep contributions focused and self-contained.
+- Prefer readability and include comments where possible.
+- Include a README or docstring header for non-trivial contributions.
+- Avoid mixing unrelated concepts together.
+- Keep code style consistent with the repository.
+- Avoid heavy use of overriding internals, as these may change with versioning.

pyglet-3.0.dev5/contrib/dist_field/renderfield.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import sys
+
+import pyglet
+from pyglet.enums import BlendFactor
+from pyglet.graphics.state import State
+from pyglet.window import key
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.graphics import ShaderProgram, Group
+    from pyglet.graphics.texture import Texture
+
+
+class DepthFieldUniforms(State):
+    sets_state = True
+
+    def __init__(self, program: ShaderProgram):
+        self.program = program
+
+    def set_state(self, ctx) -> None:
+        self.program['bidirectional'] = enable_bidirectional
+        self.program['antialias'] = enable_antialias
+        self.program['outline'] = enable_outline
+        self.program['outline_width'] = outline_width
+        self.program['glow'] = enable_glow
+        self.program['glow_width'] = glow_width
+
+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.set_state(DepthFieldUniforms(program))
+
+
+class DistFieldSprite(pyglet.sprite.Sprite):
+    """Override sprite to use DistFieldTextureGroup."""
+    group_class = DistFieldGroup
+
+    def __init__(self, img, x=0, y=0, z=0, blend_src=BlendFactor.SRC_ALPHA, blend_dest=BlendFactor.ONE_MINUS_SRC_ALPHA, batch=None,
+                 group=None, subpixel=False, program=None) -> None:
+        super().__init__(img, x, y, z, blend_src, blend_dest, batch, group, subpixel, program)
+
+
+window = pyglet.window.Window(resizable=True)
+
+
+@window.event
+def on_resize(width, height):
+    scale_width = width / float(image.width)
+    scale_height = height / float(image.height)
+    sprite.scale = min(scale_width, scale_height)
+    sprite.x = width / 2
+    sprite.y = height / 2
+
+
+@window.event
+def on_draw():
+    window.clear()
+    sprite.draw()
+
+
+@window.event
+def on_key_press(symbol, modifiers):
+    global enable_bidirectional
+    global enable_antialias
+    global enable_outline
+    global enable_glow
+    global outline_width
+    global glow_width
+    if symbol == key.B:
+        enable_bidirectional = not enable_bidirectional
+    elif symbol == key.A:
+        enable_antialias = not enable_antialias
+    elif symbol == key.O:
+        enable_outline = not enable_outline
+        enable_glow = False
+    elif symbol == key.G:
+        enable_glow = not enable_glow
+        enable_outline = False
+    elif symbol == key.PERIOD:
+        if enable_glow:
+            glow_width += 0.005
+        else:
+            outline_width += 0.005
+    elif symbol == key.COMMA:
+        if enable_glow:
+            glow_width -= 0.005
+        else:
+            outline_width -= 0.005
+
+    print('-' * 78)
+    print('enable_bidirectional:', enable_bidirectional)
+    print('enable_antialias:', enable_antialias)
+    print('enable_outline:', enable_outline)
+    print('enable_glow:', enable_glow)
+    print('outline_width:', outline_width)
+
+
+vertex_source = """#version 150 core
+    in vec3 translate;
+    in vec4 colors;
+    in vec3 tex_coords;
+    in vec2 scale;
+    in vec3 position;
+    in float rotation;
+
+    out vec4 vertex_colors;
+    out vec3 texture_coords;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    mat4 m_scale = mat4(1.0);
+    mat4 m_rotation = mat4(1.0);
+    mat4 m_translate = mat4(1.0);
+
+    void main()
+    {
+        m_scale[0][0] = scale.x;
+        m_scale[1][1] = scale.y;
+        m_translate[3][0] = translate.x;
+        m_translate[3][1] = translate.y;
+        m_translate[3][2] = translate.z;
+        m_rotation[0][0] =  cos(-radians(rotation));
+        m_rotation[0][1] =  sin(-radians(rotation));
+        m_rotation[1][0] = -sin(-radians(rotation));
+        m_rotation[1][1] =  cos(-radians(rotation));
+
+        gl_Position = window.projection * window.view * m_translate * m_rotation * m_scale * vec4(position, 1.0);
+
+        vertex_colors = colors;
+        texture_coords = tex_coords;
+    }
+"""
+
+fragment_source = """#version 150 core
+    in vec4 vertex_colors;
+    in vec3 texture_coords;
+    out vec4 final_colors;
+
+    uniform sampler2D sprite_texture;
+
+    uniform bool bidirectional;
+    uniform bool antialias;
+    uniform bool outline;
+    uniform bool glow;
+    uniform float outline_width;
+    uniform float glow_width;
+
+    const vec4 outline_color = vec4(0.0, 0.0, 1.0, 1.0);
+    const vec4 glow_color = vec4(1.0, 0.0, 0.0, 1.0);
+
+    void main()
+    {
+        float alpha_mask;
+        if (bidirectional)
+        {
+            vec4 field = texture2D(sprite_texture, texture_coords.xy);
+            alpha_mask = float(field.r >= 0.5 && field.g >= 0.5);
+        }
+        else
+        {
+            alpha_mask = texture2D(sprite_texture, texture_coords.xy).a;
+        }
+        float alpha_width = fwidth(alpha_mask);
+        float intensity = alpha_mask;
+
+        final_colors = vertex_colors;
+
+        if (glow)
+        {
+            float glow_min = 0.5 - glow_width;
+            intensity = (alpha_mask - glow_min) / (0.5 - glow_min);
+            float glow_intensity = 0.0;
+            if (antialias)
+                glow_intensity = 1.0 - smoothstep(0.5 - alpha_width,
+                                                  0.5 + alpha_width,
+                                                  alpha_mask) * 2.0;
+            else
+                glow_intensity = float(alpha_mask < 0.5);
+
+            final_colors = mix(final_colors, glow_color, glow_intensity);
+        }
+        else if (outline)
+        {
+            float outline_intensity = 0.0;
+            float outline_min = 0.5 - outline_width;
+            float outline_max = 0.5;
+            if (antialias)
+            {
+
+                outline_intensity = 1.0 - smoothstep(outline_max - alpha_width,
+                                                     outline_max + alpha_width,
+                                                     alpha_mask) * 2.0;
+
+                intensity *= smoothstep(outline_min - alpha_width,
+                                        outline_min + alpha_width,
+                                        alpha_mask) * 2.0;
+            }
+            else
+            {
+                outline_intensity =
+                    float(alpha_mask >= outline_min && alpha_mask <= outline_max);
+                intensity = float(alpha_mask >= outline_min);
+            }
+            final_colors = mix(final_colors, outline_color, outline_intensity);
+        }
+        else if (antialias)
+        {
+            intensity *= smoothstep(0.5 - alpha_width,
+                                    0.5 + alpha_width,
+                                    alpha_mask) * 2.0;
+        }
+        else
+        {
+            intensity = float(alpha_mask >= 0.5);
+        }
+
+        final_colors.a = intensity;
+    }
+"""
+
+enable_bidirectional = False
+enable_antialias = False
+enable_outline = False
+enable_glow = False
+outline_width = 0.02
+glow_width = 0.1
+
+dist_shader = pyglet.graphics.ShaderProgram(
+    pyglet.graphics.Shader(vertex_source, "vertex"),
+    pyglet.graphics.Shader(fragment_source, "fragment"),
+)
+
+if len(sys.argv) > 1:
+    filename = sys.argv[1]
+else:
+    filename = 'py.df.png'
+
+controls = """
+Following keys modify the shader operation:
+
+    A   Toggle antialiasing
+    B   Toggle bidirectional (see below)
+    O   Toggle outline
+    G   Toggle glow
+    ,   Decrease outline/glow
+    .   Increase outline/glow
+"""
+print(controls)
+
+image = pyglet.image.load(filename)
+
+image.anchor_x = image.width // 2
+image.anchor_y = image.height // 2
+sprite = DistFieldSprite(image, program=dist_shader)
+
+pyglet.app.run()

pyglet-3.0.dev5/contrib/spritebenchmark.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+"""Simple sprite stress benchmark that adjusts sprite count to track target FPS."""
+
+import random
+
+import pyglet
+
+
+WIDTH = 1280
+HEIGHT = 720
+TARGET_FPS = 60
+
+window = pyglet.window.Window(WIDTH, HEIGHT, caption="Benchmark", resizable=True, vsync=False)
+label = pyglet.text.Label(" ", x=5, y=5, color=(223, 223, 223, 255), dpi=80)
+batch = pyglet.graphics.Batch()
+
+
+grey_img = pyglet.image.SolidColorImagePattern((50, 50, 50, 150)).create_image(5, 5)
+blocks = []
+
+
+@window.event
+def on_draw():
+    window.clear()
+    batch.draw()
+    label.draw()
+
+
+@window.event
+def on_resize(width, height):
+    global WIDTH, HEIGHT
+    WIDTH, HEIGHT = width, height
+
+
+def update(dt):
+
+    fps = 1 / dt
+    count = int(fps - TARGET_FPS)
+
+    if count > 0:
+        for i in range(count//2):
+            x = random.uniform(0, WIDTH/2)
+            y = random.uniform(0, HEIGHT)
+            blocks.append(pyglet.sprite.Sprite(img=grey_img, x=x, y=y, batch=batch, subpixel=True))
+
+    else:
+        if blocks:
+            blocks.pop(0)
+
+    for block in blocks:
+        block.x += dt
+
+    if blocks:
+        label.text = f"FPS: {round(fps)}, sprites:{len(blocks)}"
+
+
+pyglet.clock.schedule_interval(update, 1/120)
+pyglet.app.run(1/120)