pyglet 3.0.dev3__tar.gz → 3.0.dev4__tar.gz

{pyglet-3.0.dev3 → pyglet-3.0.dev4}/.github/workflows/unittests.yml

@@ -8,9 +8,8 @@ jobs:
     strategy:
       matrix:
         python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13', '3.14', 'pypy-3.10' ]
-        backend-override: [[opengl, '4.6'], [gl2, '2.0'], [gles2, '2.0'], [gles3, '3.2']]
 
-    name: Python ${{ matrix.python-version }} Ubuntu ${{ matrix.backend-override[0] }}
+    name: Python ${{ matrix.python-version }} Ubuntu
     steps:
       - uses: actions/checkout@v4
       - name: Setup python
@@ -26,15 +25,34 @@ jobs:
           sudo apt-get install xvfb ffmpeg
       - name: Run tests
         env:
-          PYGLET_BACKEND: ${{ matrix.backend-override[0] }}
-          MESA_GL_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
-          MESA_GLES_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
           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
+          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
@@ -61,9 +79,8 @@ jobs:
     strategy:
       matrix:
         python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
-        backend-override: [[opengl, '4.6'], [gl2, '2.0'], [gles2, '2.0']]
 
-    name: Python ${{ matrix.python-version }} Windows ${{ matrix.backend-override[0] }}
+    name: Python ${{ matrix.python-version }} Windows
     steps:
       - uses: actions/checkout@v4
       - name: Setup python
@@ -81,22 +98,38 @@ jobs:
           pip install pytest
       - name: Run tests
         shell: pwsh
-        env:
-          PYGLET_BACKEND: ${{ matrix.backend-override[0] }}
-          MESA_GL_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
-          MESA_GLES_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
         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
+          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' ]
-        backend-override: [[opengl, '4.6'], [gles2, '2.0'], [gles3, '3.2']]
 
-    name: Python ${{ matrix.python-version }} Ubuntu HEADLESS ${{ matrix.backend-override[0] }}
+    name: Python ${{ matrix.python-version }} Ubuntu HEADLESS
     steps:
       - uses: actions/checkout@v4
       - name: Setup python
@@ -111,13 +144,31 @@ jobs:
           sudo apt-get install --fix-missing libgl1-mesa-dev xvfb
       - name: Run tests
         env:
-          PYGLET_BACKEND: ${{ matrix.backend-override[0] }}
-          MESA_GL_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
-          MESA_GLES_VERSION_OVERRIDE: ${{ matrix.backend-override[1] }}
           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
+          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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglet
-Version: 3.0.dev3
+Version: 3.0.dev4
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8

pyglet-3.0.dev4/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.dev3/experimental → pyglet-3.0.dev4/contrib}/spritebenchmark.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+"""Simple sprite stress benchmark that adjusts sprite count to track target FPS."""
+
 import random
 
 import pyglet

