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

pyglet/graphics/api/gl2/global_opengl.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import ctypes
+import sys
+from typing import Sequence, TYPE_CHECKING
+
+import pyglet
+from pyglet.graphics.api.gl.global_opengl import OpenGLBackend
+from pyglet.graphics.api.base import WindowTransformations
+from pyglet.graphics.api.gl2.shader import ShaderProgram, Shader
+
+from pyglet.math import Mat4
+
+if TYPE_CHECKING:
+    from _ctypes import Array
+    from pyglet.graphics.shader import ShaderType
+    from pyglet.window import Window
+
+_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
+
+
+class OpenGL2_Matrices(WindowTransformations):
+    def __init__(self, window: Window, backend: OpenGL2Backend):
+        self.backend = backend
+        self._viewport = (0, 0, *window.get_framebuffer_size())
+
+        width, height = window.get_size()
+        super().__init__(window, Mat4.orthogonal_projection(0, width, 0, height, -255, 255), Mat4(), Mat4())
+
+        self.projection = self._projection
+        self.view = self._view
+
+    @staticmethod
+    def _get_mat_float_array(matrix: Mat4) -> Array[ctypes.c_float]:
+        return (ctypes.c_float * 16)(*matrix)
+
+    @property
+    def projection(self) -> Mat4:
+        return self._projection
+
+    @projection.setter
+    def projection(self, projection: Mat4) -> None:
+        self._projection = projection
+
+        projection_array = tuple(self._projection)
+        for program in self.backend.current_context.cached_programs.values():
+            with program:
+                program["u_projection"] = projection_array
+
+    @property
+    def view(self) -> Mat4:
+        return self._view
+
+    @view.setter
+    def view(self, view: Mat4) -> None:
+        self._view = view
+        view_array = tuple(self._view)
+        for program in self.backend.current_context.cached_programs.values():
+            with program:
+                program["u_view"] = view_array
+
+    @property
+    def model(self) -> Mat4:
+        return self._model
+
+    @model.setter
+    def model(self, model: Mat4) -> None:
+        self._model = model
+
+class OpenGL2Backend(OpenGLBackend):
+
+    def get_default_configs(self) -> Sequence[pyglet.config.OpenGLConfig]:
+        """A sequence of configs to use if the user does not specify any.
+
+        These will be used during Window creation.
+        """
+        return [
+            pyglet.config.OpenGLConfig(double_buffer=True, depth_size=24, major_version=2, minor_version=0,
+                                                opengl_api=self.gl_api),
+            pyglet.config.OpenGLConfig(double_buffer=True, depth_size=16, major_version=2, minor_version=0,
+                                                opengl_api=self.gl_api),
+        ]
+
+    def get_cached_shader(self, name: str, *sources: tuple[str, ShaderType]) -> ShaderProgram:
+        """Create a ShaderProgram from OpenGL GLSL source.
+
+        This is a convenience method that takes one or more tuples of
+        (source_string, shader_type), and returns a
+        :py:class:`~pyglet.graphics.ShaderProgram` instance.
+
+        ``source_string`` is OpenGL GLSL source code as a str, and ``shader_type``
+        is the OpenGL shader type, such as "vertex" or "fragment". See
+        :py:class:`~pyglet.graphics.Shader` for more information.
+
+        .. note:: This method is cached. Given the same shader sources, the
+                  same ShaderProgram instance will be returned. For more
+                  control over the ShaderProgram lifecycle, it is recommended
+                  to manually create Shaders and link ShaderPrograms.
+
+        .. versionadded:: 2.0.10
+        """
+        assert self.current_context
+        assert isinstance(name, str), "First argument must be a string name for the shader."
+
+        if program := self.current_context.cached_programs.get(name):
+            return program
+
+        shaders = (Shader(src, srctype) for (src, srctype) in sources)
+        program = ShaderProgram(*shaders)
+        self.current_context.cached_programs[name] = program
+
+        # With GLES it doesn't support glMatrixMode's and no UBO's.
+        # Set the projection for each shader manually.
+        if not self.current_context.window._shadow:  # Do not set if it's the shadow window?  # noqa: SLF001
+            with program:
+                program["u_projection"] = tuple(self.current_context.window._matrices.projection)
+                program["u_view"] = tuple(self.current_context.window._matrices.view)
+
+        return program
+
+    def initialize_matrices(self, window: Window) -> OpenGL2_Matrices:
+        return OpenGL2_Matrices(window, self)

