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

pyglet/graphics/{vertexbuffer.py → api/gl/buffer.py}

@@ -8,118 +8,31 @@ changes to GPU memory, which can improve performance is some cases.
 """
 from __future__ import annotations
 
-import abc
 import ctypes
 import sys
 from functools import lru_cache
-from typing import TYPE_CHECKING, Sequence, Type
+from typing import TYPE_CHECKING, Sequence
 
-from _ctypes import Array, _Pointer, _SimpleCData
 
-import pyglet
-from pyglet.gl.gl import (
+from pyglet.graphics.api.gl import (
     GL_ARRAY_BUFFER,
     GL_DYNAMIC_DRAW,
     GL_ELEMENT_ARRAY_BUFFER,
-    GL_MAP_READ_BIT,
-    GL_MAP_WRITE_BIT,
     GL_MAP_COHERENT_BIT,
     GL_MAP_PERSISTENT_BIT,
+    GL_MAP_READ_BIT,
+    GL_MAP_WRITE_BIT,
     GL_WRITE_ONLY,
     GLubyte,
     GLuint,
-    glBindBuffer,
-    glBufferData,
-    glBufferStorage,
-    glBufferSubData,
-    glDeleteBuffers,
-    glGenBuffers,
-    glMapBuffer,
-    glMapBufferRange,
-    glUnmapBuffer,
+    OpenGLSurfaceContext,
 )
+from pyglet.graphics.buffer import AbstractBuffer
 
 if TYPE_CHECKING:
-    from pyglet.gl import Context
-    from pyglet.graphics.shader import Attribute
-
-CTypesDataType = Type[_SimpleCData]
-CTypesPointer = _Pointer
-
-
-class AbstractBuffer:
-    """Abstract buffer of byte data.
-
-    Attributes:
-        size:
-            Size of buffer, in bytes
-        ptr:
-            Memory offset of the buffer, as used by the ``glVertexPointer`` family of functions
-    """
-
-    ptr: int = 0
-    size: int = 0
-
-    @abc.abstractmethod
-    def bind(self, target: int = GL_ARRAY_BUFFER) -> None:
-        """Bind this buffer to an OpenGL target."""
-
-    @abc.abstractmethod
-    def unbind(self) -> None:
-        """Reset the buffer's OpenGL target."""
-
-    @abc.abstractmethod
-    def set_data(self, data: Sequence[int] | CTypesPointer) -> None:
-        """Set the entire contents of the buffer.
-
-        Args:
-            data:
-                The byte array to set.
-
-        """
-
-    @abc.abstractmethod
-    def set_data_region(self, data: Sequence[int] | CTypesPointer, start: int, length: int) -> None:
-        """Set part of the buffer contents.
-
-        Args:
-            data:
-                The byte array of data to set
-            start:
-                Offset to start replacing data
-            length:
-                Length of region to replace
-
-        """
-
-    @abc.abstractmethod
-    def map(self) -> CTypesPointer[ctypes.c_ubyte]:
-        """Map the entire buffer into system memory.
-
-        The mapped region must be subsequently unmapped with `unmap` before
-        performing any other operations on the buffer.
-
-        Returns:
-            Pointer to the mapped block in memory
-        """
-
-    @abc.abstractmethod
-    def unmap(self) -> None:
-        """Unmap a previously mapped memory block."""
-
-    def resize(self, size: int) -> None:
-        """Resize the buffer to a new size.
-
-        Args:
-            size:
-                New size of the buffer, in bytes
-
-        """
-
-    @abc.abstractmethod
-    def delete(self) -> None:
-        """Delete this buffer, reducing system resource usage."""
-
+    from pyglet.customtypes import CType, CTypesPointer
+    from pyglet.graphics.shader import Attribute, GraphicsAttribute
+    from ctypes import Array, _SimpleCData
 
 class BufferObject(AbstractBuffer):
     """Lightweight representation of an OpenGL Buffer Object.
@@ -133,62 +46,88 @@ class BufferObject(AbstractBuffer):
     """
 
     id: int
-    size: int
     usage: int
