pyglet 2.1.12__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/display/headless.py

@@ -2,15 +2,16 @@ from __future__ import annotations
 
 from typing import Literal
 
-import pyglet
 import warnings
+from ctypes import byref
 
-from .base import Display, Screen, ScreenMode, Canvas
+import pyglet
 
+from .base import Display, Screen
+from pyglet.libs import egl
+from pyglet.util import debug_print
 
-from ctypes import byref
-from pyglet.libs.egl import egl
-from pyglet.libs.egl import eglext
+_debug = debug_print('debug_api')
 
 
 class HeadlessDisplay(Display):
@@ -21,21 +22,27 @@ class HeadlessDisplay(Display):
         self._screens = [HeadlessScreen(self, 0, 0, 1920, 1080)]
 
         num_devices = egl.EGLint()
-        eglext.eglQueryDevicesEXT(0, None, byref(num_devices))
-        if num_devices.value > 0:
-            headless_device = pyglet.options['headless_device']
-            if headless_device < 0 or headless_device >= num_devices.value:
-                raise ValueError(f'Invalid EGL device id: {headless_device}')
-            devices = (eglext.EGLDeviceEXT * num_devices.value)()
-            eglext.eglQueryDevicesEXT(num_devices.value, devices, byref(num_devices))
-            self._display_connection = eglext.eglGetPlatformDisplayEXT(
-                eglext.EGL_PLATFORM_DEVICE_EXT, devices[headless_device], None)
-        else:
+        try:
+            egl.eglQueryDevicesEXT(0, None, byref(num_devices))
+        except pyglet.libs.egl.eglext.MissingFunctionException:
             warnings.warn('No device available for EGL device platform. Using native display type.')
             display = egl.EGLNativeDisplayType()
             self._display_connection = egl.eglGetDisplay(display)
 
-        egl.eglInitialize(self._display_connection, None, None)
+        if num_devices.value > 0:
+            headless_device = pyglet.options.headless_device
+            if headless_device < 0 or headless_device >= num_devices.value:
+                raise ValueError(f'Invalid EGL device id: {headless_device}')
+            devices = (egl.EGLDeviceEXT * num_devices.value)()
+            egl.eglQueryDevicesEXT(num_devices.value, devices, byref(num_devices))
+            self._display_connection = egl.eglGetPlatformDisplayEXT(
+                egl.EGL_PLATFORM_DEVICE_EXT, devices[headless_device], None,
+            )
+
+        majorver = egl.EGLint()
+        minorver = egl.EGLint()
+        egl.eglInitialize(self._display_connection, majorver, minorver)
+        assert _debug(f"EGL version: {majorver.value}.{minorver.value}")
 
     def get_screens(self):
         return self._screens
@@ -44,24 +51,10 @@ class HeadlessDisplay(Display):
         egl.eglTerminate(self._display_connection)
 
 
-class HeadlessCanvas(Canvas):
-    def __init__(self, display, egl_surface):
-        super().__init__(display)
-        self.egl_surface = egl_surface
-
-
 class HeadlessScreen(Screen):
     def __init__(self, display, x, y, width, height):
         super().__init__(display, x, y, width, height)
 
-    def get_matching_configs(self, template):
-        canvas = HeadlessCanvas(self.display, None)
-        configs = template.match(canvas)
-        # XXX deprecate
-        for config in configs:
-            config.screen = self
-        return configs
-
     def get_modes(self):
         pass
 