pyglet/graphics/api/gl2/shader.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from ctypes import (
+    Structure,
+    c_byte,
+    c_double,
+    c_float,
+    c_int,
+    c_short,
+    c_ubyte,
+    c_uint,
+    c_ushort,
+)
+from typing import TYPE_CHECKING
+
+import pyglet
+import pyglet.graphics.api.gl.gl as gl
+from pyglet.graphics.api.gl.shader import GLDataType
+from pyglet.graphics.api.gl.shader import Shader as GLShader
+from pyglet.graphics.api.gl.shader import ShaderProgram as GLShaderProgram
+from pyglet.graphics.shader import ShaderException, ShaderSource, ShaderType
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl import OpenGLSurfaceContext
+    from pyglet.customtypes import CType, DataTypes
+
+_debug_api_shaders = pyglet.options.debug_api_shaders
+
+_c_types: dict[int, CType] = {
+    gl.GL_BYTE: c_byte,
+    gl.GL_UNSIGNED_BYTE: c_ubyte,
+    gl.GL_SHORT: c_short,
+    gl.GL_UNSIGNED_SHORT: c_ushort,
+    gl.GL_INT: c_int,
+    gl.GL_UNSIGNED_INT: c_uint,
+    gl.GL_FLOAT: c_float,
+    gl.GL_DOUBLE: c_double,
+}
+
+_data_type_to_gl_type: dict[DataTypes, int] = {
+    'b': gl.GL_BYTE,  # signed byte
+    'B': gl.GL_UNSIGNED_BYTE,  # unsigned byte
+    'h': gl.GL_SHORT,  # signed short
+    'H': gl.GL_UNSIGNED_SHORT,  # unsigned short
+    'i': gl.GL_INT,  # signed int
+    'I': gl.GL_UNSIGNED_INT,  # unsigned int
+    'f': gl.GL_FLOAT,  # float
+    'q': gl.GL_INT,  # signed long long (Requires GL_INT64_NV if available. Just use int.)
+    'Q': gl.GL_UNSIGNED_INT,  # unsigned long long (Requires GL_UNSIGNED_INT64_NV if available. Just use uint.)
+}
+
+
+class UniformBlock:
+    """Not supported by OpenGL 2.0."""
+
+    def __init__(
+        self,
+        program: ShaderProgram,
+        name: str,
+        index: int,
+        size: int,
+        binding: int,
+        uniforms: dict[int, tuple[str, GLDataType, int, int]],
+        uniform_count: int,
+    ) -> None:
+        raise NotImplementedError
+
+
+class UniformBufferObject:
+    """Not supported by OpenGL 2.0."""
+
+    def __init__(self, view_class: type[Structure], buffer_size: int, binding: int) -> None:
+        """Initialize the Uniform Buffer Object with the specified Structure."""
+        raise NotImplementedError
+
+
+
+
+# Shader & program classes:
+
+
+class GLShaderSource(ShaderSource):
+    """GLSL source container for making source parsing simpler.
+
+    We support locating out attributes and applying #defines values.
+
+    .. note:: We do assume the source is neat enough to be parsed this way and doesn't contain several statements in
+              one line.
+    """
+
+    _type: gl.GLenum
+    _lines: list[str]
+
+    def __init__(self, source: str, source_type: gl.GLenum | int) -> None:
+        """Create a shader source wrapper."""
+        self._lines = source.strip().splitlines()
+        self._type = source_type
+
+        if not self._lines:
+            msg = "Shader source is empty"
+            raise ShaderException(msg)
+
+        self._version = self._find_glsl_version()
+
+        if "es" in pyglet.options.backend:
+            self._patch_gles()
+
+        self._patch_legacy()
+
+    def _patch_legacy(self) -> None:
+        """Replace any legacy GL2 matrices with our uniform implementation."""
+        if self._type == gl.GL_VERTEX_SHADER:
+            replaced = False
+            for idx, line in enumerate(self._lines):
+                if "gl_ProjectionMatrix" in line or "gl_ModelViewMatrix" in line:
+                    self._lines[idx] = line.replace("gl_ProjectionMatrix", "u_projection").replace(
+                        "gl_ModelViewMatrix",
+                        "u_view",
+                    )
+                    replaced = True
+
+            if replaced:
+                self._lines.insert(1, "uniform mat4 u_projection;")
+                self._lines.insert(2, "uniform mat4 u_view;")
+
+    def _patch_gles(self) -> None:
+        """Patch the built-in shaders for GLES support.
+
+        Probably will need better handling to not affect user shaders.
+        """
+        if self._lines[0].strip().startswith("#version"):
+            self._lines[0] = ""
+
+            self._lines.insert(0, "precision mediump float;")
+
+        self._version = "es 1.00"
+
+    def validate(self) -> str:
+        """Return the validated shader source."""
+        return "\n".join(self._lines)
+
+    def _find_glsl_version(self) -> int:
+        if self._lines[0].strip().startswith("#version"):
+            try:
+                return int(self._lines[0].split()[1])
+            except (ValueError, IndexError):
+                pass
+
+        source = "\n".join(f"{str(i + 1).zfill(3)}: {line} " for i, line in enumerate(self._lines))
+
+        msg = (
+            "Cannot find #version flag in shader source. "
+            "A #version statement is required on the first line.\n"
+            "------------------------------------\n"
+            f"{source}"
+        )
+        raise ShaderException(msg)
+
+
+class Shader(GLShader):
+    """OpenGL shader.
+
+    Shader objects are compiled on instantiation.
+    You can reuse a Shader object in multiple ShaderPrograms.
+    """
+
+    _context: OpenGLSurfaceContext | None
+    _id: int | None
+    type: ShaderType
+
+    @classmethod
+    def supported_shaders(cls) -> tuple[ShaderType, ...]:
+        return 'vertex', 'fragment'
+
+    @staticmethod
+    def get_string_class() -> type[GLShaderSource]:
+        return GLShaderSource
+
+
+class ShaderProgram(GLShaderProgram):  # noqa: D101
+    _uniform_blocks: None
+    __slots__ = '_attributes', '_context', '_id', '_uniform_blocks', '_uniforms'
+
+    def __init__(self, *shaders: Shader) -> None:
+        """Initialize the ShaderProgram using at least two Shader instances."""
+        super().__init__(*shaders)
+
+    def _get_uniform_blocks(self) -> None:
+        """Return Uniform Block information."""
+        return
+
+
+class ComputeShaderProgram:
+    """OpenGL Compute Shader Program.
+
+    Not supported by OpenGL 2.0
+    """
+
+    def __init__(self, source: str) -> None:
+        raise NotImplementedError