pyglet-3.0.dev4/contrib/svg/svg_test.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+import os.path
+import re
+import xml.dom.minidom
+
+import pyglet
+from pyglet.enums import BlendFactor, GeometryMode
+from pyglet.graphics import Group, Shader, ShaderGroup, ShaderProgram
+from pyglet.graphics.api.base import SurfaceContext
+from pyglet.graphics.api.gl import (
+    GL_DONT_CARE,
+    GL_LINE_SMOOTH,
+    GL_LINE_SMOOTH_HINT,
+    glDisable,
+    glEnable,
+    glHint,
+)
+from pyglet.graphics.state import State
+
+
+_VERTEX_SOURCE = """#version 330 core
+in vec2 position;
+
+uniform WindowBlock
+{
+    mat4 projection;
+    mat4 view;
+} window;
+
+void main()
+{
+    gl_Position = window.projection * window.view * vec4(position, 0.0, 1.0);
+}
+"""
+
+_FRAGMENT_SOURCE = """#version 330 core
+out vec4 final_color;
+
+void main()
+{
+    final_color = vec4(1.0, 0.0, 0.0, 1.0);
+}
+"""
+
+
+class LineSmoothState(State):
+    sets_state = True
+    unsets_state = True
+
+    def set_state(self, ctx: SurfaceContext) -> None:
+        glEnable(GL_LINE_SMOOTH)
+        glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE)
+
+    def unset_state(self, ctx: SurfaceContext) -> None:
+        glDisable(GL_LINE_SMOOTH)
+
+
+class Curve:
+    PATH_RE = re.compile(r'([MLHVCSQTAZ])([^MLHVCSQTAZ]*)', re.IGNORECASE)
+    INT = r'([+-]?\d+)'
+    FLOAT = r'(?:[\s,]*)([+-]?\d+(?:\.\d+)?)'
+
+    HANDLERS = {}
+
+    def handle(self, rx, types, HANDLERS=HANDLERS):
+        def register(function):
+            HANDLERS[self] = (rx and re.compile(rx), function, types)
+            return function
+
+        return register
+
+    def __init__(self, spec):
+        self.start = None
+        self.current = None
+        self.last_control = None
+        self.min_x = self.min_y = self.max_x = self.max_y = None
+        self.segments = []
+
+        for cmd, value in self.PATH_RE.findall(spec):
+            if not cmd:
+                continue
+            rx, handler, types = self.HANDLERS[cmd.upper()]
+            if rx is None:
+                handler(self, cmd)
+                continue
+            v = []
+            for fields in rx.findall(value):
+                if not isinstance(fields, tuple):
+                    fields = (fields,)
+                v.append([types[i](e) for i, e in enumerate(fields)])
+            handler(self, cmd, v)
+
+    def _determine_rect(self, x, y):
+        y = -y
+        if self.min_x is None:
+            self.min_x = self.max_x = x
+            self.min_y = self.max_y = y
+            return
+        if self.min_x > x:
+            self.min_x = x
+        elif self.max_x < x:
+            self.max_x = x
+        if self.min_y > y:
+            self.min_y = y
+        elif self.max_y < y:
+            self.max_y = y
+
+    def _append_line(self, x1, y1, x2, y2):
+        self.segments.append((x1, -y1, x2, -y2))
+        self._determine_rect(x1, y1)
+        self._determine_rect(x2, y2)
+
+    @handle('M', FLOAT * 2, (float, float))
+    def moveto(self, cmd, points):
+        points = [list(map(float, point)) for point in points]
+        if not points:
+            return
+        self.start = self.current = points[0]
+        self.last_control = None
+        if len(points) > 1:
+            self.lineto({'m': 'l', 'M': 'L'}[cmd], points[1:])
+
+    @handle('L', FLOAT * 2, (float, float))
+    def lineto(self, cmd, points):
+        if self.current is None:
+            return
+        for point in points:
+            cx, cy = self.current
+            x, y = list(map(float, point))
+            self._append_line(cx, cy, x, y)
+            self.current = (x, y)
+        self.last_control = None
+
+    @handle('H', FLOAT, (float,))
+    def horizontal_lineto(self, cmd, xvals):
+        if self.current is None or not xvals:
+            return
+        cx, cy = self.current
+        x = float(xvals[-1][0])
+        self._append_line(cx, cy, x, cy)
+        self.current = (x, cy)
+        self.last_control = None
+
+    @handle('V', FLOAT, (float,))
+    def vertical_lineto(self, cmd, yvals):
+        if self.current is None or not yvals:
+            return
+        cx, cy = self.current
+        y = float(yvals[-1][0])
+        self._append_line(cx, cy, cx, y)
+        self.current = (cx, y)
+        self.last_control = None
+
+    @handle('Z', None, None)
+    def closepath(self, cmd):
+        if self.current is None or self.start is None:
+            return
+        cx, cy = self.current
+        sx, sy = self.start
+        self._append_line(cx, cy, sx, sy)
+        self.current = self.start
+        self.last_control = None
+
+    @handle('C', FLOAT * 6, (float,) * 6)
+    def curveto(self, cmd, control_points):
+        if self.current is None:
+            return
+        last = None
+        for entry in control_points:
+            x1, y1, x2, y2, x, y = list(map(float, entry))
+            cx, cy = self.current
+            self.last_control = (x2, y2)
+            self.current = (x, y)
+            t = 0.0
+            while t <= 1.0001:
+                a = t
+                a2 = a**2
+                a3 = a**3
+                b = 1 - t
+                b2 = b**2
+                b3 = b**3
+                px = cx * b3 + 3 * x1 * b2 * a + 3 * x2 * b * a2 + x * a3
+                py = cy * b3 + 3 * y1 * b2 * a + 3 * y2 * b * a2 + y * a3
+                if last is not None:
+                    self._append_line(last[0], last[1], px, py)
+                last = (px, py)
+                t += 0.01
+
+    @handle('S', FLOAT * 4, (float,) * 4)
+    def smooth_curveto(self, cmd, control_points):
+        if self.current is None:
+            return
+        if self.last_control is None:
+            self.last_control = self.current
+
+        last = None
+        for entry in control_points:
+            x2, y2, x, y = list(map(float, entry))
+            cx, cy = self.current
+            lcx, lcy = self.last_control
+            x1, y1 = cx + (cx - lcx), cy + (cy - lcy)
+
+            self.last_control = (x2, y2)
+            self.current = (x, y)
+
+            t = 0.0
+            while t <= 1.0001:
+                a = t
+                a2 = a**2
+                a3 = a**3
+                b = 1 - t
+                b2 = b**2
+                b3 = b**3
+                px = cx * b3 + 3 * x1 * b2 * a + 3 * x2 * b * a2 + x * a3
+                py = cy * b3 + 3 * y1 * b2 * a + 3 * y2 * b * a2 + y * a3
+                if last is not None:
+                    self._append_line(last[0], last[1], px, py)
+                last = (px, py)
+                t += 0.01
+
+    @handle('Q', FLOAT * 4, (float,) * 4)
+    def quadratic_curveto(self, cmd, control_points):
+        raise NotImplementedError('not implemented')
+
+    @handle('T', FLOAT * 2, (float,) * 2)
+    def smooth_quadratic_curveto(self, cmd, control_points):
+        raise NotImplementedError('not implemented')
+
+    @handle('A', FLOAT * 3 + INT * 2 + FLOAT * 2, (float,) * 3 + (int,) * 2 + (float,) * 2)
+    def elliptical_arc(self, cmd, parameters):
+        raise NotImplementedError('not implemented')
+
+
+class SVG:
+    def __init__(self, filename, rect=None):
+        self._rect = rect
+        self.scale_x = 1.0
+        self.scale_y = 1.0
+        self.translate_x = 0.0
+        self.translate_y = 0.0
+
+        self.batch = pyglet.graphics.Batch()
+        self.shader = ShaderProgram(Shader(_VERTEX_SOURCE, "vertex"), Shader(_FRAGMENT_SOURCE, "fragment"))
+
+        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())
+
+        dom = xml.dom.minidom.parse(filename)
+        svg_tag = dom.documentElement
+        if svg_tag.tagName != 'svg':
+            raise ValueError(f'document is <{svg_tag.tagName}> instead of <svg>')
+
+        self.objects = []
+        for group_tag in svg_tag.getElementsByTagName('g'):
+            for path_tag in group_tag.getElementsByTagName('path'):
+                self.objects.append(Curve(path_tag.getAttribute('d')))
+
+        self.min_x = min(o.min_x for o in self.objects if o.min_x is not None)
+        self.max_x = max(o.max_x for o in self.objects if o.max_x is not None)
+        self.min_y = min(o.min_y for o in self.objects if o.min_y is not None)
+        self.max_y = max(o.max_y for o in self.objects if o.max_y is not None)
+
+        if rect is None:
+            self._rect = (
+                self.min_x,
+                self.min_y,
+                self.max_x - self.min_x,
+                self.max_y - self.min_y,
+            )
+
+        self.drawables = []
+        self._build_vertex_lists()
+        self.rect = self._rect
+
+    @property
+    def rect(self):
+        return self._rect
+
+    @rect.setter
+    def rect(self, new_rect):
+        self._rect = new_rect
+        self.translate_x, self.translate_y, rw, rh = new_rect
+        width = self.max_x - self.min_x
+        height = self.max_y - self.min_y
+        self.scale_x = abs(rw / width) if width else 1.0
+        self.scale_y = abs(rh / height) if height else 1.0
+        self._update_vertices()
+
+    def _build_vertex_lists(self):
+        for curve in self.objects:
+            if not curve.segments:
+                continue
+            positions = []
+            for x1, y1, x2, y2 in curve.segments:
+                positions.extend((x1, y1, x2, y2))
+            vertex_list = self.shader.vertex_list(
+                len(positions) // 2,
+                GeometryMode.LINES,
+                self.batch,
+                self.line_group,
+                position=('f', positions),
+            )
+            self.drawables.append((curve, vertex_list))
+
+    def _update_vertices(self):
+        for curve, vertex_list in self.drawables:
+            transformed = []
+            for x1, y1, x2, y2 in curve.segments:
+                transformed.extend((
+                    (x1 - self.min_x) * self.scale_x + self.translate_x,
+                    (y1 - self.min_y) * self.scale_y + self.translate_y,
+                    (x2 - self.min_x) * self.scale_x + self.translate_x,
+                    (y2 - self.min_y) * self.scale_y + self.translate_y,
+                ))
+            vertex_list.position[:] = transformed
+
+    def draw(self):
+        self.batch.draw()
+
+
+window = pyglet.window.Window(width=600, height=300, resizable=True)
+
+dirname = os.path.dirname(__file__)
+svg = SVG(os.path.join(dirname, 'hello_world.svg'), rect=(0, 0, 600, 300))
+
+
+@window.event
+def on_draw():
+    window.clear()
+    svg.draw()
+
+
+@window.event
+def on_resize(w, h):
+    svg.rect = (0, 0, w, h)
+
+
+pyglet.app.run()

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