pyglet/display/wayland.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from collections import namedtuple
+from threading import Event
+from typing import Literal
+
+from pyglet.libs.linux.egl import egl, eglext
+from pyglet.libs.linux.wayland.client import Client
+
+from .base import Display, Screen, ScreenMode
+
+ModeInfo = namedtuple('ModeInfo', 'width, height, depth, rate, current, primary')
+Geometry = namedtuple('Geometry', 'x, y, physical_width, physical_height, make, model, transform')
+
+
+class WaylandScreenMode(ScreenMode):
+    def __init__(self, screen: Screen, info: ModeInfo):
+        self.width = info.width
+        self.height = info.height
+        self.depth = info.depth
+        self.rate = info.rate
+        self.primary = info.primary
+        self.current = info.current
+        super().__init__(screen)
+
+
+class WaylandDisplay(Display):
+    _protocols = ('/usr/share/wayland/wayland.xml', '/usr/share/wayland-protocols/stable/xdg-shell/xdg-shell.xml')
+    _display_instance: WaylandDisplay | None = None
+
+    def __new__(cls):
+        if cls._display_instance:
+            return cls._display_instance
+        cls._display_instance = super().__new__(cls)
+        return cls._display_instance
+
+    def __init__(self):
+        super().__init__()
+        # Create temporary Client connection to query Screen information:
+        # TODO: use the new fractional scaling Protocol if available.
+        self.client = Client(*self._protocols)
+        self.client.sync()
+
+        self.display_connection = egl.eglGetPlatformDisplay(eglext.EGL_PLATFORM_WAYLAND, self.client.wl_display_p, None)
+
+        assert egl.eglInitialize(self.display_connection, None, None) == egl.EGL_TRUE, "Failed to initialize Display"
+
+        self._screens = []
+        for i, _ in enumerate(self.client.globals.get('wl_output', [])):
+            # Initialize values to default
+            self._geo = None
+            self._modes = []
+            self._scale = None
+            self._name = None
+            self._descript = None
+            self._query_done = Event()
+            wl_output = self.client.protocol_dict['wayland'].bind_interface('wl_output', index=i)
+            self._mode_enum = wl_output.enums['mode']
+            self._transform_enum = wl_output.enums['transform']
+            # Callbacks will update values:
+            wl_output.set_handlers(
+                geometry=self._wl_output_geometry_handler,
+                mode=self._wl_output_mode_handler,
+                scale=self._wl_output_scale_handler,
+                name=self._wl_output_name_handler,
+                description=self._wl_output_description_handler,
+                done=self._wl_output_done_handler,
+            )
+            self.client.sync()
+            self._query_done.wait()
+            # Make Screen instance with the now-filled-in values:
+            self._screens.append(WaylandScreen(self, self._geo, self._modes, self._scale, self._name, self._descript))
+            wl_output.release()
+
+    # Start Wayland Event handlers
+
+    def _wl_output_done_handler(self):
+        self._query_done.set()
+
+    def _wl_output_scale_handler(self, scale):
+        self._scale = scale
+
+    def _wl_output_name_handler(self, name):
+        self._name = name
+
+    def _wl_output_description_handler(self, description):
+        self._descript = description
+
+    def _wl_output_geometry_handler(self, x, y, physical_width, physical_height, subpixel, make, model, transform):
+        transform = self._transform_enum[transform]
+        self._geo = Geometry(x, y, physical_width, physical_height, make, model, transform)
+
+    def _wl_output_mode_handler(self, flags, width, height, refresh):
+        is_current = self._mode_enum.entries[0] & flags
+        is_primary = self._mode_enum.entries[1] & flags
+        self._modes.append(ModeInfo(width, height, None, refresh * 0.001, is_current, is_primary))
+
+    # End Wayland Event handlers
+
+    def get_screens(self):
+        return self._screens
+
+    def __del__(self):
+        egl.eglTerminate(self.display_connection)
+
+
+class WaylandScreen(Screen):
+
+    def get_display_id(self) -> str | int:
+        return self.name
+
+    def get_monitor_name(self) -> str | Literal["Unknown"]:
+        return self.description
+
+    def __init__(self, display, geometry, modes, scale, name, description):
+        self.name = name
+        self.description = description
+        self._scale = scale
+        self._geo = geometry
+        self._modes = modes
+        _width_pixels = max(mode.width for mode in self._modes)
+        _height_pixels = max(mode.height for mode in self._modes)
+        # No physical size can exist, such as WSL (they are virtual).
+        if self._geo.physical_width != 0:
+            _width_inches = self._geo.physical_width / 25.4
+            _height_inches = self._geo.physical_height / 25.4
+            _dpi_width = _width_pixels / _width_inches
+            _dpi_height = _height_pixels / _height_inches
+            self._dpi = (_dpi_width + _dpi_height) / 2
+        else:
+            self._dpi = scale
+
+        super().__init__(display, self._geo.x, self._geo.y, _width_pixels, _height_pixels)
+
+    def get_modes(self):
+        return self._modes
+
+    def get_mode(self):
+        for mode in self._modes:
+            if mode.current:
+                return mode
+        return self._modes[0]
+
+    def set_mode(self, mode):
+        pass
+
+    def restore_mode(self):
+        pass
+
+    def get_dpi(self):
+        return self._dpi
+
+    def get_scale(self):
+        return self._scale
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(x={self.x}, y={self.y}, width={self.width}, height={self.height})"