pyglet/graphics/api/gl2/shapes.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import pyglet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api import ShaderProgram
+
+vertex_source = """#version 110
+    attribute vec2 position;
+    attribute vec3 translation;
+    attribute vec4 colors;
+    attribute float rotation;
+
+    varying vec4 vertex_colors;
+
+    mat4 m_rotation = mat4(1.0);
+    mat4 m_translate = mat4(1.0);
+
+    uniform mat4 u_projection;
+    uniform mat4 u_view;
+
+    void main()
+    {
+        m_translate[3][0] = translation.x;
+        m_translate[3][1] = translation.y;
+        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 = u_projection * u_view * m_translate * m_rotation * vec4(position, translation.z, 1.0);
+        vertex_colors = colors;
+    }
+"""
+
+fragment_source = """#version 150 core
+    varying vec4 vertex_colors;
+
+    void main()
+    {
+        gl_FragColor = vertex_colors;
+    }
+"""
+
+
+def get_default_shader() -> ShaderProgram:
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_shapes",
+        (vertex_source, 'vertex'),
+        (fragment_source, 'fragment'),
+    )

pyglet/graphics/api/gl2/sprite.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+import pyglet
+
+_is_pyglet_doc_run = hasattr(sys, 'is_pyglet_doc_run') and sys.is_pyglet_doc_run
+
+if TYPE_CHECKING:
+    from pyglet.graphics import ShaderProgram
+
+
+vertex_source: str = """#version 110
+    attribute vec3 translate;
+    attribute vec4 colors;
+    attribute vec3 tex_coords;
+    attribute vec2 scale;
+    attribute vec3 position;
+    attribute float rotation;
+
+    varying vec4 vertex_colors;
+    varying vec3 texture_coords;
+
+    uniform mat4 u_projection;
+    uniform mat4 u_view;
+
+    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 = u_projection * u_view * m_translate * m_rotation * m_scale * vec4(position, 1.0);
+
+        vertex_colors = colors;
+        texture_coords = tex_coords;
+    }
+"""
+
+fragment_source: str = """#version 110
+    varying vec4 vertex_colors;
+    varying vec3 texture_coords;
+
+    uniform sampler2D sprite_texture;
+
+    void main()
+    {
+        gl_FragColor = texture2D(sprite_texture, texture_coords.xy) * vertex_colors;
+    }
+"""
+
+def get_default_shader() -> ShaderProgram:
+    """Create and return the default sprite shader.
+
+    This method allows the module to be imported without an OpenGL Context.
+    """
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_sprite",
+        (vertex_source, 'vertex'),
+        (fragment_source, 'fragment'),
+    )
+
+def get_default_array_shader() -> ShaderProgram:
+    """Create and return the default array sprite shader.
+
+    This method allows the module to be imported without an OpenGL Context.
+    """
+    raise NotImplementedError

