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

pyglet/graphics/api/webgl/webgl_js.pyi

@@ -0,0 +1,307 @@
+# WebGL object types
+from typing import Any, Sequence
+
+class WebGLShader: ...
+class WebGLProgram: ...
+class WebGLBuffer: ...
+class WebGLTexture: ...
+class WebGLFramebuffer: ...
+class WebGLRenderbuffer: ...
+class WebGLUniformLocation: ...
+class WebGLActiveInfo:
+    name: str
+    size: int
+    type: int
+class WebGLQuery: ...
+class WebGLSampler: ...
+class WebGLSync: ...
+class WebGLTransformFeedback: ...
+class WebGLVertexArrayObject: ...
+
+class WebGLRenderingContext:
+    # --- Texture State ---
+    def activeTexture(self, texture: int) -> None: ...
+
+    # --- Shader Functions ---
+    def createShader(self, shaderType: int) -> WebGLShader | None: ...
+    def shaderSource(self, shader: WebGLShader, source: str) -> None: ...
+    def compileShader(self, shader: WebGLShader) -> None: ...
+    def getShaderParameter(self, shader: WebGLShader, pname: int) -> Any: ...
+    def getShaderInfoLog(self, shader: WebGLShader) -> str: ...
+    def getShaderSource(self, shader: WebGLShader) -> str: ...
+    def deleteShader(self, shader: WebGLShader | None) -> None: ...
+
+    # --- Program Functions ---
+    def createProgram(self) -> WebGLProgram | None: ...
+    def attachShader(self, program: WebGLProgram, shader: WebGLShader) -> None: ...
+    def detachShader(self, program: WebGLProgram, shader: WebGLShader) -> None: ...
+    def linkProgram(self, program: WebGLProgram) -> None: ...
+    def useProgram(self, program: WebGLProgram | None) -> None: ...
+    def getProgramParameter(self, program: WebGLProgram, pname: int) -> Any: ...
+    def getProgramInfoLog(self, program: WebGLProgram) -> str: ...
+    def getAttachedShaders(self, program: WebGLProgram) -> list[WebGLShader]: ...
+    def getActiveAttrib(self, program: WebGLProgram, index: int) -> WebGLActiveInfo | None: ...
+    def getActiveUniform(self, program: WebGLProgram, index: int) -> WebGLActiveInfo | None: ...
+    def getUniformLocation(self, program: WebGLProgram, name: str) -> WebGLUniformLocation | None: ...
+    def getUniform(self, program: WebGLProgram, location: WebGLUniformLocation) -> Any: ...
+    def deleteProgram(self, program: WebGLProgram | None) -> None: ...
+
+    # --- Buffer Functions ---
+    def createBuffer(self) -> WebGLBuffer | None: ...
+    def bindBuffer(self, target: int, buffer: WebGLBuffer | None) -> None: ...
+    def bufferData(self, target: int, data: int | bytes | Sequence[float] | memoryview, usage: int) -> None: ...
+    def bufferSubData(self, target: int, offset: int, data: bytes | Sequence[float] | memoryview) -> None: ...
+    def deleteBuffer(self, buffer: WebGLBuffer | None) -> None: ...
+    def getBufferParameter(self, target: int, pname: int) -> Any: ...
+
+    # --- Texture Functions ---
+    def createTexture(self) -> WebGLTexture | None: ...
+    def bindTexture(self, target: int, texture: WebGLTexture | None) -> None: ...
+    def texImage2D(
+        self, target: int, level: int, internalformat: int,
+        width: int, height: int, border: int,
+        format: int, type: int, pixels: bytes | memoryview | None = None,
+    ) -> None: ...
+    def texImage2D(
+        self, target: int, level: int, internalformat: int,
+        format: int, type: int, source: Any,
+    ) -> None: ...  # Overload for image sources
+    def texSubImage2D(
+        self, target: int, level: int, xoffset: int, yoffset: int,
+        width: int, height: int, format: int, type: int,
+        pixels: bytes | memoryview | None = None,
+    ) -> None: ...
+    def texSubImage2D(
+        self, target: int, level: int, xoffset: int, yoffset: int,
+        format: int, type: int, source: Any,
+    ) -> None: ...  # Overload for image sources
+    def texParameterf(self, target: int, pname: int, param: float) -> None: ...
+    def texParameteri(self, target: int, pname: int, param: int) -> None: ...
+    def compressedTexImage2D(
+            self, target: int, level: int, internalformat: int,
+            width: int, height: int, border: int, pixels: bytes | memoryview | None = None,
+    ) -> None: ...
+    def generateMipmap(self, target: int) -> None: ...
+    def deleteTexture(self, texture: WebGLTexture | None) -> None: ...
+    def getTexParameter(self, target: int, pname: int) -> Any: ...
+
+    # --- Renderbuffer Functions ---
+    def createRenderbuffer(self) -> WebGLRenderbuffer | None: ...
+    def bindRenderbuffer(self, target: int, renderbuffer: WebGLRenderbuffer | None) -> None: ...
+    def renderbufferStorage(self, target: int, internalformat: int, width: int, height: int) -> None: ...
+    def renderbufferStorageMultisample(self, target: int, samples: int, internalformat: int, width: int, height: int) -> None: ...
+    def deleteRenderbuffer(self, renderbuffer: WebGLRenderbuffer | None) -> None: ...
+    def getRenderbufferParameter(self, target: int, pname: int) -> Any: ...
+
+    # --- Framebuffer Functions ---
+    def createFramebuffer(self) -> WebGLFramebuffer | None: ...
+    def bindFramebuffer(self, target: int, framebuffer: WebGLFramebuffer | None) -> None: ...
+    def framebufferRenderbuffer(self, target: int, attachment: int, renderbuffertarget: int, renderbuffer: WebGLRenderbuffer | None) -> None: ...
+    def framebufferTexture2D(self, target: int, attachment: int, textarget: int, texture: WebGLTexture | None, level: int) -> None: ...
+    def checkFramebufferStatus(self, target: int) -> int: ...
+    def deleteFramebuffer(self, framebuffer: WebGLFramebuffer | None) -> None: ...
+    def getFramebufferAttachmentParameter(self, target: int, attachment: int, pname: int) -> Any: ...
+
+    # --- State and Misc Functions ---
+    def clear(self, mask: int) -> None: ...
+    def clearColor(self, red: float, green: float, blue: float, alpha: float) -> None: ...
+    def clearDepth(self, depth: float) -> None: ...
+    def clearStencil(self, s: int) -> None: ...
+    def colorMask(self, red: bool, green: bool, blue: bool, alpha: bool) -> None: ...
+    def cullFace(self, mode: int) -> None: ...
+    def depthFunc(self, func: int) -> None: ...
+    def depthMask(self, flag: bool) -> None: ...
+    def depthRange(self, zNear: float, zFar: float) -> None: ...
+    def disable(self, cap: int) -> None: ...
+    def enable(self, cap: int) -> None: ...
+    def finish(self) -> None: ...
+    def flush(self) -> None: ...
+    def frontFace(self, mode: int) -> None: ...
+    def hint(self, target: int, mode: int) -> None: ...
+    def isBuffer(self, buffer: WebGLBuffer) -> bool: ...
+    def isContextLost(self) -> bool: ...
+    def isEnabled(self, cap: int) -> bool: ...
+    def isFramebuffer(self, framebuffer: WebGLFramebuffer) -> bool: ...
+    def isProgram(self, program: WebGLProgram) -> bool: ...
+    def isRenderbuffer(self, renderbuffer: WebGLRenderbuffer) -> bool: ...
+    def isShader(self, shader: WebGLShader) -> bool: ...
+    def isTexture(self, texture: WebGLTexture) -> bool: ...
+    def lineWidth(self, width: float) -> None: ...
+    def pixelStorei(self, pname: int, param: int | bool) -> None: ...
+    def polygonOffset(self, factor: float, units: float) -> None: ...
+    def readPixels(
+        self, x: int, y: int, width: int, height: int,
+        format: int, type: int, pixels: bytes | memoryview | None,
+    ) -> None: ...
+    def sampleCoverage(self, value: float, invert: bool) -> None: ...
+    def scissor(self, x: int, y: int, width: int, height: int) -> None: ...
+    def getError(self) -> int: ...
+    def getParameter(self, pname: int) -> Any: ...
+    def getContextAttributes(self) -> Any: ...
+    def getExtension(self, name: str) -> Any: ...
+    def getSupportedExtensions(self) -> list[str] | None: ...
+
+    # --- Vertex Attribute Functions ---
+    def enableVertexAttribArray(self, index: int) -> None: ...
+    def disableVertexAttribArray(self, index: int) -> None: ...
+    def vertexAttrib1f(self, index: int, x: float) -> None: ...
+    def vertexAttrib1fv(self, index: int, values: Sequence[float] | memoryview) -> None: ...
+    def vertexAttrib2f(self, index: int, x: float, y: float) -> None: ...
+    def vertexAttrib2fv(self, index: int, values: Sequence[float] | memoryview) -> None: ...
+    def vertexAttrib3f(self, index: int, x: float, y: float, z: float) -> None: ...
+    def vertexAttrib3fv(self, index: int, values: Sequence[float] | memoryview) -> None: ...
+    def vertexAttrib4f(self, index: int, x: float, y: float, z: float, w: float) -> None: ...
+    def vertexAttrib4fv(self, index: int, values: Sequence[float] | memoryview) -> None: ...
+    def vertexAttribPointer(self, index: int, size: int, type: int, normalized: bool, stride: int, offset: int) -> None: ...
+    def getVertexAttrib(self, index: int, pname: int) -> Any: ...
+    def getVertexAttribOffset(self, index: int, pname: int) -> int: ...
+    def getAttribLocation(self, program: WebGLProgram, name: str) -> int: ...
+
+    # --- Uniform Functions ---
+    def uniform1f(self, location: WebGLUniformLocation, x: float) -> None: ...
+    def uniform1fv(self, location: WebGLUniformLocation, v: Sequence[float] | memoryview) -> None: ...
+    def uniform1i(self, location: WebGLUniformLocation, x: int) -> None: ...
+    def uniform1iv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform2f(self, location: WebGLUniformLocation, x: float, y: float) -> None: ...
+    def uniform2fv(self, location: WebGLUniformLocation, v: Sequence[float] | memoryview) -> None: ...
+    def uniform2i(self, location: WebGLUniformLocation, x: int, y: int) -> None: ...
+    def uniform2iv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform3f(self, location: WebGLUniformLocation, x: float, y: float, z: float) -> None: ...
+    def uniform3fv(self, location: WebGLUniformLocation, v: Sequence[float] | memoryview) -> None: ...
+    def uniform3i(self, location: WebGLUniformLocation, x: int, y: int, z: int) -> None: ...
+    def uniform3iv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform4f(self, location: WebGLUniformLocation, x: float, y: float, z: float, w: float) -> None: ...
+    def uniform4fv(self, location: WebGLUniformLocation, v: Sequence[float] | memoryview) -> None: ...
+    def uniform4i(self, location: WebGLUniformLocation, x: int, y: int, z: int, w: int) -> None: ...
+    def uniform4iv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniformMatrix2fv(self, location: WebGLUniformLocation, transpose: bool, value: Sequence[float] | memoryview) -> None: ...
+    def uniformMatrix3fv(self, location: WebGLUniformLocation, transpose: bool, value: Sequence[float] | memoryview) -> None: ...
+    def uniformMatrix4fv(self, location: WebGLUniformLocation, transpose: bool, value: Sequence[float] | memoryview) -> None: ...
+    def validateProgram(self, program: WebGLProgram) -> None: ...
+
+    # --- Viewport ---
+    def viewport(self, x: int, y: int, width: int, height: int) -> None: ...
+    def drawArrays(self, mode: int, first: int, count: int) -> None: ...
+    def drawElements(self, mode: int, count: int, type: int, offset: int) -> None: ...
+
+
+
+class WebGL2RenderingContext(WebGLRenderingContext):
+    def beginQuery(self, target: int, query: WebGLQuery) -> None: ...
+    def beginTransformFeedback(self, primitiveMode: int) -> None: ...
+    def bindBufferBase(self, target: int, index: int, buffer: WebGLBuffer | None) -> None: ...
+    def bindBufferRange(self, target: int, index: int, buffer: WebGLBuffer | None, offset: int, size: int) -> None: ...
+    def bindSampler(self, unit: int, sampler: WebGLSampler | None) -> None: ...
+    def bindTransformFeedback(self, target: int, transformFeedback: WebGLTransformFeedback | None) -> None: ...
+    def bindVertexArray(self, array: WebGLVertexArrayObject | None) -> None: ...
+    def blitFramebuffer(
+        self, srcX0: int, srcY0: int, srcX1: int, srcY1: int,
+        dstX0: int, dstY0: int, dstX1: int, dstY1: int,
+        mask: int, filter: int,
+    ) -> None: ...
+    def clearBufferfi(self, buffer: int, drawbuffer: int, depth: float, stencil: int) -> None: ...
+    def clearBufferfv(self, buffer: int, drawbuffer: int, values: Sequence[float] | memoryview) -> None: ...
+    def clearBufferiv(self, buffer: int, drawbuffer: int, values: Sequence[int] | memoryview) -> None: ...
+    def clearBufferuiv(self, buffer: int, drawbuffer: int, values: Sequence[int] | memoryview) -> None: ...
+    def clientWaitSync(self, sync: WebGLSync, flags: int, timeout: int) -> int: ...
+    def texStorage2D(self, target: int, levels: int, internalformat: int, width: int, height: int) -> None: ...
+    def compressedTexImage3D(
+        self, target: int, level: int, internalformat: int,
+        width: int, height: int, depth: int, border: int,
+        imageSize: int, data: bytes | memoryview | None,
+    ) -> None: ...
+    def compressedTexSubImage3D(
+        self, target: int, level: int, xoffset: int, yoffset: int, zoffset: int,
+        width: int, height: int, depth: int, format: int,
+        imageSize: int, data: bytes | memoryview | None,
+    ) -> None: ...
+    def copyBufferSubData(self, readTarget: int, writeTarget: int, readOffset: int, writeOffset: int, size: int) -> None: ...
+    def copyTexSubImage3D(
+        self, target: int, level: int, xoffset: int, yoffset: int, zoffset: int,
+        x: int, y: int, width: int, height: int,
+    ) -> None: ...
+    def createQuery(self) -> WebGLQuery | None: ...
+    def deleteQuery(self, query: WebGLQuery | None) -> None: ...
+    def getQuery(self, target: int, pname: int) -> WebGLQuery | None: ...
+    def getQueryParameter(self, query: WebGLQuery, pname: int) -> Any: ...
+    def createSampler(self) -> WebGLSampler | None: ...
+    def deleteSampler(self, sampler: WebGLSampler | None) -> None: ...
+    def getSamplerParameter(self, sampler: WebGLSampler, pname: int) -> Any: ...
+    def samplerParameteri(self, sample: WebGLSampler, pname: int, param: int) -> None: ...
+    def samplerParameterf(self, sample: WebGLSampler, pname: int, param: float) -> None: ...
+    def createSync(self, condition: int, flags: int) -> WebGLSync | None: ...
+    def deleteSync(self, sync: WebGLSync | None) -> None: ...
+    def getSyncParameter(self, sync: WebGLSync, pname: int) -> Any: ...
+    def fenceSync(self, condition: int, flags: int) -> WebGLSync | None: ...
+    def createTransformFeedback(self) -> WebGLTransformFeedback | None: ...
+    def deleteTransformFeedback(self, transformFeedback: WebGLTransformFeedback | None) -> None: ...
+    def createVertexArray(self) -> WebGLVertexArrayObject | None: ...
+    def deleteVertexArray(self, array: WebGLVertexArrayObject | None) -> None: ...
+    def isQuery(self, query: WebGLQuery) -> bool: ...
+    def isSampler(self, sampler: WebGLSampler) -> bool: ...
+    def isSync(self, sync: WebGLSync) -> bool: ...
+    def isTransformFeedback(self, transformFeedback: WebGLTransformFeedback) -> bool: ...
+    def isVertexArray(self, array: WebGLVertexArrayObject) -> bool: ...
+    def drawArraysInstanced(self, mode: int, first: int, count: int, instanceCount: int) -> None: ...
+    def drawElementsInstanced(self, mode: int, count: int, type: int, offset: int, instanceCount: int) -> None: ...
+    def drawRangeElements(self, mode: int, start: int, end: int, count: int, type: int, offset: int) -> None: ...
+    def endQuery(self, target: int) -> None: ...
+    def endTransformFeedback(self) -> None: ...
+    def getBufferSubData(self, target: int, srcByteOffset: int, dstBuffer: bytearray | memoryview) -> None: ...
+    def getIndexedParameter(self, target: int, index: int) -> Any: ...
+    # --- Uniform Block Functions ---
+    def getUniformBlockIndex(self, program: WebGLProgram, uniformBlockName: str) -> int: ...
+    def getActiveUniformBlockParameter(self, program: WebGLProgram, uniformBlockIndex: int, pname: int) -> Any: ...
+    def getActiveUniformBlockName(self, program: WebGLProgram, uniformBlockIndex: int) -> str: ...
+    def uniformBlockBinding(self, program: WebGLProgram, uniformBlockIndex: int, uniformBlockBinding: int) -> None: ...
+
+    # --- Blending Functions ---
+    def blendColor(self, red: float, green: float, blue: float, alpha: float) -> None: ...
+    def blendEquation(self, mode: int) -> None: ...
+    def blendEquationSeparate(self, modeRGB: int, modeAlpha: int) -> None: ...
+    def blendFunc(self, sfactor: int, dfactor: int) -> None: ...
+    def blendFuncSeparate(self, srcRGB: int, dstRGB: int, srcAlpha: int, dstAlpha: int) -> None: ...
+
+    # --- Additional WebGL2 Functions ---
+    def getFragDataLocation(self, program: WebGLProgram, name: str) -> int: ...
+    def drawBuffers(self, buffers: Sequence[int]) -> None: ...
+    def uniform1ui(self, location: WebGLUniformLocation, v0: int) -> None: ...
+    def uniform1uiv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform2ui(self, location: WebGLUniformLocation, v0: int, v1: int) -> None: ...
+    def uniform2uiv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform3ui(self, location: WebGLUniformLocation, v0: int, v1: int, v2: int) -> None: ...
+    def uniform3uiv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def uniform4ui(self, location: WebGLUniformLocation, v0: int, v1: int, v2: int, v3: int) -> None: ...
+    def uniform4uiv(self, location: WebGLUniformLocation, v: Sequence[int] | memoryview) -> None: ...
+    def vertexAttribDivisor(self, index: int, divisor: int) -> None: ...
+    def waitSync(self, sync: WebGLSync, flags: int, timeout: int) -> int: ...
+    def readBuffer(self, source: int) -> None: ...
+    def transformFeedbackVaryings(self, program: WebGLProgram, varyings: Sequence[str], buffermode: int) -> None: ...
+    def texImage3D(
+        self, target: int, level: int, internalformat: int,
+        width: int, height: int, depth: int, border: int,
+        format: int, type: int, pixels: int | bytes | memoryview | None = None,
+    ) -> None: ...
+    def texImage3D(
+        self, target: int, level: int, internalformat: int,
+        width: int, height: int, depth: int, border: int,
+        format: int, type: int, source: Any,
+    ) -> None: ...  # Overload for image sources
+    def texStorage3D(self, target: int, levels: int, internalformat: int, width: int, height: int, depth: int) -> None: ...
+    def texSubImage3D(
+        self, target: int, level: int, xoffset: int, yoffset: int,
+        zoffset: int, width: int, height: int, depth: int, format: int,
+        type: int, pixels: int | bytes | memoryview | None = None,
+    ) -> None: ...
+    def texSubImage3D(
+        self, target: int, level: int, xoffset: int, yoffset: int,
+        zoffset: int, width: int, height: int, depth: int, format: int,
+        type: int, source: Any,
+    ) -> None: ...  # Overload for image sources
+    def framebufferTextureLayer(self,
+        target: int,
+        attachment: int,
+        texture: WebGLTexture | None,
+        level: int,
+        layer: int,
+    ) -> None: ...

pyglet/{image → graphics}/atlas.py

@@ -1,13 +1,13 @@
 """Group multiple small images into larger Textures.
 
 This module provides classes to efficiently pack small images into larger Textures.
-This can have major performance benefits when dealiing with a large number of images.
+This can have major performance benefits when dealing with a large number of images.
 
 :py:class:`~pyglet.image.atlas.TextureAtlas` maintains one texture; :py:class:`TextureBin`
 manages a collection of atlases of a given size. :py:class:`TextureArrayBin` works similarly
-except for :py:class:`~pyglet.image.TextureArray`s instead of altases.
+except for :py:class:`~pyglet.graphics.TextureArray`s instead of altases.
 
-This module is used internally by the :py:mod:`pyglet.resource` module.
+This module is used internally by the :py:mod:`~pyglet.resource` module.
 
 Example usage::
 
@@ -21,8 +21,8 @@ Example usage::
     boat_texture = bin.add(boat_image)
 
 The result of :py:meth:`TextureBin.add` is a :py:class:`TextureRegion`
-containing the image. Once added, an image cannot be removed from a bin (or an 
-atlas); nor can a list of images be obtained from a given bin or atlas -- it is 
+containing the image. Once added, an image cannot be removed from a bin (or an
+atlas); nor can a list of images be obtained from a given bin or atlas -- it is
 the application's responsibility to keep track of the regions returned by the
 ``add`` methods.
 
@@ -34,18 +34,18 @@ import pyglet
 
 from typing import TYPE_CHECKING
 
+
 if TYPE_CHECKING:
-    from pyglet.image import AbstractImage, ImageData, TextureRegion, TextureArrayRegion
+    from pyglet.image import ImageData, ImageDataRegion
+    from pyglet.graphics.texture import TextureRegion, TextureArrayRegion
 
 
-class AllocatorException(Exception):
-    """The allocator does not have sufficient free space for the requested
-    image size."""
-    pass
+class AllocatorException(Exception):  # noqa: N818
+    """The allocator does not have sufficient free space for the requested image size."""
 
 
 class _Strip:
-    __slots__ = 'x', 'y', 'max_height', 'y2'
+    __slots__ = 'max_height', 'x', 'y', 'y2'
 
     def __init__(self, y: int, max_height: int) -> None:
         self.x = 0
@@ -54,7 +54,7 @@ class _Strip:
         self.y2 = y
 
     def add(self, width: int, height: int) -> tuple[int, int]:
-        assert width > 0 and height > 0
+        assert width > 0 and height > 0  # noqa: PT018
         assert height <= self.max_height
 
         x, y = self.x, self.y
@@ -77,18 +77,18 @@ class Allocator:
     best when rectangles are allocated of the same size, or in decreasing
     height order.
     """
-    __slots__ = 'width', 'height', 'strips', 'used_area'
+    __slots__ = 'height', 'strips', 'used_area', 'width'
 
     def __init__(self, width: int, height: int) -> None:
         """Create an ``Allocator`` of the given size."""
-        assert width > 0 and height > 0
+        assert width > 0 and height > 0  # noqa: PT018
         self.width = width
         self.height = height
         self.strips = [_Strip(0, height)]
         self.used_area = 0
 
     def alloc(self, width: int, height: int) -> tuple[int, int]:
-        """Get the position of a free area in the allocator of the given size
+        """Get the position of a free area in the allocator of the given size.
 
         If a suitable position can be found for the requested size, the position
         will be marked as in-use and returned. (The same position will never be
@@ -110,7 +110,8 @@ class Allocator:
             self.strips.append(newstrip)
             return newstrip.add(width, height)
 
-        raise AllocatorException(f"No more space in {self} for box {width}x{height}")
+        msg = f"No more space in {self} for box {width}x{height}"
+        raise AllocatorException(msg)
 
     def get_usage(self) -> float:
         """Get the fraction of area already allocated.
@@ -120,8 +121,7 @@ class Allocator:
         return self.used_area / float(self.width * self.height)
 
     def get_fragmentation(self) -> float:
-        """Get the fraction of area that's unlikely to ever be used, based on
-        current allocation behaviour.
+        """Get the fraction of area that's unlikely to ever be used, based on current allocation behaviour.
 
         This method is useful for debugging and profiling only.
         """
@@ -140,7 +140,7 @@ class TextureAtlas:
     by allowing all the Images to be drawn together with a single
     Texture bind, rather than multiple tiny Texture binds per draw.
 
-    When creating a TextureAtlas instance, a new :py:class:`~pyglet.image.Texture`
+    When creating a TextureAtlas instance, a new :py:class:`~pyglet.graphics.Texture`
     object will be created at the requested size. If the maximum texture
     size supported by the OpenGL driver is less than requested, the
     smaller of the two will be used.
@@ -148,18 +148,18 @@ class TextureAtlas:
 
     def __init__(self, width: int = 2048, height: int = 2048) -> None:
         """Create a Texture Atlas of the given size."""
-        max_texture_size = pyglet.image.get_max_texture_size()
+        max_texture_size = pyglet.graphics.texture.get_max_texture_size()
         width = min(width, max_texture_size)
         height = min(height, max_texture_size)
 
-        self.texture = pyglet.image.Texture.create(width, height)
+        self.texture = pyglet.graphics.Texture.create(width, height)
         self.allocator = Allocator(width, height)
 
-    def add(self, img: ImageData, border: int = 0) -> TextureRegion:
+    def add(self, img: ImageData | ImageDataRegion, border: int = 0) -> TextureRegion:
         """Add ImageData to the atlas.
 
         Given :py:class:`~pyglet.image.ImageData`, add it to the Atlas and
-        return a new :py:class:`~pyglet.image.TextureRegion` object. An
+        return a new :py:class:`~pyglet.graphics.TextureRegion` object. An
         optional ``border`` argument can be passed, which will leave the
         specified number of blank pixels around the added ImageData. This
         can be useful in certain situations and blend modes, where
@@ -171,14 +171,15 @@ class TextureAtlas:
         no room in the atlas for the image.
         """
         x, y = self.allocator.alloc(img.width + border * 2, img.height + border * 2)
-        self.texture.blit_into(img, x + border, y + border, 0)
+        self.texture.bind()
+        self.texture.upload(img, x + border, y + border, 0)
         return self.texture.get_region(x + border, y + border, img.width, img.height)
 
 
 class TextureBin:
     """Collection of TextureAtlases.
 
-    :py:class:`~pyglet.image.atlas.TextureBin` maintains a collection
+    :py:class:`~pyglet.graphics.atlas.TextureBin` maintains a collection
     of TextureAtlases, and creates new ones as necessary to accommodate
     adding an unbound number of Images. When one TextureAltas is full,
     a new one is automatically created to fit the next ImageData.
@@ -186,12 +187,12 @@ class TextureBin:
 
     def __init__(self, texture_width: int = 2048, texture_height: int = 2048) -> None:
         """Create a texture bin for holding atlases of the given size."""
-        max_texture_size = pyglet.image.get_max_texture_size()
+        max_texture_size = pyglet.graphics.texture.get_max_texture_size()
         self.texture_width = min(texture_width, max_texture_size)
         self.texture_height = min(texture_height, max_texture_size)
         self.atlases = []
 
-    def add(self, img: ImageData | AbstractImage, border: int = 0) -> TextureRegion:
+    def add(self, img: ImageData | ImageDataRegion, border: int = 0) -> TextureRegion:
         """Add an image into this texture bin.
 
         This method calls :py:meth:`~TextureAtlas.add` for the first atlas
@@ -224,8 +225,8 @@ class TextureArrayBin:
     """
 
     def __init__(self, texture_width: int = 2048, texture_height: int = 2048, max_depth: int | None = None) -> None:
-        max_texture_size = pyglet.image.get_max_texture_size()
-        self.max_depth = max_depth or pyglet.image.get_max_array_texture_layers()
+        max_texture_size = pyglet.graphics.texture.get_max_texture_size()
+        self.max_depth = max_depth or pyglet.graphics.texture.get_max_array_texture_layers()
         self.texture_width = min(texture_width, max_texture_size)
         self.texture_height = min(texture_height, max_texture_size)
         self.arrays = []
@@ -233,7 +234,7 @@ class TextureArrayBin:
     def add(self, img: ImageData) -> TextureArrayRegion:
         """Add an image into this texture array bin.
 
-        This method calls :py:meth:`~pyglet.image.TextureArray.add` for the first
+        This method calls :py:meth:`~pyglet.graphics.TextureArray.add` for the first
         array that has room for the image.
 
         ``TextureArraySizeExceeded`` is raised if the image exceeds the dimensions of
@@ -242,11 +243,11 @@ class TextureArrayBin:
         try:
             array = self.arrays[-1]
             return array.add(img)
-        except pyglet.image.TextureArrayDepthExceeded:
+        except pyglet.graphics.texture.TextureArrayDepthExceeded:
             pass
         except IndexError:
             pass
 
-        array = pyglet.image.TextureArray.create(self.texture_width, self.texture_height, max_depth=self.max_depth)
+        array = pyglet.graphics.texture.TextureArray.create(self.texture_width, self.texture_height, max_depth=self.max_depth)
         self.arrays.append(array)
         return array.add(img)

pyglet/graphics/base.py

@@ -0,0 +1,10 @@
+from enum import auto, Enum
+
+
+class GeometryMode(Enum):
+    POINTS = auto()
+    LINES = auto()
+    LINE_STRIP = auto()
+    TRIANGLES = auto()
+    TRIANGLE_STRIP = auto()
+    TRIANGLE_FAN = auto()