@@ -51,6 +51,7 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/shapes
    programming_guide/models
    programming_guide/resources
+   programming_guide/texture
    programming_guide/rendering
    programming_guide/events
    programming_guide/gui
@@ -65,6 +66,7 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/options
    programming_guide/debug
    programming_guide/migration
+   programming_guide/migration2
    programming_guide/pyodide
 
 .. toctree::
@@ -74,6 +76,7 @@ If you are migrating from an older version of pyglet, please read through
    modules/pyglet
    modules/app
    modules/clock
+   modules/config/index
    modules/display
    modules/customtypes
    modules/enums
@@ -86,6 +89,7 @@ If you are migrating from an older version of pyglet, please read through
    modules/input
    modules/math
    modules/media
+   modules/models
    modules/resource
    modules/sprite
    modules/shapes

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

@@ -75,7 +75,7 @@ A silent audio driver that consumes, but does not play back any audio is also
 available.
 
 If your source contains video, and you are using a :class:`~pyglet.media.VideoPlayer`
-then the player will contain a :meth:`~pyglet.media.VideoPlayer.texture`
+then the player will contain a :attr:`~pyglet.media.player.VideoPlayer.texture`
 property returning the current video frame.
 
 The player has an internal `master clock` which is used to synchronize the
@@ -83,11 +83,11 @@ video and the audio. The audio synchronization is delegated to the
 ``AudioPlayer``. More info found below. The video synchronization is made by
 asking the :class:`~pyglet.media.Source` for the next video timestamp.
 The player then schedules on pyglet event loop a