pyglet/graphics/api/gl2/text.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import pyglet
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from pyglet.graphics import ShaderProgram
+
+layout_vertex_source = """#version 110
+    attribute vec3 position;
+    attribute vec4 colors;
+    attribute vec3 tex_coords;
+    attribute vec3 translation;
+    attribute vec3 view_translation;
+    attribute vec2 anchor;
+    attribute float rotation;
+    attribute float visible;
+
+    uniform mat4 u_projection;
+    uniform mat4 u_view;
+
+    varying vec4 text_colors;
+    varying vec2 texture_coords;
+    varying vec4 vert_position;
+
+    void main()
+    {
+        mat4 m_rotation = mat4(1.0);
+        vec3 v_anchor = vec3(anchor.x, anchor.y, 0);
+        mat4 m_anchor = mat4(1.0);
+        mat4 m_translate = mat4(1.0);
+
+        m_translate[3][0] = translation.x;
+        m_translate[3][1] = translation.y;
+        m_translate[3][2] = translation.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 = u_projection * u_view * m_translate * m_anchor * m_rotation * vec4(position + 
+        view_translation + v_anchor, 1.0) * visible;
+
+        vert_position = vec4(position + translation + view_translation + v_anchor, 1.0);
+        text_colors = colors;
+        texture_coords = tex_coords.xy;
+    }
+"""
+
+layout_fragment_source = """#version 110
+    varying vec4 text_colors;
+    varying vec2 texture_coords;
+    varying vec4 vert_position;
+
+    uniform sampler2D text;
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        gl_FragColor = vec4(text_colors.rgb, texture2D(text, texture_coords).a * text_colors.a);
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+layout_fragment_image_source = """#version 110
+    varying vec4 text_colors;
+    varying vec2 texture_coords;
+    varying vec4 vert_position;
+
+    uniform sampler2D image_texture;
+
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        gl_FragColor = texture2D(image_texture, texture_coords.xy);
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+decoration_vertex_source = """#version 110
+    attribute vec3 position;
+    attribute vec4 colors;
+    attribute vec3 translation;
+    attribute vec3 view_translation;
+    attribute vec2 anchor;
+    attribute float rotation;
+    attribute float visible;
+
+    varying vec4 vert_colors;
+    varying vec4 vert_position;
+
+    uniform mat4 u_projection;
+    uniform mat4 u_view;
+
+    void main()
+    {
+        mat4 m_rotation = mat4(1.0);
+        vec3 v_anchor = vec3(anchor.x, anchor.y, 0);
+        mat4 m_anchor = mat4(1.0);
+        mat4 m_translate = mat4(1.0);
+
+        m_translate[3][0] = translation.x;
+        m_translate[3][1] = translation.y;
+        m_translate[3][2] = translation.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 = u_projection * u_view * m_translate * m_anchor * m_rotation * vec4(position + 
+        view_translation + v_anchor, 1.0) * visible;
+
+        vert_position = vec4(position + translation + view_translation + v_anchor, 1.0);
+        vert_colors = colors;
+    }
+"""
+decoration_fragment_source = """#version 110
+    varying vec4 vert_colors;
+    varying vec4 vert_position;
+
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        gl_FragColor = vert_colors;
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+
+
+def get_default_layout_shader() -> ShaderProgram:
+    """The default shader used for all glyphs in the layout."""
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_text_layout",
+        (layout_vertex_source, "vertex"),
+        (layout_fragment_source, "fragment"),
+    )
+
+
+def get_default_image_layout_shader() -> ShaderProgram:
+    """The default shader used for an InlineElement image. Used for HTML Labels that insert images via <img> tag."""
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_text_image",
+        (layout_vertex_source, "vertex"),
+        (layout_fragment_image_source, "fragment"),
+    )
+
+
+def get_default_decoration_shader() -> ShaderProgram:
+    """The default shader for underline and background decoration effects in the layout."""
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_text_decoration",
+        (decoration_vertex_source, "vertex"),
+        (decoration_fragment_source, "fragment"),
+    )