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

pyglet/graphics/api/gl/shapes.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+import pyglet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.shader import ShaderProgram
+
+vertex_source = """#version 150 core
+    in vec2 position;
+    in vec3 translation;
+    in vec4 colors;
+    in float rotation;
+
+    out vec4 vertex_colors;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    mat4 m_rotation = mat4(1.0);
+    mat4 m_translate = mat4(1.0);
+
+    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 = window.projection * window.view * m_translate * m_rotation * vec4(position, translation.z, 1.0);
+        vertex_colors = colors;
+    }
+"""
+
+fragment_source = """#version 150 core
+    in vec4 vertex_colors;
+    out vec4 final_color;
+
+    void main()
+    {
+        final_color = 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/gl/sprite.py

@@ -0,0 +1,102 @@
+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 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: str = """#version 150 core
+    in vec4 vertex_colors;
+    in vec3 texture_coords;
+    out vec4 final_colors;
+
+    uniform sampler2D sprite_texture;
+
+    void main()
+    {
+        final_colors = texture(sprite_texture, texture_coords.xy) * vertex_colors;
+    }
+"""
+
+fragment_array_source: str = """#version 150 core
+    in vec4 vertex_colors;
+    in vec3 texture_coords;
+    out vec4 final_colors;
+
+    uniform sampler2DArray sprite_texture;
+
+    void main()
+    {
+        final_colors = texture(sprite_texture, texture_coords) * 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.
+    """
+    return pyglet.graphics.api.core.get_cached_shader(
+        "default_sprite_array",
+        (vertex_source, 'vertex'),
+        (fragment_array_source, 'fragment'),
+    )

pyglet/graphics/api/gl/state.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Callable, Generator, TYPE_CHECKING
+
+import pyglet
+from pyglet.enums import BlendFactor, BlendOp, CompareOp
+from pyglet.graphics.api.gl import GL_TEXTURE0, GL_BLEND, GL_SCISSOR_TEST, GL_DEPTH_TEST, OpenGLSurfaceContext, \
+    glScissor
+from pyglet.graphics.api.gl.enums import blend_factor_map, compare_op_map
+from pyglet.graphics.state import State
+
+if TYPE_CHECKING:
+    from pyglet.graphics.texture import TextureBase
+    from pyglet.graphics.api.gl.shader import ShaderProgram
+    from pyglet.customtypes import ScissorProtocol
+
+
+@dataclass(frozen=True)
+class ActiveTextureState(State):
+    binding: int
+    sets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx = pyglet.graphics.api.core.current_context
+        ctx.glActiveTexture(GL_TEXTURE0 + self.binding)
+
+    # Technically not needed since this is a dependent state and will always be called with its parents.
+    # def unset_state(self, ctx: OpenGLSurfaceContext):
+    #    glActiveTexture(GL_TEXTURE0)
+
+
+@dataclass(frozen=True)
+class TextureState(State):  # noqa: D101
+    texture: tuple[int, int]
+    binding: int = 0
+    set_id: int = 0
+
+    parents: bool = True
+    sets_state: bool = True
+
+    @classmethod
+    def from_texture(cls, texture: TextureBase, binding: int, set_id: int) -> TextureState:
+        return cls((texture.target, texture.id), binding, set_id)
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glBindTexture(*self.texture)
+
+    def generate_parent_states(self) -> Generator[State, None, None]:
+        yield ActiveTextureState(self.binding)
+
+
+
+@dataclass(frozen=True)
+class ShaderProgramState(State):
+    program: ShaderProgram
+
+    sets_state: bool = True
+    #unsets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        self.program.use()
+
+    #def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+    #    self.program.stop()
+
+@dataclass(frozen=True)
+class RenderPassState(State):
+    renderpass: Any  # Renderpass for Vulkan.
+
+
+@dataclass(frozen=True)
+class RenderAreaState(State):
+    width: int
+    height: int
+
+
+@dataclass(frozen=True)
+class ScissorStateEnable(State):
+    sets_state: bool = True
+    unsets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glEnable(GL_SCISSOR_TEST)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glDisable(GL_SCISSOR_TEST)
+
+@dataclass(frozen=True)
+class ScissorState(State):
+    spo: ScissorProtocol
+
+    sets_state: bool = True
+    parents: bool = True
+
+    def generate_parent_states(self) -> Generator[State, None, None]:
+        yield ScissorStateEnable()
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        glScissor(int(self.spo.x), int(self.spo.y), int(self.spo.width), int(self.spo.height))
+
+
+@dataclass(frozen=True)
+class BlendStateEnable(State):
+    sets_state: bool = True
+    unsets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glEnable(GL_BLEND)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glDisable(GL_BLEND)
+
+
+@dataclass(frozen=True)
+class BlendState(State):
+    src: BlendFactor
+    dst: BlendFactor
+    op: BlendOp = BlendOp.ADD
+
+    sets_state: bool = True
+    parents: bool = True
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.src, BlendFactor):
+            raise Exception("src must be BlendFactor")
+
+    def generate_parent_states(self) -> Generator[State, None, None]:
+        yield BlendStateEnable()
+        # Do later.
+        #if self.op != BlendOp.ADD:
+        #    yield GLBlendState(blend_factor_map[self.src], self.op)
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glBlendFunc(blend_factor_map[self.src], blend_factor_map[self.dst])
+
+
+@dataclass(frozen=True)
+class DepthTestStateEnable(State):
+    sets_state: bool = True
+    unsets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glEnable(GL_DEPTH_TEST)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glDisable(GL_DEPTH_TEST)
+
+
+@dataclass(frozen=True)
+class DepthBufferComparison(State):
+    func: CompareOp
+
+    sets_state: bool = True
+    parents: bool = True
+
+    def generate_parent_states(self) -> Generator[State, None, None]:
+        yield DepthTestStateEnable()
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glDepthFunc(compare_op_map[self.func])
+
+
+@dataclass(frozen=True)
+class DepthWriteState(State):
+    flag: int
+
+@dataclass(frozen=True)
+class StencilFuncState(State):
+    func: Callable
+    ref: int
+    mask: int
+
+@dataclass(frozen=True)
+class StencilOpState(State):
+    fail: int
+    zfail: int
+    zpass: int
+
+@dataclass(frozen=True)
+class PolygonModeState(State):
+    face: int
+    mode: int
+
+
+@dataclass(frozen=True)
+class ViewportState(State):
+    x: int
+    y: int
+    width: int
+    height: float
+
+    sets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.glViewport(self.x, self.y, self.width, self.height)
+
+
+@dataclass(frozen=True)
+class UniformBufferState(State):
+    name: str
+    binding: int
+
+
+@dataclass(frozen=True)
+class ShaderUniformState(State):
+    program: ShaderProgram
+    data: dict[str, Any]
+
+    sets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        for name, value in self.data.items():
+            self.program[name] = value
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    def __eq__(self, other: State) -> bool:
+        return False

pyglet/graphics/api/gl/text.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import pyglet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.shader import ShaderProgram
+
+layout_vertex_source = """#version 330 core
+    in vec3 position;
+    in vec4 colors;
+    in vec3 tex_coords;
+    in vec3 translation;
+    in vec3 view_translation;
+    in vec2 anchor;
+    in float rotation;
+    in float visible;
+
+    out vec4 text_colors;
+    out vec2 texture_coords;
+    out vec4 vert_position;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    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 = window.projection * window.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 330 core
+    in vec4 text_colors;
+    in vec2 texture_coords;
+    in vec4 vert_position;
+
+    out vec4 final_colors;
+
+    uniform sampler2D text;
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        final_colors = texture(text, texture_coords) * text_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
+        }
+    }
+"""
+layout_fragment_image_source = """#version 330 core
+    in vec4 text_colors;
+    in vec2 texture_coords;
+    in vec4 vert_position;
+
+    uniform sampler2D image_texture;
+
+    out vec4 final_colors;
+
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        final_colors = texture(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 330 core
+    in vec3 position;
+    in vec4 colors;
+    in vec3 translation;
+    in vec3 view_translation;
+    in vec2 anchor;
+    in float rotation;
+    in float visible;
+
+    out vec4 vert_colors;
+    out vec4 vert_position;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    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 = window.projection * window.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 330 core
+    in vec4 vert_colors;
+    in vec4 vert_position;
+
+    out vec4 final_colors;
+
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        final_colors = 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"),
+    )
+
+# ====== SCROLLING TEXT
+
+