pyglet/display/win32.py

@@ -20,7 +20,6 @@ from pyglet.libs.win32.constants import (
     WINDOWS_10_CREATORS_UPDATE_OR_GREATER,
     WINDOWS_VISTA_OR_GREATER,
 )
-from pyglet.libs.win32.context_managers import device_context
 from pyglet.libs.win32.types import (
     DEVMODE,
     DISPLAY_DEVICEW,
@@ -35,7 +34,7 @@ from pyglet.libs.win32.types import (
     UINT32,
 )
 
-from .base import Canvas, Display, Screen, ScreenMode
+from .base import Display, Screen, ScreenMode
 
 if TYPE_CHECKING:
     from ctypes.wintypes import HDC, HMONITOR, LPARAM, LPRECT
@@ -165,16 +164,6 @@ class Win32Screen(Screen):  # noqa: D101
 
         return "Unknown"
 
-    def get_matching_configs(self, template):
-        with device_context(None) as hdc:
-            canvas = Win32Canvas(self.display, 0, hdc)
-            configs = template.match(canvas)
-            # XXX deprecate config's being screen-specific
-            for config in configs:
-                config.screen = self
-
-        return configs
-
     def _get_monitor_info(self) -> MONITORINFOEX:
         info = MONITORINFOEX()
         info.cbSize = sizeof(MONITORINFOEX)
@@ -257,6 +246,8 @@ _win32_scale_name = {
     1: "center",
     2: "stretch",
 }
+
+
 class Win32ScreenMode(ScreenMode):  # noqa: D101
     def __init__(self, screen: Win32Screen, mode: DEVMODE) -> None:  # noqa: D107
         super().__init__(screen)
@@ -271,8 +262,4 @@ class Win32ScreenMode(ScreenMode):  # noqa: D101
         return (f'{self.__class__.__name__}(width={self.width!r}, height={self.height!r}, depth={self.depth!r},'
                 f'rate={self.rate}, scaling={_win32_scale_name.get(self.scaling)})')
 
-class Win32Canvas(Canvas):  # noqa: D101
-    def __init__(self, display: Win32Display, hwnd: HWND, hdc: HDC) -> None:  # noqa: D107
-        super().__init__(display)
-        self.hwnd = hwnd
-        self.hdc = hdc
+

pyglet/display/xlib.py

@@ -2,37 +2,45 @@ from __future__ import annotations
 
 import ctypes
 import warnings
-from ctypes import POINTER, byref, c_buffer, c_char_p, c_int, cast
 from typing import TYPE_CHECKING
+from ctypes import POINTER, byref, c_buffer, c_char_p, c_int, cast
 
 import pyglet
+
 from pyglet import app
-from pyglet.app.xlib import XlibSelectDevice
-from pyglet.libs.x11 import xlib
+from pyglet.app.linux import LinuxSelectDevice
 from pyglet.util import asbytes
 
 from . import xlib_vidmoderestore
-from .base import Canvas, Display, Screen, ScreenMode
+from .base import Display, Screen, ScreenMode
+
+
+# XXX
+# from pyglet.window import NoSuchDisplayException
+class NoSuchDisplayException(Exception):
+    pass
 
+
+from pyglet.libs.linux.x11 import xlib
 if TYPE_CHECKING:
     from pyglet.gl import Config
 
 try:
-    from pyglet.libs.x11 import xinerama
+    from pyglet.libs.linux.x11 import xinerama
 
     _have_xinerama = True
 except:
     _have_xinerama = False
 
 try:
-    from pyglet.libs.x11 import xsync
+    from pyglet.libs.linux.x11 import xsync
 
     _have_xsync = True
 except:
     _have_xsync = False
 
 try:
-    from pyglet.libs.x11 import xf86vmode
+    from pyglet.libs.linux.x11 import xf86vmode
 
     _have_xf86vmode = True
 except:
@@ -59,7 +67,7 @@ def _error_handler(display, event):
     # driver bugs (and so the reports are useless).  Nevertheless, set
     # environment variable PYGLET_DEBUG_X11 to 1 to get dumps of the error
     # and a traceback (execution will continue).
-    if pyglet.options['debug_x11']:
+    if pyglet.options.debug_x11:
         event = event.contents
         buf = c_buffer(1024)
         xlib.XGetErrorText(display, event.error_code, buf, len(buf))
@@ -80,7 +88,7 @@ _error_handler_ptr = xlib.XErrorHandler(_error_handler)
 xlib.XSetErrorHandler(_error_handler_ptr)
 
 
-class XlibDisplay(XlibSelectDevice, Display):
+class XlibDisplay(LinuxSelectDevice, Display):
     _display = None  # POINTER(xlib.Display)
 
     _x_im = None  # X input method
@@ -199,7 +207,7 @@ class XlibDisplay(XlibSelectDevice, Display):
             self._screens = [screen]
         return self._screens
 
-    # XlibSelectDevice interface
+    # LinuxSelectDevice interface
 
     def fileno(self) -> int:
         return self._fileno
@@ -252,15 +260,7 @@ class XlibScreen(Screen):
     def get_scale(self) -> float:
         return self.get_dpi() / 96
 
-    def get_matching_configs(self, template: Config):
-        canvas = XlibCanvas(self.display, None)
-        configs = template.match(canvas)
-        # XXX deprecate
-        for config in configs:
-            config.screen = self
-        return configs
-
-    def get_modes(self) -> list[XlibScreenModeXF86]:
+    def get_modes(self):
         if not _have_xf86vmode:
             return []
 
@@ -493,11 +493,3 @@ class XlibScreenModeXrandr(XlibScreenMode):
 
     def __repr__(self) -> str:
         return f'XlibScreenMode(width={self.width!r}, height={self.height!r}, depth={self.depth!r}, rate={self.rate})'
-
-
-class XlibCanvas(Canvas):  # noqa: D101
-    display: XlibDisplay
-
-    def __init__(self, display: XlibDisplay, x_window: xlib.Window) -> None:  # noqa: D107
-        super().__init__(display)
-        self.x_window = x_window

pyglet/display/xlib_vidmoderestore.py

@@ -16,11 +16,11 @@ import signal
 import struct
 import threading
 
-from pyglet.libs.x11 import xlib
+from pyglet.libs.linux.x11 import xlib
 from pyglet.util import asbytes
 
 try:
-    from pyglet.libs.x11 import xf86vmode
+    from pyglet.libs.linux.x11 import xf86vmode
 except:
     # No xf86vmode... should not be switching modes.
     pass

pyglet/enums.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+from enum import Enum, auto
+
+
+class GraphicsAPI(Enum):
+    OPENGL = auto()
+    OPENGL_2 = auto()
+    OPENGL_ES_2 = auto()
+    OPENGL_ES_3 = auto()
+    WEBGL = auto()
+
+
+class BlendFactor(Enum):
+    ZERO = "ZERO"
+    ONE = "ONE"
+    SRC_COLOR = "SRC_COLOR"
+    ONE_MINUS_SRC_COLOR = "ONE_MINUS_SRC_COLOR"
+    DST_COLOR = "DST_COLOR"
+    ONE_MINUS_DST_COLOR = "ONE_MINUS_DST_COLOR"
+    SRC_ALPHA = "SRC_ALPHA"
+    ONE_MINUS_SRC_ALPHA = "ONE_MINUS_SRC_ALPHA"
+    DST_ALPHA = "DST_ALPHA"
+    ONE_MINUS_DST_ALPHA = "ONE_MINUS_DST_ALPHA"
+    CONSTANT_COLOR = "CONSTANT_COLOR"
+    ONE_MINUS_CONSTANT_COLOR = "ONE_MINUS_CONSTANT_COLOR"
+    CONSTANT_ALPHA = "CONSTANT_ALPHA"
+    ONE_MINUS_CONSTANT_ALPHA = "ONE_MINUS_CONSTANT_ALPHA"
+
+
+class BlendOp(Enum):
+    ADD = "ADD"
+    SUBTRACT = "SUBTRACT"
+    REVERSE_SUBTRACT = "REVERSE_SUBTRACT"
+    MIN = "MIN"
+    MAX = "MAX"
+
+
+class TextureFilter(Enum):
+    LINEAR = auto()
+    NEAREST = auto()
+
+
+class AddressMode(Enum):
+    REPEAT = auto()
+    MIRRORED_REPEAT = auto()
+    CLAMP_TO_EDGE = auto()
+    CLAMP_TO_BORDER = auto()
+
+
+class TextureWrapping(Enum):
+    WRAP_S = auto()
+    WRAP_T = auto()
+    WRAP_R = auto()
+
+
+class ComponentFormat(str, Enum):
+    R = 'R'
+    RG = 'RG'
+    RGB = 'RGB'
+    RGBA = 'RGBA'
+    D = 'D'  # Depth Component
+    DS = 'DS'  # Depth Stencil
+    BGR = 'BGR'
+    BGRA = 'BGRA'
+    L = 'L'  # Luminance (R) - Deprecated
+    LA = 'LA'  # Luminance Alpha (LA) - Deprecated
+
+
+class TextureType(Enum):
+    TYPE_1D = auto()
+    TYPE_2D = auto()
+    TYPE_3D = auto()
+    TYPE_CUBE_MAP = auto()
+    TYPE_1D_ARRAY = auto()
+    TYPE_2D_ARRAY = auto()
+    TYPE_CUBE_MAP_ARRAY = auto()
+
+
+class CompareOp(Enum):
+    NEVER = auto()
+    LESS = auto()
+    EQUAL = auto()
+    LESS_OR_EQUAL = auto()
+    GREATER = auto()
+    NOT_EQUAL = auto()
+    GREATER_OR_EQUAL = auto()
+    ALWAYS = auto()
+
+class FramebufferTarget(Enum):
+    FRAMEBUFFER = auto()
+    DRAW = auto()
+    READ = auto()
+
+class FramebufferAttachment(Enum):
+    COLOR0 = auto()
+    COLOR1 = auto()
+    COLOR2 = auto()
+    COLOR3 = auto()
+    COLOR4 = auto()
+    COLOR5 = auto()
+    COLOR6 = auto()
+    COLOR7 = auto()
+    COLOR8 = auto()
+    COLOR9 = auto()
+    COLOR10 = auto()
+    COLOR11 = auto()
+    COLOR12 = auto()
+    COLOR13 = auto()
+    COLOR14 = auto()
+    COLOR15 = auto()
+
+    DEPTH = auto()
+    STENCIL = auto()
+    DEPTH_STENCIL = auto()
+
+
+
+class Weight(str, Enum):
+    """An :py:class:`~enum.Enum` of known cross-platform font weight strings.
+
+    Each value is both an :py:class:`~enum.Enum` and a :py:class:`str`.
+    This is not a built-in Python :py:class:`~enum.StrEnum` to ensure
+    compatibility with Python < 3.11.
+
+    .. important:: Fonts will use the closest match if they lack a weight.
+
+    The values of this enum imitate the string names for font weights
+    as used in CSS and the OpenType specification. Numerical font weights
+    are not supported because:
+
+    * Integer font weight support and behavior varies by back-end
+    * Some font renderers do not support or round :py:class:`float` values
+    * Some font renderers lack support for variable-width fonts
+
+    Additional weight strings may be supported by certain font-rendering
+    back-ends. To learn more, please see your platform's API documentation
+    and the following:
+
+    #. `The MDN article on CSS font weights <https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight>`_
+    #. `The OpenType specification <https://learn.microsoft.com/en-us/typography/opentype/spec/os2#usweightclass>`_
+
+    """
+
+    THIN = 'thin'
+    EXTRALIGHT = 'extralight'
+    LIGHT = 'light'
+    NORMAL = 'normal'
+    """The default weight for a font."""
+    MEDIUM = 'medium'
+    SEMIBOLD = 'semibold'
+    BOLD = 'bold'
+    """The default **bold** style for a font."""
+    EXTRABOLD = 'extrabold'
+    BLACK = 'black'
+    EXTRABLACK = 'extrablack'
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class Stretch(str, Enum):
+    """The stretch or width class of the font."""
+    ULTRACONDENSED = 'ultracondensed'
+    EXTRACONDENSED = 'extracondensed'
+    CONDENSED = 'condensed'
+    SEMICONDENSED = 'semicondensed'
+    NORMAL = 'normal'
+    """The default stretch for a font."""
+    SEMIEXPANDED = 'semiexpanded'
+    EXPANDED = 'expanded'
+    EXTRAEXPANDED = 'extraexpanded'
+    ULTRAEXPANDED = 'ultraexpanded'
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class Style(str, Enum):
+    """The slant style of the font."""
+    NORMAL = 'normal'
+    """The default style for a font."""
+    ITALIC = 'italic'
+    OBLIQUE = 'oblique'

pyglet/event.py

@@ -348,7 +348,6 @@ class EventDispatcher:
             "EventDispatcher.register_event_type('event_name')."
         )
         assert event_type in self.event_types, f"{event_type} not found in {self}.event_types == {self.event_types}"
