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

pyglet/graphics/api/webgl/shapes.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pyglet
+from pyglet.enums import BlendFactor
+from pyglet.graphics.draw import Group
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.webgl.shader import ShaderProgram
+
+vertex_source = """#version 300 es
+    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 300 es
+    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'),
+    )
+
+
+class _ShapeGroup(Group):
+    """Shared Shape rendering Group.
+
+    The group is automatically coalesced with other shape groups
+    sharing the same parent group and blend parameters.
+    """
+
+    blend_src: int
+    blend_dest: int
+
+    def __init__(
+        self, blend_src: BlendFactor, blend_dest: BlendFactor, program: ShaderProgram, parent: Group | None = None
+    ) -> None:
+        """Create a Shape group.
+
+        The group is created internally. Usually you do not
+        need to explicitly create it.
+
+        Args:
+            blend_src:
+                OpenGL blend source mode; for example, ``GL_SRC_ALPHA``.
+            blend_dest:
+                OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``.
+            program:
+                The ShaderProgram to use.
+            parent:
+                Optional parent group.
+        """
+        super().__init__(parent=parent)
+        self.set_shader_program(program)
+        self.set_blend(blend_src, blend_dest)

pyglet/graphics/api/webgl/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.shader 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/webgl/state.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Callable, Generator
+
+from pyglet.enums import BlendFactor, BlendOp, CompareOp
+from pyglet.graphics.api.webgl.enums import blend_factor_map, compare_op_map
+from pyglet.graphics.api.webgl.gl import GL_BLEND, GL_DEPTH_TEST, GL_SCISSOR_TEST, GL_TEXTURE0
+from pyglet.graphics.state import State
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.webgl.webgl_js import WebGLTexture
+    from pyglet.graphics.api.webgl import OpenGLSurfaceContext
+    from pyglet.graphics import Group
+    from pyglet.graphics.api.webgl.shader import ShaderProgram
+    from pyglet.graphics.texture import TextureBase
+
+
+@dataclass(frozen=True)
+class ActiveTextureState(State):
+    binding: int
+    sets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.activeTexture(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]
+    # WebGL doesn't expose the actual texture ID, so we use the python memory ID instead to consolidate the types
+    # as Python doesn't allow the JS Proxy to be hashable.
+    # However, the actual WebGL object needs to be passed for the function.
+    webgl_texture: WebGLTexture = field(hash=False, compare=False)
+    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, id(texture.id)),
+                   webgl_texture=texture.id,
+                   binding=binding,
+                   set_id=set_id)
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.bindTexture(self.texture[0], self.webgl_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()l
+
+
+@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.gl.enable(GL_SCISSOR_TEST)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.disable(GL_SCISSOR_TEST)
+
+
+@dataclass(frozen=True)
+class ScissorState(State):
+    group: Group
+
+    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:
+        ctx.gl.scissor(*self.group.data["scissor"])
+
+
+@dataclass(frozen=True)
+class BlendStateEnable(State):
+    sets_state: bool = True
+    unsets_state: bool = True
+
+    def set_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.enable(GL_BLEND)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.disable(GL_BLEND)
+
+
+@dataclass(frozen=True)
+class BlendState(State):
+    src: BlendFactor
+    dst: BlendFactor
+    op: BlendOp = BlendOp.ADD
+
+    sets_state: bool = True
+    parents: bool = True
+
+    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.gl.blendFunc(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.gl.enable(GL_DEPTH_TEST)
+
+    def unset_state(self, ctx: OpenGLSurfaceContext) -> None:
+        ctx.gl.disable(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.gl.depthFunc(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.gl.viewport(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/webgl/text.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pyglet
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.webgl 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"),
+    )