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

pyglet/graphics/api/webgl/buffer.py

@@ -0,0 +1,302 @@
+"""OpenGL Buffer Objects.
+
+:py:class:`~BufferObject` and a :py:class:`~BackedBufferObject` are provied.
+The first is a lightweight abstraction over an OpenGL buffer, as created
+with ``glGenBuffers``. The backed buffer object is similar, but provides a
+full mirror of the data in CPU memory. This allows for delayed uploading of
+changes to GPU memory, which can improve performance is some cases.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import sys
+from functools import lru_cache
+from typing import TYPE_CHECKING, Sequence
+
+import js
+import pyodide.ffi
+
+import pyglet
+from pyglet.customtypes import CType, CTypesPointer
+from pyglet.graphics.api.webgl.gl import (
+    GL_ARRAY_BUFFER,
+    GL_BUFFER_SIZE,
+    GL_DYNAMIC_DRAW,
+    GL_ELEMENT_ARRAY_BUFFER,
+    GL_MAP_COHERENT_BIT,
+    GL_MAP_PERSISTENT_BIT,
+    GL_MAP_READ_BIT,
+    GL_MAP_WRITE_BIT,
+    GL_WRITE_ONLY,
+)
+from pyglet.graphics.buffer import AbstractBuffer
+
+if TYPE_CHECKING:
+    from _ctypes import Array
+
+    from pyglet.graphics.api.webgl import OpenGLSurfaceContext
+    from pyglet.graphics.api.webgl.webgl_js import WebGLBuffer
+    from pyglet.graphics.shader import Attribute, GraphicsAttribute
+
+
+class BufferObject(AbstractBuffer):
+    """Lightweight representation of an OpenGL Buffer Object.
+
+    The data in the buffer is not replicated in any system memory (unless it
+    is done so by the video driver).  While this can reduce system memory usage,
+    performing multiple small updates to the buffer can be relatively slow.
+    The target of the buffer is ``GL_ARRAY_BUFFER`` internally to avoid
+    accidentally overriding other states when altering the buffer contents.
+    The intended target can be set when binding the buffer.
+    """
+
+    id: WebGLBuffer
+    usage: int
+    target: int
+    _context: OpenGLSurfaceContext | None
+
+    def __init__(self, context: OpenGLSurfaceContext, size: int, target: int = GL_ARRAY_BUFFER,
+                 usage: int = GL_DYNAMIC_DRAW) -> None:
+        """Initialize the BufferObject with the given size and draw usage.
+
+        JS does not allow to directly map memory, so all of them must be backed.
+        """
+        super().__init__('b', size)
+        self.usage = usage
+        self.target = target
+        self._context = context
+        self._gl = self._context.gl
+
+        self.id = self._gl.createBuffer()
+
+        self._gl.bindBuffer(self.target, self.id)
+        self._gl.bufferData(self.target, self.size, self.usage)
+
+    def get_bytes(self) -> bytes: ...
+
+    def get_bytes_region(self, offset: int, length: int) -> bytes: ...
+
+    def get_data_region(self, start: int, length: int) -> ctypes.Array[CType]: ...
+
+    def set_bytes(self, data: bytes) -> None: ...
+
+    def set_bytes_region(self, start: int, length: int) -> None: ...
+
+    def set_data_ptr(self, offset: int, length: int, ptr: CTypesPointer) -> None: ...
+
+    def get_buffer_size(self):
+        return self._gl.getBufferParameter(self.target, GL_BUFFER_SIZE)
+
+    def invalidate(self) -> None:
+        self._gl.bufferData(self.target, None, self.usage)
+
+    def bind(self) -> None:
+        self._gl.bindBuffer(self.target, self.id)
+
+    def unbind(self) -> None:
+        self._gl.bindBuffer(self.target, 0)
+
+    def get_data(self) -> ctypes.Array[CType]:
+        data = js.Uint8Array.new(self.size)
+        self._gl.bindBuffer(self.target, self.id)
+        self._gl.getBufferSubData(self.target, 0, data)
+        py_buffer = data.buffer.to_py(depth=1)
+        return bytes(py_buffer)
+
+    def set_data(self, data: Sequence[int] | CTypesPointer) -> None:
+        byte_data = ctypes.string_at(data, ctypes.sizeof(data.contents))
+        buffer = pyodide.ffi.to_js(memoryview(byte_data))
+        js_array = js.Uint8Array.new(buffer)
+        self._gl.bindBuffer(self.target, self.id)
+        self._gl.bufferData(self.target, js_array, self.usage)
+
+    def set_data_region(self, data: Sequence[int] | CTypesPointer, start: int, length: int) -> None:
+        self._gl.bindBuffer(self.target, self.id)
+        self._gl.bufferSubData(self.target, start, data)
+
+    def map(self, bits=GL_WRITE_ONLY) -> CTypesPointer[ctypes.c_byte]:
+        raise NotImplementedError()
+
+    def map_range(self, start: int, size: int, ptr_type: type[CTypesPointer], bits=GL_MAP_WRITE_BIT) -> CTypesPointer:
+        raise NotImplementedError()
+
+    def unmap(self) -> None:
+        raise NotImplementedError()
+
+    def delete(self) -> None:
+        self._gl.deleteBuffer(self.id)
+        self.id = None
+
+    def __del__(self) -> None:
+        if self.id is not None:
+            try:
+                self._context.delete_buffer(self.id)
+                self.id = None
+            except (AttributeError, ImportError):
+                pass  # Interpreter is shutting down
+
+    def resize(self, size: int) -> None:
+        # Map, create a copy, then reinitialize.
+        temp = (ctypes.c_byte * size)()
+
+        self._gl.bindBuffer(self.target, self.id)
+        data = glMapBufferRange(self.target, 0, self.size, GL_MAP_READ_BIT)
+        ctypes.memmove(temp, data, min(size, self.size))
+        glUnmapBuffer(self.target)
+
+        self.size = size
+        self._gl.bufferData(self.target, self.size, temp, self.usage)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={self.id}, data_type={self.data_type}, size={self.size})"
+
+
+class BackedBufferObject(BufferObject):
+    """A buffer with system-memory backed store.
+
+    Updates to the data via ``set_data`` and ``set_data_region`` will be held
+    in system memory until ``commit`` is called.  The advantage is that fewer
+    OpenGL calls are needed, which can increase performance at the expense of
+    system memory.
+    """
+
+    data: CType
+    data_ptr: int
+    _dirty_min: int
+    _dirty_max: int
+    _dirty: bool
+    stride: int
+    element_count: int
+    ctype: CType
+
+    def __init__(
+        self, context: OpenGLSurfaceContext, size: int, c_type: CType, stride: int, element_count: int,
+            usage: int = GL_DYNAMIC_DRAW, target: int=GL_ARRAY_BUFFER,
+    ) -> None:
+        super().__init__(context, size, target, usage)
+
+        self.c_type = c_type
+        self._ctypes_size = ctypes.sizeof(c_type)
+        number = size // self._ctypes_size
+        self.data = (c_type * number)()
+        self.data_ptr = ctypes.addressof(self.data)
+
+        self._dirty_min = sys.maxsize
+        self._dirty_max = 0
+        self._dirty = False
+
+        self.stride = stride
+        self.element_count = element_count
+
+    def commit(self) -> None:
+        """Commits all saved changes to the underlying buffer before drawing.
+
+        Allows submitting multiple changes at once, rather than having to call glBufferSubData for every change.
+        """
+        if not self._dirty:
+            return
+
+        self._gl.bindBuffer(self.target, self.id)
+        size = self._dirty_max - self._dirty_min
+        if size > 0:
+            if size == self.size:
+                byte_data = ctypes.string_at(self.data_ptr, self.size)
+                buffer = pyodide.ffi.to_js(memoryview(byte_data))
+                js_array = js.Uint8Array.new(buffer)
+                self._gl.bufferData(self.target, js_array, self.usage)
+            else:
+                byte_data = ctypes.string_at(self.data_ptr + self._dirty_min, size)
+                buffer = pyodide.ffi.to_js(memoryview(byte_data))
+                js_array = js.Uint8Array.new(buffer)
+
+                self._gl.bufferSubData(self.target, self._dirty_min, js_array)
+
+            self._dirty_min = sys.maxsize
+            self._dirty_max = 0
+            self._dirty = False
+
+    @lru_cache(maxsize=None)  # noqa: B019
+    def get_region(self, start: int, count: int) -> Array[CType]:
+        byte_start = self.stride * start  # byte offset
+        array_count = self.element_count * count  # number of values
+        ptr_type = ctypes.POINTER(self.c_type * array_count)
+        return ctypes.cast(self.data_ptr + byte_start, ptr_type).contents
+
+    def set_region(self, start: int, count: int, data: Sequence[float]) -> None:
+        array_start = self.element_count * start
+        array_end = self.element_count * count + array_start
+
+        self.data[array_start:array_end] = data
+
+        # replicated from self.invalidate_region
+        byte_start = self.stride * start
+        byte_end = byte_start + self.stride * count
+        # As of Python 3.11, this is faster than min/max:
+        if byte_start < self._dirty_min:
+            self._dirty_min = byte_start
+        if byte_end > self._dirty_max:
+            self._dirty_max = byte_end
+        self._dirty = True
+
+    def resize(self, size: int) -> None:
+        # size is the allocator size * attribute.stride
+        number = size // ctypes.sizeof(self.c_type)
+        data = (self.c_type * number)()
+        ctypes.memmove(data, self.data, min(size, self.size))
+        self.data = data
+        self.data_ptr = ctypes.addressof(data)
+        self.size = size
+
+        # Set the dirty range to be the entire buffer.
+        self._dirty_min = 0
+        self._dirty_max = self.size
+        self._dirty = True
+
+        self.get_region.cache_clear()
+
+    def invalidate(self) -> None:
+        super().invalidate()
+        self._dirty = True
+
+    def invalidate_region(self, start: int, count: int) -> None:
+        byte_start = self.stride * start
+        byte_end = byte_start + self.stride * count
+        # As of Python 3.11, this is faster than min/max:
+        if byte_start < self._dirty_min:
+            self._dirty_min = byte_start
+        if byte_end > self._dirty_max:
+            self._dirty_max = byte_end
+        self._dirty = True
+
+
+class AttributeBufferObject(BackedBufferObject):
+    """A backed buffer used for Shader Program attributes."""
+
+    def __init__(self, context: OpenGLSurfaceContext, size: int, graphics_attr: GraphicsAttribute) -> None:
+        # size is the allocator size * attribute.stride (buffer size)
+        super().__init__(context, size, graphics_attr.attribute.c_type,
+                         graphics_attr.view.stride,
+                         graphics_attr.attribute.fmt.components)
+
+
+
+class IndexedBufferObject(BackedBufferObject):
+    """A backed buffer used for indices."""
+
+    def __init__(self, context: OpenGLSurfaceContext, size: int, c_type: CType, stride: int, element_count: int,
+                 usage: int = GL_DYNAMIC_DRAW) -> None:
+        super().__init__(context, size, c_type, stride, element_count, usage, GL_ELEMENT_ARRAY_BUFFER)
+
+    def bind_to_index_buffer(self) -> None:
+        """Binds this buffer as an index buffer on the active vertex array."""
+        self._gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.id)
+
+
+class PersistentBufferObject(BackedBufferObject):
+    """A persistently mapped buffer.
+
+    Available in OpenGL 4.3+ contexts. Persistently mapped buffers
+    are mapped one time on creation, and can be updated at any time
+    without the need to map or unmap.
+    """

pyglet/graphics/api/webgl/context.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import weakref
+from typing import TYPE_CHECKING, Any, Callable
+
+import js
+from pyodide.ffi import create_proxy
+
+from pyglet.graphics.api.base import SurfaceContext
+from pyglet.graphics.api.webgl import gl
+from pyglet.graphics.api.webgl.gl import GL_COLOR_BUFFER_BIT
+from pyglet.graphics.api.webgl.gl_info import GLInfo
+from pyglet.graphics.api.webgl.shader import GLDataType
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api import WebGLBackend
+    from pyglet.graphics.api.webgl.config import OpenGLWindowConfig
+    from pyglet.graphics.api.webgl.webgl_js import WebGL2RenderingContext
+    from pyglet.window import Window
+    from pyglet.window.emscripten import EmscriptenWindow
+
+
+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 OpenGLSurfaceContext(SurfaceContext):
+    """A base OpenGL context for drawing.
+
+    Use ``DisplayConfig.create_context`` to create a context.
+    """
+
+    gl: WebGL2RenderingContext
+    config: OpenGLWindowConfig
+    context_share: OpenGLSurfaceContext | None
+
+    def __init__(
+        self,
+        global_ctx: WebGLBackend,
+        window: EmscriptenWindow,
+        config: OpenGLWindowConfig,  # noqa: D417
+        context_share: OpenGLSurfaceContext | None = None,
+    ) -> None:
+        """Initialize a context.
+
+        This should only be created through the ``DisplayConfig.create_context`` method.
+
+        Args:
+            config:
+                An operating system specific config.
+            context_share:
+                A context to share objects with. Use ``None`` to disable sharing.
+        """
+        super().__init__(global_ctx, window, config)
+        self.global_ctx = global_ctx
+        self.window = window
+        self.config = config
+        self.context_share = context_share
+        self.is_current = False
+
+        # The GL Context.
+        self.gl = self.window.canvas.getContext("webgl2")
+
+        self._info = GLInfo()
+        self._info.query(self.gl)
+        self.object_space = ObjectSpace()
+
+        self._draw_proxy = create_proxy(self.window.draw)
+
+        self._clear_color = (0.0, 0.0, 0.0, 1.0)
+
+        self.doomed_vaos = []
+        self.doomed_framebuffers = []
+
+        self.cached_programs = weakref.WeakValueDictionary()
+        self._create_uniform_dicts()
+
+    def get_info(self) -> GLInfo:
+        """Get the :py:class:`~GLInfo` instance for this context."""
+        return self._info
+
+    def resized(self, width, height): ...
+
+    def detach(self):
+        self.context = None
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={id(self)}, share={self.context_share})"
+
+    def __enter__(self) -> None:
+        self.set_current()
+
+    def __exit__(self, *_args) -> None:  # noqa: ANN002
+        return
+
+    def set_clear_color(self, r: float, g: float, b: float, a: float) -> None:
+        self._clear_color = (r, g, b, a)
+
+    def clear(self) -> None:
+        self.gl.clear(GL_COLOR_BUFFER_BIT)
+
+    def flip(self):
+        pass
+
+    def destroy(self) -> None:
+        """Release the Context.
+
+        The context will not be useable after being destroyed.  Each platform
+        has its own convention for releasing the context and the buffer(s)
+        that depend on it in the correct order; this should never be called
+        by an application.
+        """
+        # self.detach()
+        #
+        if self.core.current_context is self:
+            self.core.current_context = None
+        #     #gl_info.remove_active_context()
+
+    def attach(self, window: Window) -> None:
+        # if not self.config.compatible(canvas):
+        #     msg = f'Cannot attach {canvas} to {self}'
+        #     raise RuntimeError(msg)
+        self.window = window
+
+    def before_draw(self) -> None:
+        self.gl.clearColor(*self._clear_color)
+        self.gl.clear(GL_COLOR_BUFFER_BIT)
+
+    def set_current(self) -> None:
+        return
+        """Make this the active Context.
+
+        Setting the Context current will also delete any OpenGL
+        objects that have been queued for deletion. IE: any objects
+        that were created in this Context, but have been called for
+        deletion while another Context was active.
+        """
+        assert self.window is not None, "Window has not been attached."
+
+        # Not per-thread
+        self.global_ctx.current_context = self
+        gl.current_context = self
+
+        # Set active context.
+        # gl_info.set_active_context()
+
+        if not self._info.was_queried:
+            self._info.query()
+
+        if self.object_space.doomed_textures:
+            self._delete_objects(self.object_space.doomed_textures, gl.glDeleteTextures)
+        if self.object_space.doomed_buffers:
+            self._delete_objects(self.object_space.doomed_buffers, gl.glDeleteBuffers)
+        if self.object_space.doomed_shader_programs:
+            self._delete_objects_one_by_one(self.object_space.doomed_shader_programs, gl.glDeleteProgram)
+        if self.object_space.doomed_shaders:
+            self._delete_objects_one_by_one(self.object_space.doomed_shaders, gl.glDeleteShader)
+        if self.object_space.doomed_renderbuffers:
+            self._delete_objects(self.object_space.doomed_renderbuffers, gl.glDeleteRenderbuffers)
+
+        if self.doomed_vaos:
+            self._delete_objects(self.doomed_vaos, gl.glDeleteVertexArrays)
+        if self.doomed_framebuffers:
+            self._delete_objects(self.doomed_framebuffers, gl.glDeleteFramebuffers)
+
+    def _create_uniform_dicts(self) -> None:
+        self._uniform_setters: dict[int, tuple[GLDataType, Callable, int]] = {
+            # uniform: gl_type, setter, length
+            gl.GL_BOOL: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_BOOL_VEC2: (gl.GLint, self.gl.uniform2iv, 2),
+            gl.GL_BOOL_VEC3: (gl.GLint, self.gl.uniform3iv, 3),
+            gl.GL_BOOL_VEC4: (gl.GLint, self.gl.uniform4iv, 4),
+            gl.GL_INT: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_INT_VEC2: (gl.GLint, self.gl.uniform2iv, 2),
+            gl.GL_INT_VEC3: (gl.GLint, self.gl.uniform3iv, 3),
+            gl.GL_INT_VEC4: (gl.GLint, self.gl.uniform4iv, 4),
+            gl.GL_FLOAT: (gl.GLfloat, self.gl.uniform1f, 1),
+            gl.GL_FLOAT_VEC2: (gl.GLfloat, self.gl.uniform2fv, 2),
+            gl.GL_FLOAT_VEC3: (gl.GLfloat, self.gl.uniform3fv, 3),
+            gl.GL_FLOAT_VEC4: (gl.GLfloat, self.gl.uniform4fv, 4),
+            # 1D Samplers
+            gl.GL_SAMPLER_1D: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_SAMPLER_1D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_1D: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_INT_SAMPLER_1D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_1D: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            # 2D Samplers
+            gl.GL_SAMPLER_2D: (gl.GLint, self.gl.uniform1i, 1),
+            gl.GL_SAMPLER_2D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_2D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_2D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_2D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            # Multisample
+            gl.GL_SAMPLER_2D_MULTISAMPLE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_2D_MULTISAMPLE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: (gl.GLint, self.gl.uniform1iv, 1),
+            # Cube Samplers
+            gl.GL_SAMPLER_CUBE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_CUBE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_CUBE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_SAMPLER_CUBE_MAP_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_CUBE_MAP_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            # 3D Samplers
+            gl.GL_SAMPLER_3D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_INT_SAMPLER_3D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_UNSIGNED_INT_SAMPLER_3D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_FLOAT_MAT2: (gl.GLfloat, self.gl.uniformMatrix2fv, 4),
+            gl.GL_FLOAT_MAT3: (gl.GLfloat, self.gl.uniformMatrix3fv, 6),
+            gl.GL_FLOAT_MAT4: (gl.GLfloat, self.gl.uniformMatrix4fv, 16),
+            # Images
+            gl.GL_IMAGE_1D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_2D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_2D_RECT: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_3D: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_1D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_2D_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_2D_MULTISAMPLE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_2D_MULTISAMPLE_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_BUFFER: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_CUBE: (gl.GLint, self.gl.uniform1iv, 1),
+            gl.GL_IMAGE_CUBE_MAP_ARRAY: (gl.GLint, self.gl.uniform1iv, 1),
+        }