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

pyglet/experimental/hidraw.py

@@ -1,30 +1,21 @@
 """Work in progress HIDRAW device abstraction for Linux"""
 
 import os
-import fcntl
 import ctypes
-import warnings
 
-from ctypes import c_int as _int
 from ctypes import c_uint as _uint
 from ctypes import c_uint8 as _u8
-from ctypes import c_uint16 as _u16
 from ctypes import c_int16 as _s16
 from ctypes import c_uint32 as _u32
-from ctypes import c_int32 as _s32
-from ctypes import c_int64 as _s64
 from ctypes import create_string_buffer
 
-from concurrent.futures import ThreadPoolExecutor
-
 import pyglet
 
-from pyglet.app.xlib import XlibSelectDevice
-from pyglet.libs.ioctl import _IOR, _IOR_str, _IOWR_len
-from pyglet.input.base import Device, RelativeAxis, AbsoluteAxis, Button, Joystick, Controller
-from pyglet.input.base import DeviceOpenException, ControllerManager
+from pyglet.app.linux import LinuxSelectDevice
+from pyglet.libs.linux.ioctl import _IOR, _IOR_str, _IOWR_len
+from pyglet.input.base import Device
+from pyglet.input.base import DeviceOpenException
 from pyglet.input.linux.evdev_constants import *
-from pyglet.input.controller import get_mapping, Relation, create_guid
 
 
 # From /linux/blob/master/include/uapi/linux/hidraw.h
@@ -83,7 +74,7 @@ def get_set_bits(bytestring):
     return bits
 
 
-class HIDRawDevice(XlibSelectDevice, Device):
+class HIDRawDevice(LinuxSelectDevice, Device):
     _fileno = None
 
     def __init__(self, display, filename):
@@ -150,7 +141,7 @@ class HIDRawDevice(XlibSelectDevice, Device):
     # def ff_upload_effect(self, structure):
     #     os.write(self._fileno, structure)
 
-    # XlibSelectDevice interface
+    # LinuxSelectDevice interface
 
     def fileno(self):
         return self._fileno

pyglet/experimental/multitexture_sprite.py

@@ -7,12 +7,25 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import pyglet
-from pyglet.gl import glActiveTexture, glBindTexture, glEnable, GL_BLEND, glBlendFunc, glDisable, glGetIntegerv, GLint
-from pyglet.gl import GL_SRC_ALPHA, GL_TEXTURE0, GL_ONE_MINUS_SRC_ALPHA, GL_TRIANGLES, GL_MAX_TEXTURE_IMAGE_UNITS
+from pyglet.graphics.api.gl import (
+    GL_BLEND,
+    GL_MAX_TEXTURE_IMAGE_UNITS,
+    GL_ONE_MINUS_SRC_ALPHA,
+    GL_SRC_ALPHA,
+    GL_TEXTURE0,
+    GL_TRIANGLES,
+    GLint,
+    glActiveTexture,
+    glBindTexture,
+    glBlendFunc,
+    glDisable,
+    glEnable,
+    glGetIntegerv,
+)
 
 if TYPE_CHECKING:
-    from pyglet.image import Texture, AbstractImage, Animation
     from pyglet.graphics import Batch, Group, ShaderProgram
+    from pyglet.image import _AbstractImage, Animation, Texture
 
 
 class MultiTextureSpriteGroup(pyglet.graphics.Group):
@@ -113,14 +126,14 @@ class MultiTextureSpriteGroup(pyglet.graphics.Group):
 
 # Allows the default shader to pick the appropriate sampler for the fragment shader
 _SAMPLER_TYPES = {
-    pyglet.gl.GL_TEXTURE_2D: "sampler2D",
-    pyglet.gl.GL_TEXTURE_2D_ARRAY: "sampler2DArray"
+    pyglet.graphics.api.gl.GL_TEXTURE_2D: "sampler2D",
+    pyglet.graphics.api.gl.GL_TEXTURE_2D_ARRAY: "sampler2DArray",
 }
 
 # Allows the default shader to grab the correct coords based on texture type
 _SAMPLER_COORDS = {
-    pyglet.gl.GL_TEXTURE_2D: ".xy",
-    pyglet.gl.GL_TEXTURE_2D_ARRAY: ""
+    pyglet.graphics.api.gl.GL_TEXTURE_2D: ".xy",
+    pyglet.graphics.api.gl.GL_TEXTURE_2D_ARRAY: "",
 }
 
 
@@ -137,9 +150,9 @@ def _get_default_mt_shader(images: dict[str, Texture]) -> ShaderProgram:
     assert len(images) <= max_tex.value, f"Only {max_tex.value} Texture Units are available."
 
     # Generate the default vertex shader
-    in_tex_coords = '\n'.join([f"in vec3 {name}_coords;" for name in images.keys()])
-    out_tex_coords = '\n'.join([f"out vec3 {name}_coords_frag;" for name in images.keys()])
-    tex_coords_assignments = '\n'.join([f"{name}_coords_frag = {name}_coords;" for name in images.keys()])
+    in_tex_coords = '\n'.join([f"in vec3 {name}_coords;" for name in images])
+    out_tex_coords = '\n'.join([f"out vec3 {name}_coords_frag;" for name in images])
+    tex_coords_assignments = '\n'.join([f"{name}_coords_frag = {name}_coords;" for name in images])
 
     vertex_source = f"""
     #version 150 core
@@ -182,7 +195,7 @@ def _get_default_mt_shader(images: dict[str, Texture]) -> ShaderProgram:
     }}
     """
 
