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

pyglet/image/codecs/ktx2.py

@@ -0,0 +1,161 @@
+# KTX2 decoder, based on the spec here: https://github.khronos.org/KTX-Specification/ktxspec.v2.html
+
+from __future__ import annotations
+
+import struct
+import itertools
+import zlib
+from typing import BinaryIO
+
+try:
+    import zstandard
+    _zstandard_available = True
+except ImportError:
+    _zstandard_available = False
+
+from pyglet.image.base import CompressedImageData, CompressionFormat
+from pyglet.image import codecs
+from pyglet.image.codecs import ImageDecodeException
+
+
+class _FileStruct:
+    _fields = []
+
+    def __init__(self, data):
+        if len(data) < self.get_size():
+            raise ImageDecodeException('Not a KTX2 file')
+        items = struct.unpack(self.get_format(), data)
+        for field, value in itertools.zip_longest(self._fields, items, fillvalue=None):
+            setattr(self, field[0], value)
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        return '{}({})'.format(name, (', \n%s' % (' ' * (len(name) + 1))).join(
+            [f'{field[0]} = {getattr(self, field[0])!r}' for field in self._fields]))
+
+    @classmethod
+    def get_format(cls):
+        return '<' + ''.join([f[1] for f in cls._fields])
+
+    @classmethod
+    def get_size(cls):
+        return struct.calcsize(cls.get_format())
+
+
+class KTX2Header(_FileStruct):
+    _fields = [
+        ('vkFormat', 'I'),
+        ('typeSize', 'I'),
+        ('pixelWidth', 'I'),
+        ('pixelHeight', 'I'),
+        ('pixelDepth', 'I'),
+        ('layerCount', 'I'),
+        ('faceCount', 'I'),
+        ('levelCount', 'I'),
+        ('supercompressionScheme', 'I'),
+
+        ('dfdByteOffset', 'I'),
+        ('dfdByteLength', 'I'),
+        ('kvdByteOffset', 'I'),
+        ('kvdByteLength', 'I'),
+        ('sgdByteOffset', 'Q'),
+        ('sgdByteLength', 'Q'),
+    ]
+
+class KTX2LevelIndex(_FileStruct):
+    _fields = [
+        ('byteOffset', 'Q'),
+        ('byteLength', 'Q'),
+        ('uncompressedByteLength', 'Q'),
+    ]
+
+class KTX2ImageDecoder(codecs.ImageDecoder):
+    def get_file_extensions(self) -> list[str]:
+        return ['.ktx2']
+
+    def decode(self, filename: str, file: BinaryIO | None = None) -> CompressedImageData:
+        file_opened = False
+        if not file:
+            file = open(filename, 'rb')
+            file_opened = True
+
+        # Magic header, if supported
+        magic = file.read(12)
+        if magic != b'\xABKTX 20\xBB\r\n\x1A\n':
+            raise ImageDecodeException('Invalid KTX2 file (bad magic)')
+
+        header_data = file.read(KTX2Header.get_size())
+        header = KTX2Header(header_data)
+
+        width = header.pixelWidth
+        height = header.pixelHeight
+        mipmaps = header.levelCount or 1
+
+        fmt = CompressionFormat(
+            fmt=b'KTX2',
+            alpha=header.vkFormat in (131, 147, 148),
+            dxgi_format=0,
+            vk_format=header.vkFormat,
+        )
+
+        # Mip map level indexes
+        level_indices = []
+        for _ in range(mipmaps):
+            index_data = file.read(KTX2LevelIndex.get_size())
+            level_indices.append(KTX2LevelIndex(index_data))
+
+        # 2 = ZStandard compression
+        # 1 = Zlib compression.
+        # 0 = Not compressed.
+        if header.supercompressionScheme != 0:
+            if header.sgdByteOffset == 0:
+                datas = self.decompress_ktx2_per_level(file, header, level_indices)
+        else:
+            datas = []
+            for idx in level_indices:
+                file.seek(idx.byteOffset)
+                data = file.read(idx.byteLength)
+                datas.append(data)
+
+        image = CompressedImageData(width, height, fmt, datas[0])
+        for level, data in enumerate(datas[1:], 1):
+            image.set_mipmap_data(level, data)
+
+        if file_opened:
+            file.close()
+
+        return image
+
+    def decompress_ktx2_per_level(self, file: BinaryIO, header: KTX2Header, level_indices: list):
+        datas = []
+        for idx in level_indices:
+            file.seek(idx.byteOffset)
+            compressed_data = file.read(idx.byteLength)
+
+            if header.supercompressionScheme == 3:
+                decompressed = zlib.decompress(compressed_data)
+            elif header.supercompressionScheme == 2:
+                if _zstandard_available:
+                    dctx = zstandard.ZstdDecompressor()
+                    with dctx.stream_reader(compressed_data) as reader:
+                        decompressed = reader.read(idx.uncompressedByteLength)
+                else:
+                    msg = "File was supercompressed with Zstandard, but zstandard package is not installed."
+                    raise ImageDecodeException(msg)
+            else:
+                msg = f"Unsupported supercompression scheme: {header.supercompressionScheme}"
+                raise ImageDecodeException(msg)
+
+            if len(decompressed) != idx.uncompressedByteLength:
+                msg = f"Size mismatch at level: expected {idx.uncompressedByteLength}, got {len(decompressed)}"
+                raise ImageDecodeException(msg)
+
+            datas.append(decompressed)
+        return datas
+
+def get_decoders():
+    return [KTX2ImageDecoder()]
+
+
+def get_encoders():
+    return []

pyglet/image/codecs/pil.py

@@ -66,7 +66,7 @@ class PILImageEncoder(ImageEncoder):
             image_from_fn = getattr(Image, "frombytes")
         except AttributeError:
             image_from_fn = getattr(Image, "fromstring")
-        pil_image = image_from_fn(fmt, (image.width, image.height), image.get_data(fmt, pitch))
+        pil_image = image_from_fn(fmt, (image.width, image.height), image.get_bytes(fmt, pitch))
 
         try:
             pil_image.save(file, pil_format)

pyglet/image/codecs/png.py

@@ -65,7 +65,7 @@ class PNGImageEncoder(ImageEncoder):
         writer = pypng.Writer(image.width, image.height, greyscale=greyscale, alpha=has_alpha)
 
         data = array.array('B')
-        data.frombytes(image.get_data(image.format, image.pitch))
+        data.frombytes(image.get_bytes(image.format, image.pitch))
 
         writer.write_array(file, data)
 

pyglet/image/codecs/wic.py

@@ -4,6 +4,7 @@ import os
 from ctypes import byref, memmove
 from typing import BinaryIO, Sequence
 
+import pyglet
 from pyglet.image import ImageData
 from pyglet.image.codecs import ImageDecodeException, ImageDecoder, ImageEncoder
 from pyglet.image.codecs.wincodec_lib import (
@@ -16,6 +17,7 @@ from pyglet.image.codecs.wincodec_lib import (
     GUID_ContainerFormatWmp,
     GUID_WICPixelFormat24bppBGR,
     GUID_WICPixelFormat32bppBGRA,
+    GUID_WICPixelFormat32bppRGBA,
     IID_IWICImagingFactory1,
     IID_IWICImagingFactory2,
     IPropertyBag2,
@@ -112,6 +114,12 @@ def extract_image_data(bitmap: IWICBitmap, target_fmt: com.GUID = GUID_WICPixelF
 
     .. note:: ``bitmap`` is released before this function returns.
     """
+    if "es" in pyglet.options.backend:
+        target_fmt = GUID_WICPixelFormat32bppRGBA
+        fmt = "RGBA"
+    else:
+        fmt = "BGRA"
+
     width = UINT()
     height = UINT()
 
@@ -124,7 +132,6 @@ def extract_image_data(bitmap: IWICBitmap, target_fmt: com.GUID = GUID_WICPixelF
     pf = com.GUID(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
     bitmap.GetPixelFormat(byref(pf))
 
-    fmt = 'BGRA'
     # If target format is not what we want (32bit BGRA) convert it.
     if pf != target_fmt:
         converter = IWICFormatConverter()
@@ -136,6 +143,8 @@ def extract_image_data(bitmap: IWICBitmap, target_fmt: com.GUID = GUID_WICPixelF
         # 99% of the time conversion will be possible to default.
         # However, we check to be safe and fallback to 24 bit BGR if not possible.
         if not conversion_possible:
+            if "es" in pyglet.options.backend:
+                    raise Exception("Could not convert image to proper format.")
             target_fmt = GUID_WICPixelFormat24bppBGR
             fmt = 'BGR'
 
@@ -286,7 +295,7 @@ class WICEncoder(ImageEncoder):  # noqa: D101
 
         pitch = image.width * len(fmt)
 
-        image_data = image.get_data(fmt, -pitch)
+        image_data = image.get_bytes(fmt, -pitch)
 
         size = pitch * image.height
 

pyglet/info.py

@@ -5,6 +5,7 @@ Intended usage is to create a file for bug reports, e.g.::
     python -m pyglet.info > info.txt
 
 """
+from __future__ import annotations
 
 _first_heading = True
 
@@ -20,7 +21,7 @@ def _heading(heading):
 
 
 def dump_platform():
-    """Dump OS specific """
+    """Dump OS specific"""
     import platform
     print('platform: ', platform.platform())
     print('release:  ', platform.release())
@@ -30,17 +31,17 @@ def dump_platform():
 def dump_python():
     """Dump Python version and environment to stdout."""
     import os
-    import sys
     import platform
+    import sys
     print('implementation:', platform.python_implementation())
     print('sys.version:', sys.version)
     print('sys.maxint:', sys.maxsize)
-    if sys.platform == 'darwin':
-        try:
-            from objc import __version__ as pyobjc_version
-            print('objc.__version__:', pyobjc_version)
-        except:
-            print('PyObjC not available')
+    # if sys.platform == 'darwin':
+    #     try:
+    #         from objc import __version__ as pyobjc_version
+    #         print('objc.__version__:', pyobjc_version)
+    #     except:
+    #         print('PyObjC not available')
     print('os.getcwd():', os.getcwd())
     for key, value in os.environ.items():
         if key.startswith('PYGLET_'):
@@ -54,27 +55,27 @@ def dump_pyglet():
     print('pyglet.compat_platform:', pyglet.compat_platform)
     print('pyglet.__file__:', pyglet.__file__)
     for key, value in pyglet.options.items():
-        print(f"pyglet.options['{key}'] = {value!r}")
+        print(f"pyglet.options.{key} = {value!r}")
 
 
 def dump_window():
     """Dump display, window, screen and default config info."""
-    from pyglet.gl import gl_info
-    if not gl_info.have_version(3):
-        print(f"Insufficient OpenGL version: {gl_info.get_version_string()}")
-        return
     import pyglet.window
+    window = pyglet.window.Window(visible=False)
+    from pyglet.graphics.api import core
+    if not core.have_version(3) or not core.have_version(2):
+        print(f"Insufficient OpenGL version: {core.get_info().get_version_string()}")
+        return
     display = pyglet.display.get_display()
     print('display:', repr(display))
     screens = display.get_screens()
     for i, screen in enumerate(screens):
         print(f'screens[{i}]: {screen!r}')
-    window = pyglet.window.Window(visible=False)
-    for key, value in window.config.get_gl_attributes():
+    for key, value in window.config.attributes.items():
         print(f"config['{key}'] = {value!r}")
     print('context:', repr(window.context))
 
-    _heading('window.context._info')
+    _heading('window.context.info')
     dump_gl(window.context)
     window.close()
 
@@ -84,21 +85,24 @@ def dump_gl(context=None):
     if context is not None:
         info = context.get_info()
     else:
-        from pyglet.gl import gl_info as info
+        from pyglet.graphics.api.gl import gl_info as info
+    print('gl_info.get_version_string():', info.get_version_string())
     print('gl_info.get_version():', info.get_version())
     print('gl_info.get_vendor():', info.get_vendor())
     print('gl_info.get_renderer():', info.get_renderer())
 
 
+
 def dump_glx():
     """Dump GLX info."""
     try:
-        from pyglet.gl import glx_info
+        from pyglet.graphics.api.gl.xlib import glx_info
     except:
         print('GLX not available.')
         return
     import pyglet
     window = pyglet.window.Window(visible=False)
+    glx_info = window.context._info.platform_info
     print('context.is_direct():', window.context.is_direct())
     window.close()
 
@@ -116,7 +120,7 @@ def dump_glx():
         for name in glx_info.get_client_extensions():
             print('  ', name)
         print('glx_info.get_extensions():')
-        for name in glx_info.get_extensions():
+        for name in glx_info.get_extensions(window.context):
             print('  ', name)
 
 
@@ -129,7 +133,7 @@ def dump_media():
 def dump_ffmpeg():
     """Dump FFmpeg info."""
     import pyglet
-    pyglet.options['search_local_libs'] = True
+    pyglet.options.search_local_libs = True
     import pyglet.media
 
     if pyglet.media.have_ffmpeg():
@@ -167,9 +171,7 @@ def dump_wintab():
     impl_version = wintab.get_implementation_version()
     spec_version = wintab.get_spec_version()
 
-    print('WinTab: {0} {1}.{2} (Spec {3}.{4})'.format(interface_name,
-                                                      impl_version >> 8, impl_version & 0xff,
-                                                      spec_version >> 8, spec_version & 0xff))
+    print(f'WinTab: {interface_name} {impl_version >> 8}.{impl_version & 0xff} (Spec {spec_version >> 8}.{spec_version & 0xff})')
 
 
 def _try_dump(heading, func):
@@ -187,7 +189,7 @@ def dump():
     _try_dump('Python', dump_python)
     _try_dump('pyglet', dump_pyglet)
     _try_dump('pyglet.window', dump_window)
-    _try_dump('pyglet.gl.glx_info', dump_glx)
+    _try_dump('pyglet.graphics.api.gl.glx_info', dump_glx)
     _try_dump('pyglet.media', dump_media)
     _try_dump('pyglet.media.ffmpeg', dump_ffmpeg)
     _try_dump('pyglet.media.drivers.openal', dump_al)

pyglet/input/__init__.py

@@ -55,6 +55,7 @@ import sys
 
 from typing import TYPE_CHECKING
 
+from . import controller
 from .base import Device, Control, RelativeAxis, AbsoluteAxis, ControllerManager
 from .base import Button, Joystick, AppleRemote, Tablet, Controller
 from .base import DeviceException, DeviceOpenException, DeviceExclusiveException
@@ -150,6 +151,13 @@ else:
         from .macos import get_tablets
         from .macos import ControllerManager
 
+    elif compat_platform == "emscripten":
+        from .emscripten import get_devices
+        from .emscripten import get_joysticks
+        from .emscripten import get_controllers
+        from .emscripten import get_tablets
+        from .emscripten import ControllerManager
+
 __all__ = [
     'get_devices',
     'get_joysticks',