-call to its :meth:`~pyglet.media.AudioPlayer.update_texture` with a delay
+call to its :meth:`~pyglet.media.player.VideoPlayer.update_texture` with a delay
 equal to the difference between the next video timestamp and the master clock
 current time.
 
-When :meth:`~pyglet.media.AudioPlayer.update_texture` is called, we will
+When :meth:`~pyglet.media.player.VideoPlayer.update_texture` is called, we will
 check if the actual master clock time is not too late compared to the video
 timestamp. This could happen if the loop was very busy and the function could
 not be called on time. In this case, the frame would be skipped until we find
@@ -309,21 +309,21 @@ When the client code runs ``player.play()``:
 The :class:`~pyglet.media.player.AudioPlayer` will check if there is an audio track
 on the media. If so it will instantiate an ``AudioPlayer`` appropriate for the
 available sound driver on the platform. It will create an empty
-:class:`~pyglet.image.Texture` if the media contains video frames and will
-schedule its :meth:`~pyglet.media.AudioPlayer.update_texture` to be called
+:class:`~pyglet.graphics.texture.Texture` if the media contains video frames and will
+schedule its :meth:`~pyglet.media.player.VideoPlayer.update_texture` to be called
 immediately. Finally it will start the master clock.
 
 The ``AudioPlayer`` will start playing
 :ref:`as described above <audioplayer-play>`.
 