-    _context: Context | None
+    target: int
+    _context: OpenGLSurfaceContext | None
 
-    def __init__(self, size: int, usage: int = GL_DYNAMIC_DRAW) -> None:
+    def __init__(self, context: OpenGLSurfaceContext, size: int, target = GL_ARRAY_BUFFER, usage: int = GL_DYNAMIC_DRAW) -> None:
         """Initialize the BufferObject with the given size and draw usage.
 
         Buffer data is cleared on creation.
         """
-        self.size = size
+        super().__init__('b', size)
         self.usage = usage
-        self._context = pyglet.gl.current_context
+        self.target = target
+        self._context = context
 
         buffer_id = GLuint()
-        glGenBuffers(1, buffer_id)
+        self._context.glGenBuffers(1, buffer_id)
         self.id = buffer_id.value
 
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
+        self._context.glBindBuffer(self.target, self.id)
         data = (GLubyte * self.size)()
-        glBufferData(GL_ARRAY_BUFFER, self.size, data, self.usage)
+        self._context.glBufferData(self.target, self.size, data, self.usage)
+
+    def get_bytes(self) -> bytes:
+        self._context.glBindBuffer(self.target, self.id)
+        ptr = self._context.glMapBufferRange(self.target, 0, self.size, GL_MAP_READ_BIT)
+        data = ctypes.string_at(ptr, size=self.size)
+        self._context.glUnmapBuffer(self.target)
+        return data
+
+    def get_bytes_region(self, offset: int, length: int) -> bytes:
+        ...
+
+    def get_data(self) -> ctypes.Array[CType]:
+        self._context.glBindBuffer(self.target, self.id)
+        ptr = self._context.glMapBufferRange(self.target, 0, self.size, GL_MAP_READ_BIT)
+        data = ctypes.string_at(ptr, size=self.size)
+        self._context.glUnmapBuffer(self.target)
+        return data
+
+    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 invalidate(self) -> None:
-        glBufferData(GL_ARRAY_BUFFER, self.size, None, self.usage)
+        self._context.glBufferData(self.target, self.size, None, self.usage)
 
-    def bind(self, target: int = GL_ARRAY_BUFFER) -> None:
-        glBindBuffer(target, self.id)
+    def bind(self) -> None:
+        self._context.glBindBuffer(self.target, self.id)
 
     def unbind(self) -> None:
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-
-    def bind_to_index_buffer(self) -> None:
-        """Binds this buffer as an index buffer on the active vertex array."""
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.id)
+        self._context.glBindBuffer(self.target, 0)
 
     def set_data(self, data: Sequence[int] | CTypesPointer) -> None:
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        glBufferData(GL_ARRAY_BUFFER, self.size, data, self.usage)
+        self._context.glBindBuffer(self.target, self.id)
+        self._context.glBufferData(self.target, self.size, data, self.usage)
 
     def set_data_region(self, data: Sequence[int] | CTypesPointer, start: int, length: int) -> None:
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        glBufferSubData(GL_ARRAY_BUFFER, start, length, data)
+        self._context.glBindBuffer(self.target, self.id)
+        self._context.glBufferSubData(self.target, start, length, data)
 
-    def map(self) -> CTypesPointer[ctypes.c_byte]:
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        return ctypes.cast(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY),
+    def map(self, bits=GL_WRITE_ONLY) -> CTypesPointer[ctypes.c_byte]:
+        self._context.glBindBuffer(self.target, self.id)
+        return ctypes.cast(self._context.glMapBuffer(self.target, bits),
                            ctypes.POINTER(ctypes.c_byte * self.size)).contents
 
-    def map_range(self, start: int, size: int, ptr_type: type[CTypesPointer]) -> CTypesPointer:
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        return ctypes.cast(glMapBufferRange(GL_ARRAY_BUFFER, start, size, GL_MAP_WRITE_BIT), ptr_type).contents
+    def map_range(self, start: int, size: int, ptr_type: type[CTypesPointer], bits=GL_MAP_WRITE_BIT) -> CTypesPointer:
+        self._context.glBindBuffer(self.target, self.id)
+        return ctypes.cast(self._context.glMapBufferRange(self.target, start, size, bits), ptr_type).contents
 
     def unmap(self) -> None:
-        glUnmapBuffer(GL_ARRAY_BUFFER)
+        self._context.glUnmapBuffer(self.target)
 
     def delete(self) -> None:
-        glDeleteBuffers(1, GLuint(self.id))
+        self._context.glDeleteBuffers(1, GLuint(self.id))
         self.id = None
 
     def __del__(self) -> None:
@@ -203,16 +142,16 @@ class BufferObject(AbstractBuffer):
         # Map, create a copy, then reinitialize.
         temp = (ctypes.c_byte * size)()
 
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
-        data = glMapBufferRange(GL_ARRAY_BUFFER, 0, self.size, GL_MAP_READ_BIT)
+        self._context.glBindBuffer(self.target, self.id)
+        data = self._context.glMapBufferRange(self.target, 0, self.size, GL_MAP_READ_BIT)
         ctypes.memmove(temp, data, min(size, self.size))
-        glUnmapBuffer(GL_ARRAY_BUFFER)
+        self._context.glUnmapBuffer(self.target)
 
         self.size = size
-        glBufferData(GL_ARRAY_BUFFER, self.size, temp, self.usage)
+        self._context.glBufferData(self.target, self.size, temp, self.usage)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(id={self.id}, size={self.size})"
+        return f"{self.__class__.__name__}(id={self.id}, data_type={self.data_type}, size={self.size})"
 
 
 class BackedBufferObject(BufferObject):
@@ -223,18 +162,18 @@ class BackedBufferObject(BufferObject):
     OpenGL calls are needed, which can increase performance at the expense of
     system memory.
     """
-    data: CTypesDataType
+    data: Array[CType] | Array[_SimpleCData]
     data_ptr: int
     _dirty_min: int
     _dirty_max: int
     _dirty: bool
     stride: int
-    count: int
-    ctype: CTypesDataType
+    element_count: int
+    ctype: CType
 
-    def __init__(self, size: int, c_type: CTypesDataType, stride: int, count: int,  # noqa: D107
+    def __init__(self, context: OpenGLSurfaceContext, size: int, c_type: CType, stride: int, element_count: int,
                  usage: int = GL_DYNAMIC_DRAW) -> None:
-        super().__init__(size, usage)
+        super().__init__(context, size, GL_ARRAY_BUFFER, usage)
 
         self.c_type = c_type
         self._ctypes_size = ctypes.sizeof(c_type)
@@ -247,7 +186,7 @@ class BackedBufferObject(BufferObject):
         self._dirty = False
 
         self.stride = stride
-        self.count = count
+        self.element_count = element_count
 
     def commit(self) -> None:
         """Commits all saved changes to the underlying buffer before drawing.
@@ -257,28 +196,28 @@ class BackedBufferObject(BufferObject):
         if not self._dirty:
             return
 
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
+        self._context.glBindBuffer(self.target, self.id)
         size = self._dirty_max - self._dirty_min
         if size > 0:
             if size == self.size:
-                glBufferData(GL_ARRAY_BUFFER, self.size, self.data, self.usage)
+                self._context.glBufferData(self.target, self.size, self.data, self.usage)
             else:
-                glBufferSubData(GL_ARRAY_BUFFER, self._dirty_min, size, self.data_ptr + self._dirty_min)
+                self._context.glBufferSubData(self.target, self._dirty_min, size, self.data_ptr + self._dirty_min)
 
             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[CTypesDataType]:
+    def get_region(self, start: int, count: int) -> Array[CType]:
         byte_start = self.stride * start  # byte offset
-        array_count = self.count * count  # number of values
+        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.count * start
-        array_end = self.count * count + array_start
+        array_start = self.element_count * start
+        array_end = self.element_count * count + array_start
 
         self.data[array_start:array_end] = data
 
@@ -326,17 +265,23 @@ class BackedBufferObject(BufferObject):
 class AttributeBufferObject(BackedBufferObject):
     """A backed buffer used for Shader Program attributes."""
 
-    def __init__(self, size: int, attribute: Attribute) -> None:  # noqa: D107
+    def __init__(self, context: OpenGLSurfaceContext, size: int, graphics_attr: GraphicsAttribute) -> None:
         # size is the allocator size * attribute.stride (buffer size)
-        super().__init__(size, attribute.c_type, attribute.stride, attribute.count)
+        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, size: int, c_type: CTypesDataType, stride: int, count: int,  # noqa: D107
+    def __init__(self, context: OpenGLSurfaceContext, size: int, c_type: CType, stride: int, count: int,
                  usage: int = GL_DYNAMIC_DRAW) -> None:
-        super().__init__(size, c_type, stride, count, usage)
+        super().__init__(context, size, c_type, stride, count, usage)
+
+    def bind_to_index_buffer(self) -> None:
+        """Binds this buffer as an index buffer on the active vertex array."""
+        self._context.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.id)
 
 
 class PersistentBufferObject(AbstractBuffer):
@@ -347,7 +292,7 @@ class PersistentBufferObject(AbstractBuffer):
     without the need to map or unmap.
     """
 
-    def __init__(self, size, attribute, vao):
+    def __init__(self, context, size, attribute, vao):
         # TODO: Persistent buffers cannot be resized. A new buffer is created, and the
         #       data is copied over. Therefore, unlike other buffers, they currently
         #       require s reference to an attribute so the attribute pointer can be reset
@@ -356,25 +301,25 @@ class PersistentBufferObject(AbstractBuffer):
         self.size = size
         self.attribute = attribute
         self.attribute_stride = attribute.stride
-        self.attribute_count = attribute.count
+        self.attribute_count = attribute.element_count
         self.attribute_ctype = attribute.c_type
         self.vao = vao
 
-        self._context = pyglet.gl.current_context
+        self._context = context
 
         buffer_id = GLuint()
-        glGenBuffers(1, buffer_id)
+        self._context.glGenBuffers(1, buffer_id)
         self.id = buffer_id.value
-        glBindBuffer(GL_ARRAY_BUFFER, self.id)
+        self._context.glBindBuffer(GL_ARRAY_BUFFER, self.id)
 
         self.flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT
         data = (GLubyte * size)()
-        glBufferStorage(GL_ARRAY_BUFFER, size, data, self.flags)
+        self._context.glBufferStorage(GL_ARRAY_BUFFER, size, data, self.flags)
 
         # size is the allocator size * attribute.stride
         number = size // attribute.element_size
         ptr = ctypes.POINTER(attribute.c_type * number)
-        self.data = ctypes.cast(glMapBufferRange(GL_ARRAY_BUFFER, 0, size, self.flags), ptr).contents
+        self.data = ctypes.cast(self._context.glMapBufferRange(GL_ARRAY_BUFFER, 0, size, self.flags), ptr).contents
 
     def set_data(self, data: Sequence[int] | CTypesPointer) -> None:
         raise NotImplementedError("Not yet implemented")
@@ -383,10 +328,10 @@ class PersistentBufferObject(AbstractBuffer):
         raise NotImplementedError("Not yet implemented")
 
     def bind(self, target=GL_ARRAY_BUFFER):
-        glBindBuffer(target, self.id)
+        self._context.glBindBuffer(target, self.id)
 
     def unbind(self):
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        self._context.glBindBuffer(GL_ARRAY_BUFFER, 0)
 
     def map(self) -> CTypesPointer[ctypes.c_ubyte]:
         raise NotImplementedError("PersistentBufferObjects are always mapped.")
@@ -398,7 +343,7 @@ class PersistentBufferObject(AbstractBuffer):
         raise NotImplementedError("PersistentBufferObjects cannot be unmapped.")
 
     def delete(self) -> None:
-        glDeleteBuffers(1, GLuint(self.id))
+        self._context.glDeleteBuffers(1, GLuint(self.id))
         self.id = None
 
     @lru_cache(maxsize=None)
@@ -418,11 +363,11 @@ class PersistentBufferObject(AbstractBuffer):
         # Create temporary copy of current data
         temp = (GLubyte * size)()
         ctypes.memmove(temp, self.data, min(size, self.size))
-        glDeleteBuffers(1, GLuint(self.id))
+        self._context.glDeleteBuffers(1, GLuint(self.id))
 
         # Generate new buffer
         buffer_id = GLuint()
-        glGenBuffers(1, buffer_id)
+        self._context.glGenBuffers(1, buffer_id)
         self.id = buffer_id.value
 
         # Link attributes to new buffer:
@@ -432,7 +377,7 @@ class PersistentBufferObject(AbstractBuffer):
         self.attribute.set_pointer(self.ptr)
 
         # Initialize the new buffer with the old data, and map it:
-        glBufferStorage(GL_ARRAY_BUFFER, size, temp, self.flags)
+        self._context.glBufferStorage(GL_ARRAY_BUFFER, size, temp, self.flags)
 
         ptr_type = self.attribute.c_type * (size // self.attribute.element_size)
         self.data = self.map_range(0, size, ctypes.POINTER(ptr_type), self.flags)

pyglet/graphics/api/gl/cocoa/context.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from ctypes import byref, c_int
+from typing import TYPE_CHECKING
+
+from pyglet.config.gl.macos import os_x_release, _os_x_version, CocoaGLSurfaceConfig
+from pyglet.graphics.api.gl.base import ContextException
+from pyglet.graphics.api.gl import OpenGLSurfaceContext
+from pyglet.libs.darwin import cocoapy
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.global_opengl import OpenGLBackend
+    from pyglet.window.cocoa import CocoaWindow
+
+NSOpenGLPixelFormat = cocoapy.ObjCClass('NSOpenGLPixelFormat')
+NSOpenGLContext = cocoapy.ObjCClass('NSOpenGLContext')
+
+
+class CocoaContext(OpenGLSurfaceContext):
+
+    def __init__(self,
+                 opengl_backend: OpenGLBackend,
+                 window: CocoaWindow,
+                 config: CocoaGLSurfaceConfig,
+                 nscontext: NSOpenGLContext,
+                 share: CocoaContext | None) -> None:
+        super().__init__(opengl_backend, window, config, platform_info=None, context_share=share)
+        self.config = config
+        self._nscontext = nscontext
+
+    def attach(self, window: CocoaWindow) -> None:
+        # See if we want OpenGL 3 in a non-Lion OS
+        if _os_x_version < os_x_release['lion']:
+            msg = 'OpenGL 3 not supported'
+            raise ContextException(msg)
+
+        super().attach(window)
+        # The NSView instance should be attached to a nondeferred window before calling
+        # setView, otherwise you get an "invalid drawable" message.
+        self._nscontext.setView_(window._nsview)  # noqa: SLF001
+
+        self.set_current()
+
+    def detach(self) -> None:
+        super().detach()
+        self._nscontext.clearDrawable()
+
+    def set_current(self) -> None:
+        self._nscontext.makeCurrentContext()
+        super().set_current()
+
+    def update_geometry(self) -> None:
+        # Need to call this method whenever the context drawable (an NSView)
+        # changes size or location.
+        self._nscontext.update()
+
+    def set_full_screen(self) -> None:
+        self._nscontext.makeCurrentContext()
+        self._nscontext.setFullScreen()
+
+    def destroy(self) -> None:
+        super().destroy()
+        self._nscontext.release()
+        self._nscontext = None
+
+    def set_vsync(self, vsync: bool = True) -> None:
+        vals = c_int(vsync)
+        self._nscontext.setValues_forParameter_(byref(vals), cocoapy.NSOpenGLCPSwapInterval)
+
+    def get_vsync(self) -> bool:
+        vals = c_int()
+        self._nscontext.getValues_forParameter_(byref(vals), cocoapy.NSOpenGLCPSwapInterval)
+        return bool(vals.value)
+
+    def flip(self) -> None:
+        self._nscontext.flushBuffer()