-    in_tex_coords = '\n'.join([f"in vec3 {name}_coords_frag;" for name in images.keys()])
+    in_tex_coords = '\n'.join([f"in vec3 {name}_coords_frag;" for name in images])
     uniform_samplers = '\n'.join([f"uniform {_SAMPLER_TYPES[tex.target]} {name};" for name,tex in images.items()])
     tex_operations = '\n'.join([f"  color = layer(texture({name}, {name}_coords_frag{_SAMPLER_COORDS[tex.target]}), color);" for name, tex in images.items()])
     fragment_source = f"""
@@ -206,7 +219,7 @@ def _get_default_mt_shader(images: dict[str, Texture]) -> ShaderProgram:
     }}
     """
 
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'), (fragment_source, 'fragment'))
+    return pyglet.graphics.api.core.current_context.create_program((vertex_source, 'vertex'), (fragment_source, 'fragment'))
 
 
 class MultiTextureSprite(pyglet.sprite.Sprite):
@@ -252,7 +265,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
     group_class = MultiTextureSpriteGroup
 
     def __init__(self,
-                 images: dict[str, AbstractImage | Animation],
+                 images: dict[str, _AbstractImage | Animation],
                  x: float = 0, y: float = 0, z: float = 0,
                  blend_src: int = GL_SRC_ALPHA,
                  blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
@@ -390,8 +403,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
             getattr(self._vertex_list,f"{key}_coords")[:] = self._textures[key].tex_coords
 
     def _create_vertex_list(self) -> None:
-        """
-        Override so we can send over texture coords for each texture being used.
+        """Override so we can send over texture coords for each texture being used.
         """
         tex_coords = {}
         for name, tex in self._textures.items():
@@ -439,7 +451,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
 
         return 0
 
-    def get_layer(self, name: str) -> AbstractImage | Animation | None:
+    def get_layer(self, name: str) -> _AbstractImage | Animation | None:
         """Return the requested layer.  If it is not found then None is returned
 
         Args:
@@ -448,12 +460,12 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
         """
         if name in self._animations:
             return self._animations[name]
-        elif name in self._textures:
+        if name in self._textures:
             return self._textures[name]
 
         return None
 
-    def set_layer(self, name: str, img: AbstractImage | Animation) -> None:
+    def set_layer(self, name: str, img: _AbstractImage | Animation) -> None:
         """Sets the layer to the new image or animation.
 
         This method has no effect if name is not a valid layer.  Note: if you
@@ -504,7 +516,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
         raise NotImplementedError("MultiTextureSprite does not support the image property.  Use get_layer instead.")
 
     @image.setter
-    def image(self, img: AbstractImage | Animation) -> None:
+    def image(self, img: _AbstractImage | Animation) -> None:
         raise NotImplementedError("MultiTextureSprite does not support the image property.  Use set_layer instead.")
 
     @property

pyglet/experimental/particles.py

@@ -7,7 +7,8 @@ import time
 
 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
 
@@ -176,49 +177,26 @@ fragment_source = """#version 150
 
 
 def get_default_shader():
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (geometry_source, 'geometry'),
-                                                    (fragment_source, 'fragment'))
+    return pyglet.graphics.api.get_cached_shader(
+        "default_particles",
+        (vertex_source, 'vertex'),
+        (geometry_source, 'geometry'),
+        (fragment_source, 'fragment'),
+    )
 
 
 class EmitterGroup(graphics.Group):
     def __init__(self, texture, blend_src, blend_dest, program, parent=None):
         super().__init__(parent=parent)
         self.texture = texture
-        self.blend_src = blend_src
-        self.blend_dest = blend_dest
+        self.set_shader_program(program)
+        self.set_texture(texture)
+        self.set_blend(blend_src, blend_dest)
         self.program = program
 
-    def set_state(self):
-        self.program.use()
-
-        glActiveTexture(GL_TEXTURE0)
-        glBindTexture(self.texture.target, self.texture.id)
-
-        glEnable(GL_BLEND)
-        glBlendFunc(self.blend_src, self.blend_dest)
-
-    def unset_state(self):
-        glDisable(GL_BLEND)
-        self.program.stop()
-
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.texture})"
 
-    def __eq__(self, other):
-        return (other.__class__ is self.__class__ and
-                self.program is other.program and
-                self.parent == other.parent and
-                self.texture.target == other.texture.target and
-                self.texture.id == other.texture.id and
-                self.blend_src == other.blend_src and
-                self.blend_dest == other.blend_dest)
-
-    def __hash__(self):
-        return hash((self.program, self.parent,
-                     self.texture.id, self.texture.target,
-                     self.blend_src, self.blend_dest))
-
 
 class Emitter(event.EventDispatcher):
     _batch = None
@@ -267,7 +245,7 @@ class Emitter(event.EventDispatcher):
         texture = self._texture
         count = self._count
         self._vertex_list = self.program.vertex_list(
-            count, GL_POINTS, self._batch, self._group,
+            count, GeometryMode.POINTS, self._batch, self._group,
             position=('f', (self._x, self._y, self._z) * count),
 
             size=('f', (texture.width, texture.height, texture.anchor_x, texture.anchor_y) * count),