-
         invoked = False
 
         # Search handler stack for matching event handlers

pyglet/experimental/geoshader_sprite.py

@@ -4,7 +4,8 @@ import sys
 
 import pyglet
 from pyglet import clock, event, graphics, image
-from pyglet.gl import *
+from pyglet.graphics import GeometryMode
+from pyglet.graphics.api.gl import *
 
 _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
@@ -147,15 +148,15 @@ fragment_array_source = """#version 150 core
 
 
 def get_default_shader():
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (geometry_source, 'geometry'),
-                                                    (fragment_source, 'fragment'))
+    return pyglet.graphics.api.core.current_context.create_program((vertex_source, 'vertex'),
+                                                                   (geometry_source, 'geometry'),
+                                                                   (fragment_source, 'fragment'))
 
 
 def get_default_array_shader():
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (geometry_source, 'geometry'),
-                                                    (fragment_array_source, 'fragment'))
+    return pyglet.graphics.api.core.current_context.create_program((vertex_source, 'vertex'),
+                                                                   (geometry_source, 'geometry'),
+                                                                   (fragment_array_source, 'fragment'))
 
 
 class SpriteGroup(graphics.Group):
@@ -172,7 +173,7 @@ class SpriteGroup(graphics.Group):
         is created; applications usually do not need to explicitly create it.
 
         :Parameters:
-            `texture` : `~pyglet.image.Texture`
+            `texture` : `~pyglet.graphics.Texture`
                 The (top-level) texture containing the sprite image.
             `blend_src` : int
                 OpenGL blend source mode; for example,
@@ -180,7 +181,7 @@ class SpriteGroup(graphics.Group):
             `blend_dest` : int
                 OpenGL blend destination mode; for example,
                 ``GL_ONE_MINUS_SRC_ALPHA``.
-            `program` : `~pyglet.graphics.shader.ShaderProgram`
+            `program` : `~pyglet.graphics.ShaderProgram`
                 A custom ShaderProgram.
             `order` : int
                 Change the order to render above or below other Groups.
@@ -265,7 +266,7 @@ class Sprite(event.EventDispatcher):
             `subpixel` : bool
                 Allow floating-point coordinates for the sprite. By default,
                 coordinates are restricted to integer values.
-            `program` : `~pyglet.graphics.shader.ShaderProgram`
+            `program` : `~pyglet.graphics.ShaderProgram`
                 A custom shader to use. This shader program must contain the
                 exact same attribute names and types as the default shader.
                 The class methods and properties depend on this, and will
@@ -770,9 +771,10 @@ class Sprite(event.EventDispatcher):
         See the module documentation for hints on drawing multiple sprites
         efficiently.
         """
-        self._group.set_state_recursive()
-        self._vertex_list.draw(GL_POINTS)
-        self._group.unset_state_recursive()
+        ctx = pyglet.graphics.api.core.current_context
+        self._group.set_state_recursive(ctx)
+        self._vertex_list.draw(GeometryMode.POINTS)
+        self._group.unset_state_recursive(ctx)
 
     def __del__(self):
         try: