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

pyglet/graphics/api/gl2/vertexdomain.py

@@ -0,0 +1,364 @@
+"""Manage related vertex attributes within a single vertex domain.
+
+A vertex "domain" consists of a set of attribute descriptions that together
+describe the layout of one or more vertex buffers which are used together to
+specify the vertices in a primitive.  Additionally, the domain manages the
+buffers used to store the data and will resize them as necessary to accommodate
+new vertices.
+
+Domains can optionally be indexed, in which case they also manage a buffer
+containing vertex indices.  This buffer is grown separately and has no size
+relation to the attribute buffers.
+
+Applications can create vertices (and optionally, indices) within a domain
+with the :py:meth:`VertexDomain.create` method.  This returns a
+:py:class:`VertexList` representing the list of vertices created.  The vertex
+attribute data within the group can be modified, and the changes will be made
+to the underlying buffers automatically.
+
+The entire domain can be efficiently drawn in one step with the
+:py:meth:`VertexDomain.draw` method, assuming all the vertices comprise
+primitives of the same OpenGL primitive mode.
+"""
+from __future__ import annotations
+
+import ctypes
+from typing import TYPE_CHECKING, Any, Sequence
+
+from ctypes import Array
+
+from pyglet.graphics.api.gl import (
+    GL_BYTE,
+    GL_DOUBLE,
+    GL_FLOAT,
+    GL_INT,
+    GL_SHORT,
+    GL_UNSIGNED_BYTE,
+    GL_UNSIGNED_INT,
+    GL_UNSIGNED_SHORT,
+    GLint,
+    GLintptr,
+    GLsizei,
+    GLvoid,
+    GL_ARRAY_BUFFER, OpenGLSurfaceContext,
+
+)
+from pyglet.graphics.api.gl.enums import geometry_map
+from pyglet.graphics.api.gl.shader import GLAttribute
+from pyglet.graphics.api.gl2.buffer import AttributeBufferObject, IndexedBufferObject
+from pyglet.graphics.vertexdomain import (
+    VertexStream,
+    IndexStream,
+    VertexArrayBinding,
+    VertexArrayProtocol,
+    VertexDomainBase,
+    VertexListBase,
+    IndexedVertexDomainBase,
+    IndexedVertexListBase,
+    VertexGroupBucket,
+    _RunningIndexSupport,
+)
+
+if TYPE_CHECKING:
+    from pyglet.graphics.shader import AttributeView
+    from pyglet.customtypes import CType, DataTypes
+    from pyglet.graphics import GeometryMode
+    from pyglet.graphics.shader import Attribute
+
+_c_types = {
+    GL_BYTE: ctypes.c_byte,
+    GL_UNSIGNED_BYTE: ctypes.c_ubyte,
+    GL_SHORT: ctypes.c_short,
+    GL_UNSIGNED_SHORT: ctypes.c_ushort,
+    GL_INT: ctypes.c_int,
+    GL_UNSIGNED_INT: ctypes.c_uint,
+    GL_FLOAT: ctypes.c_float,
+    GL_DOUBLE: ctypes.c_double,
+}
+
+_gl_types = {
+    'b': GL_BYTE,
+    'B': GL_UNSIGNED_BYTE,
+    'h': GL_SHORT,
+    'H': GL_UNSIGNED_SHORT,
+    'i': GL_INT,
+    'I': GL_UNSIGNED_INT,
+    'f': GL_FLOAT,
+    'd': GL_DOUBLE,
+}
+
+
+def _make_attribute_property(name: str) -> property:
+    def _attribute_getter(self: VertexList) -> Array[float | int]:
+        buffer = self.domain.attrib_name_buffers[name]
+        region = buffer.get_region(self.start, self.count)
+        buffer.invalidate_region(self.start, self.count)
+        return region
+
+    def _attribute_setter(self: VertexList, data: Any) -> None:
+        buffer = self.domain.attrib_name_buffers[name]
+        buffer.set_region(self.start, self.count, data)
+
+    return property(_attribute_getter, _attribute_setter)
+
+
+class GLVertexArrayBinding(VertexArrayBinding):
+    streams: list[GLVertexStream | GLIndexStream]
+
+    """GL2 doesn't have a real VAO. This just acts as a container."""
+    def _create_vao(self) -> VertexArrayProtocol | None:
+        return None
+
+    def _link(self) -> None:
+        pass
+
+    def bind(self) -> None:
+        for stream in self.streams:
+            stream.bind_into(self.vao)
+
+    def unbind(self) -> None:
+        for stream in self.streams:
+            stream.unbind()
+
+
+class InstancedVertexDomain:
+    """Not available in OpenGL 2.0"""
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError("InstancedVertexDomain is not available in OpenGL 2.0.")
+
+
+class InstancedIndexedVertexDomain:
+    """Not available in OpenGL 2.0"""
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError("InstancedIndexedVertexDomain is not available in OpenGL 2.0.")
+
+
+class VertexList(VertexListBase):
+    ...
+
+
+class IndexedVertexList(IndexedVertexListBase):
+    ...
+
+
+class GLVertexStream(VertexStream):
+    _ctx: OpenGLSurfaceContext
+
+    def __init__(self, ctx: OpenGLSurfaceContext, initial_size: int, attrs: Sequence[Attribute], *, divisor: int = 0):
+        super().__init__(ctx, initial_size, attrs, divisor=divisor)
+
+    def get_graphics_attribute(self, attribute: Attribute, view: AttributeView) -> GLAttribute:
+        return GLAttribute(attribute, view)
+
+    def get_buffer(self, size: int, attribute) -> AttributeBufferObject:
+        # TODO: use persistent buffer if we have GL support for it:
+        # attribute.buffer = PersistentBufferObject(attribute.stride * self.allocator.capacity, attribute, self.vao)
+        return AttributeBufferObject(self._ctx, size, attribute)
+
+    def bind_into(self, _vao: None) -> None:
+        for attribute, buffer in zip(self.attribute_names.values(), self.buffers):
+            buffer.commit()
+            attribute.enable()
+            attribute.set_pointer()
+
+    def unbind(self) -> None:
+        for attribute in self.attribute_names.values():
+            attribute.disable()
+
+
+class GLIndexStream(IndexStream):
+    index_element_size: int
+    index_c_type: CType
+    gl_type: int
+
+    def __init__(self, ctx: OpenGLSurfaceContext, data_type: DataTypes, initial_elems: int) -> None:
+        self.gl_type = _gl_types[data_type]
+        self.index_c_type = _c_types[self.gl_type]
+        self.index_element_size = ctypes.sizeof(self.index_c_type)
+        super().__init__(ctx, data_type, initial_elems)
+
+    def _create_buffer(self) -> IndexedBufferObject:
+        return IndexedBufferObject(self.ctx, self.allocator.capacity * self.index_element_size,
+                                                self.index_c_type,
+                                                self.index_element_size,
+                                                1)
+
+    def bind_into(self, vao: VertexArrayBinding) -> None:
+        #self.buffer.bind_to_index_buffer()
+        pass
+
+    def unbind(self):
+        self.buffer.unbind()
+
+
+class VertexDomain(VertexDomainBase):
+    """Management of a set of vertex lists.
+
+    Construction of a vertex domain is usually done with the
+    :py:func:`create_domain` function.
+    """
+    def _has_multi_draw_extension(self, ctx: OpenGLSurfaceContext) -> bool:
+        return ctx.get_info().have_extension("GL_EXT_multi_draw_arrays")
+
+    def _create_vertex_class(self) -> type:
+        return type(self._vertex_class.__name__, (self._vertex_class,), self.vertex_buffers._property_dict)
+
+    def _create_vao(self) -> GLVertexArrayBinding:
+        return GLVertexArrayBinding(self._context, self._streams)
+
+    def _create_streams(self, size: int) -> list[VertexStream | IndexStream]:
+        self.vertex_buffers = GLVertexStream(self._context, size, self.per_vertex)
+        return [self.vertex_buffers]
+
+    def draw_buckets(self, mode: int, buckets: list[VertexGroupBucket]) -> None:
+        regions = []
+        for bucket in buckets:
+            regions.extend(bucket.merged_ranges)
+
+        start_list = [region[0] for region in regions]
+        size_list = [region[1] for region in regions]
+
+        if self._supports_multi_draw:
+            primcount = len(regions)
+            starts = (GLint * primcount)(*start_list)
+            sizes = (GLsizei * primcount)(*size_list)
+            self._context.glMultiDrawArrays(mode, starts, sizes, primcount)
+        else:
+            for start, size in zip(start_list, size_list):
+                self._context.glDrawArrays(mode, start, size)
+
+    def draw(self, mode: int) -> None:
+        """Draw all vertices in the domain.
+
+        All vertices in the domain are drawn at once. This is the
+        most efficient way to render primitives.
+
+        Args:
+            mode:
+                OpenGL drawing mode, e.g. ``GL_POINTS``, ``GL_LINES``, etc.
+
+        """
+        self.vao.bind()
+        self.vertex_buffers.commit()
+
+        starts, sizes = self.vertex_buffers.allocator.get_allocated_regions()
+        primcount = len(starts)
+        if primcount == 0:
+            pass
+        elif primcount == 1:
+            # Common case
+            self._context.glDrawArrays(mode, starts[0], sizes[0])
+        else:
+            starts = (GLint * primcount)(*starts)
+            sizes = (GLsizei * primcount)(*sizes)
+            self._context.glMultiDrawArrays(mode, starts, sizes, primcount)
+
+        for _, attribute in self.vertex_buffers.attribute_names.items():
+            attribute.disable()
+
+    def draw_subset(self, mode: GeometryMode, vertex_list: VertexList) -> None:
+        """Draw a specific VertexList in the domain.
+
+        The `vertex_list` parameter specifies a :py:class:`VertexList`
+        to draw. Only primitives in that list will be drawn.
+
+        Args:
+            mode:
+                OpenGL drawing mode, e.g. ``GL_POINTS``, ``GL_LINES``, etc.
+            vertex_list:
+                Vertex list to draw.
+
+        """
+        for buffer, attribute in self.buffer_attributes:
+            buffer.commit()
+            attribute.enable()
+            attribute.set_pointer(0)
+
+        self._context.glDrawArrays(geometry_map[mode], vertex_list.start, vertex_list.count)
+
+        for _, attribute in self.buffer_attributes:
+            attribute.disable()
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.vertex_buffers.allocator.starts
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__}@{id(self):x} {self.allocator}>'
+
+
+
+class IndexedVertexDomain(IndexedVertexDomainBase):
+    """Management of a set of indexed vertex lists.
+
+    Construction of an indexed vertex domain is usually done with the
+    :py:func:`create_domain` function.
+    """
+
+    _vertex_class = IndexedVertexList
+    index_stream: GLIndexStream
+
+    def _create_vertex_class(self) -> type:
+        # Make a custom VertexList class w/ properties for each attribute in the ShaderProgram:
+        return type(self._vertex_class.__name__, (_RunningIndexSupport, self._vertex_class),
+                                      self.vertex_buffers._property_dict)  # noqa: SLF001
+
+    def _has_multi_draw_extension(self, ctx: OpenGLSurfaceContext) -> bool:
+        return ctx.get_info().have_extension("GL_EXT_multi_draw_arrays")
+
+    def _create_vao(self) -> GLVertexArrayBinding:
+        return GLVertexArrayBinding(self._context, self._streams)
+
+    def _create_streams(self, size: int) -> list[VertexStream | IndexStream]:
+        self.vertex_buffers = GLVertexStream(self._context, size, self.per_vertex)
+        self.index_stream = GLIndexStream(self._context, self.index_type, size)
+        return [self.vertex_buffers, self.index_stream]
+
+    def draw_buckets(self, mode: int, buckets: list[VertexGroupBucket]) -> None:
+        self.vao.bind()
+        regions = []
+        for bucket in buckets:
+            regions.extend(bucket.merged_ranges)
+
+        start_list = [region[0] for region in regions]
+        size_list = [region[1] for region in regions]
+        primcount = len(regions)
+
+        if self._supports_multi_draw:
+            starts = [s * self.index_stream.index_element_size for s in start_list]
+            starts = (ctypes.POINTER(GLvoid) * primcount)(*(GLintptr * primcount)(*starts))
+            sizes = (GLsizei * primcount)(*size_list)
+            self._context.glMultiDrawElements(mode, sizes, self.index_stream.gl_type, starts, primcount)
+        else:
+            for start, size in zip(start_list, size_list):
+                self._context.glDrawElements(
+                    mode, size, self.index_stream.gl_type, start * self.index_stream.index_element_size)
+
+        self.vao.unbind()
+
+    def draw_subset(self, mode: GeometryMode, vertex_list: IndexedVertexList) -> None:
+        """Draw a specific IndexedVertexList in the domain.
+
+        The `vertex_list` parameter specifies a :py:class:`IndexedVertexList`
+        to draw. Only primitives in that list will be drawn.
+
+        Args:
+            mode:
+                OpenGL drawing mode, e.g. ``GL_POINTS``, ``GL_LINES``, etc.
+            vertex_list:
+                Vertex list to draw.
+        """
+        for buffer, attribute in self.buffer_attributes:
+            buffer.commit()
+            attribute.enable()
+            attribute.set_pointer(0)
+
+        self.index_buffer.commit()
+
+        self._context.glDrawElements(geometry_map[mode], vertex_list.index_count, self.index_gl_type,
+                       vertex_list.index_start * self.index_element_size)
+
+        for _, attribute in self.buffer_attributes:
+            attribute.disable()
+
+        self._context.glBindBuffer(GL_ARRAY_BUFFER, 0)

pyglet/graphics/api/webgl/__init__.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import TYPE_CHECKING, Sequence
+
+import js
+
+import pyglet
+from pyglet.graphics.api.webgl.context import OpenGLSurfaceContext
+from pyglet.graphics.api.base import BackendGlobalObject, SurfaceContext, UBOMatrixTransformations
+from pyglet.graphics.api.webgl.shader import Shader, ShaderProgram
+from pyglet.math import Mat4
+
+if TYPE_CHECKING:
+
+    from pyglet.config import SurfaceConfig
+    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 OpenGL3_Matrices(UBOMatrixTransformations):
+    # Create a default ShaderProgram, so the Window instance can
+    # update the `WindowBlock` UBO shared by all default shaders.
+    _default_vertex_source = """#version 300 es
+         in vec4 position;
+
+         uniform WindowBlock
+         {
+             mat4 projection;
+             mat4 view;
+         } window;
+
+         void main()
+         {
+             gl_Position = window.projection * window.view * position;
+         }
+     """
+    _default_fragment_source = """#version 300 es
+         out vec4 color;
+
+         void main()
+         {
+             color = vec4(1.0, 0.0, 0.0, 1.0);
+         }
+     """
+
+    def __init__(self, window: Window, backend: WebGLBackend):
+        self._default_program = backend.create_shader_program(
+            backend.create_shader(self._default_vertex_source, 'vertex'),
+            backend.create_shader(self._default_fragment_source, 'fragment'),
+        )
+
+        window_block = self._default_program.uniform_blocks['WindowBlock']
+        self.ubo = window_block.create_ubo()
+        window_block.bind(self.ubo)
+
+        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())
+
+        with self.ubo as window_block:
+            window_block.view[:] = self._view
+            window_block.projection[:] = self._projection
+
+    @property
+    def projection(self) -> Mat4:
+        return self._projection
+
+    @projection.setter
+    def projection(self, projection: Mat4):
+        with self.ubo as window_block:
+            window_block.projection[:] = projection
+
+        self._projection = projection
+
+    @property
+    def view(self) -> Mat4:
+        return self._view
+
+    @view.setter
+    def view(self, view: Mat4):
+        with self.ubo as window_block:
+            window_block.view[:] = view
+
+        self._view = view
+
+    @property
+    def model(self) -> Mat4:
+        return self._model
+
+    @model.setter
+    def model(self, model: Mat4):
+        with self.ubo as window_block:
+            window_block.model[:] = model
+
+        self._model = model
+
+
+class ObjectSpace:
+    """A container to store shared objects that are to be removed."""
+
+    def __init__(self) -> None:
+        """Initialize the context object space."""
+        # Objects scheduled for deletion the next time this object space is active.
+        self.doomed_textures = []
+        self.doomed_buffers = []
+        self.doomed_shader_programs = []
+        self.doomed_shaders = []
+        self.doomed_renderbuffers = []
+
+
+class WebGLBackend(BackendGlobalObject):
+    current_context: OpenGLSurfaceContext | None
+    _have_context: bool = False
+
+    def __init__(self) -> None:
+        self.initialized = False
+        self.current_context = None
+
+        # When the shadow window is created, a context is made. This is used to help the "real" context to utilize
+        # its full capabilities; however, the two contexts have no relationship normally. This is used for the purpose
+        # of sharing basic information between contexts. However, in usage, the user or internals should use the
+        # "real" context's information to prevent any discrepencies.
+        # self.gl_info = GLInfo()  # GL Info is a shared info space.
+        super().__init__()
+
+    @property
+    def object_space(self) -> ObjectSpace:
+        assert self.current_context is not None, "Context has not been created."
+        return self.current_context.object_space
+
+    def create_context(self, config: SurfaceConfig, shared: OpenGLSurfaceContext | None) -> OpenGLSurfaceContext:
+        return OpenGLSurfaceContext(self, config._window, config, shared)
+
+    def get_surface_context(self, window: Window, config: SurfaceConfig) -> SurfaceContext:
+        context = self.windows[window] = self.create_context(config, self.current_context)
+        self.current_context = context
+        self._have_context = True
+        return context
+
+    # def get_window_backend_context(self, window: Window, config: OpenGLWindowConfig) -> SurfaceContext:
+    #     """We will always only have one context in this Backend."""
+    #     assert self.current_context is None
+    #     context = self.windows[window] = self.create_context(config, self.current_context)
+    #     self.current_context = context
+    #     self._have_context = True
+    #     return context
+
+    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=3, minor_version=3),
+            pyglet.config.OpenGLConfig(double_buffer=True, depth_size=16, major_version=3, minor_version=3),
+        ]
+
+    def get_config(self, **kwargs: float | str | None) -> pyglet.config.OpenGLConfig:
+        return pyglet.config.OpenGLConfig(**kwargs)
+
+    def get_info(self):
+        return self.current_context.get_info()
+
+    def have_extension(self, extension_name: str) -> bool:
+        if not self.current_context:
+            warnings.warn('No GL context created yet or current context not set.')
+            return False
+
+        return self.current_context.get_info().have_extension(extension_name)
+
+    def have_version(self, major: int, minor: int = 0) -> bool:
+        if not self.current_context:
+            warnings.warn('No GL context created yet or current context not set.')
+            return False
+
+        return self.current_context.get_info().have_version(major, minor)
+
+    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.shader.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.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
+        return program
+
+    def create_shader_program(self, *shaders: Shader) -> ShaderProgram:
+        return ShaderProgram(*shaders)
+
+    def create_shader(self, source_string: str, shader_type: ShaderType) -> Shader:
+        return Shader(source_string, shader_type)
+
+    def get_default_batch(self) -> pyglet.graphics.Batch:
+        assert self.current_context
+        if not hasattr(self.current_context, "default_batch"):
+            self.current_context.default_batch = pyglet.graphics.Batch()
+
+        return self.current_context.default_batch
+
+    @property
+    def have_context(self) -> bool:
+        return self._have_context
+
+    def initialize_matrices(self, window):
+        return OpenGL3_Matrices(window, self)
+
+    def set_viewport(self, window, x: int, y: int, width: int, height: int) -> None:
+        self.current_context.gl.viewport(x, y, width, height)