-When the :meth:`~pyglet.media.VideoPlayer.update_texture` method is called,
+When the :meth:`~pyglet.media.player.VideoPlayer.update_texture` method is called,
 the next video timestamp will be checked with the master clock. We allow a
 delay up to the frame duration. If the master clock is beyond that time, the
 frame will be skipped. We will check the following frames for its timestamp
 until we find the appropriate frame for the master clock time. We will set the
 :attr:`~pyglet.media.player.VideoPlayer.texture` to the new video frame. We will
 check for the next video frame timestamp and we will schedule a new call to
-:meth:`~pyglet.media.VideoPlayer.update_texture` with a delay equals to the
+:meth:`~pyglet.media.player.VideoPlayer.update_texture` with a delay equals to the
 difference between the next video timestamps and the master clock time.
 
 Helpful tools

pyglet-3.0.dev4/doc/modules/config/base.rst

@@ -0,0 +1,6 @@
+pyglet.config.base
+==================
+
+.. automodule:: pyglet.config.base
+  :members:
+  :undoc-members:

pyglet-3.0.dev4/doc/modules/config/gl.rst

@@ -0,0 +1,6 @@
+pyglet.config.gl
+================
+
+.. automodule:: pyglet.config.gl
+  :members:
+  :undoc-members:

pyglet-3.0.dev4/doc/modules/config/index.rst

@@ -0,0 +1,14 @@
+pyglet.config
+=============
+
+.. rubric:: Submodules
+
+.. toctree::
+   :maxdepth: 1
+
+   base
+   gl
+
+.. automodule:: pyglet.config
+  :members:
+  :undoc-members:

{pyglet-3.0.dev3 → pyglet-3.0.dev4}/doc/modules/dialog.rst

@@ -12,6 +12,8 @@ Classes
 
   .. rubric:: Methods
 
+  .. automethod:: __init__
+
   .. automethod:: open
 
   .. rubric:: Events
@@ -23,6 +25,8 @@ Classes
 
   .. rubric:: Methods
 
+  .. automethod:: __init__
+
   .. automethod:: open
 
   .. rubric:: Events

pyglet-3.0.dev4/doc/modules/font/group.rst

@@ -0,0 +1,6 @@
+pyglet.font.group
+=================
+
+.. automodule:: pyglet.font.group
+  :members:
+  :undoc-members:

{pyglet-3.0.dev3 → pyglet-3.0.dev4}/doc/modules/graphics/atlas.rst

@@ -1,5 +1,5 @@
 pyglet.graphics.atlas
-==================
+=====================
 
 .. automodule:: pyglet.graphics.atlas
   :members:

{pyglet-3.0.dev3 → pyglet-3.0.dev4}/doc/modules/graphics/index.rst

@@ -7,8 +7,11 @@ pyglet.graphics
    :maxdepth: 1
 
    allocation
+   atlas
+   draw
    framebuffer
    shader
+   texture
    vertexbuffer
    vertexdomain
 

pyglet-3.0.dev4/doc/modules/graphics/texture.rst

@@ -0,0 +1,6 @@
+pyglet.graphics.texture
+=======================
+
+.. automodule:: pyglet.graphics.texture
+  :members:
+  :undoc-members: