Remove dead plugin scaffolds and duplicate lib dirs

The *_native C++ ports were replaced by bundled Python + .py plugins in
de4db79, but the source dirs were left behind without any CMake wiring —
causing confusion when editing them appears to do nothing. Same story
for libs/dds_header (stale duplicate of libs/preview_dds, unrelated to
the actively-used libs/dds-header) and libs/game_gamebryo (superseded
by libs/game_bethesda/src/gamebryo).

Removes:
- libs/basic_games_native
- libs/form43_checker_native
- libs/installer_omod_native
- libs/preview_dds_native
- libs/rootbuilder_native
- libs/script_extender_checker_native
- libs/dds_header
- libs/game_gamebryo

7 files changed, 0 insertions, 1895 deletions

diff --git a/libs/dds_header/src/CMakeLists.txt b/libs/dds_header/src/CMakeLists.txt
deleted file mode 100644
index f4f0587..0000000
--- a/libs/dds_header/src/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-
-find_package(mo2-cmake CONFIG REQUIRED)
-
-add_custom_target(DDSPreview ALL)
-mo2_configure_python(DDSPreview SIMPLE)
diff --git a/libs/dds_header/src/DDS/DDSDefinitions.py b/libs/dds_header/src/DDS/DDSDefinitions.py
deleted file mode 100644
index 2d44812..0000000
--- a/libs/dds_header/src/DDS/DDSDefinitions.py
+++ /dev/null
@@ -1,808 +0,0 @@
-import dataclasses
-from enum import IntEnum, IntFlag, auto
-import struct
-from typing import ClassVar, List
-
-from .glstuff import GL_IMAGE_FORMAT, CompressedGLTextureFormat, UncompressedGLTextureFormat
-
-DDS_MAGIC_NUMBER = b"DDS "  # b"\x20\x53\x44\x44"
-
-
-class IntEnumFromZero(IntEnum):
-    def _generate_next_value_(name, start, count, last_values):
-        return count
-
-
-class D3D10_RESOURCE_DIMENSION(IntEnumFromZero):
-    D3D10_RESOURCE_DIMENSION_UNKNOWN = auto()
-    D3D10_RESOURCE_DIMENSION_BUFFER = auto()
-    D3D10_RESOURCE_DIMENSION_TEXTURE1D = auto()
-    D3D10_RESOURCE_DIMENSION_TEXTURE2D = auto()
-    D3D10_RESOURCE_DIMENSION_TEXTURE3D = auto()
-
-
-class DXGI_FORMAT(IntEnumFromZero):
-    DXGI_FORMAT_UNKNOWN = auto()
-    DXGI_FORMAT_R32G32B32A32_TYPELESS = auto()
-    DXGI_FORMAT_R32G32B32A32_FLOAT = auto()
-    DXGI_FORMAT_R32G32B32A32_UINT = auto()
-    DXGI_FORMAT_R32G32B32A32_SINT = auto()
-    DXGI_FORMAT_R32G32B32_TYPELESS = auto()
-    DXGI_FORMAT_R32G32B32_FLOAT = auto()
-    DXGI_FORMAT_R32G32B32_UINT = auto()
-    DXGI_FORMAT_R32G32B32_SINT = auto()
-    DXGI_FORMAT_R16G16B16A16_TYPELESS = auto()
-    DXGI_FORMAT_R16G16B16A16_FLOAT = auto()
-    DXGI_FORMAT_R16G16B16A16_UNORM = auto()
-    DXGI_FORMAT_R16G16B16A16_UINT = auto()
-    DXGI_FORMAT_R16G16B16A16_SNORM = auto()
-    DXGI_FORMAT_R16G16B16A16_SINT = auto()
-    DXGI_FORMAT_R32G32_TYPELESS = auto()
-    DXGI_FORMAT_R32G32_FLOAT = auto()
-    DXGI_FORMAT_R32G32_UINT = auto()
-    DXGI_FORMAT_R32G32_SINT = auto()
-    DXGI_FORMAT_R32G8X24_TYPELESS = auto()
-    DXGI_FORMAT_D32_FLOAT_S8X24_UINT = auto()
-    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = auto()
-    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = auto()
-    DXGI_FORMAT_R10G10B10A2_TYPELESS = auto()
-    DXGI_FORMAT_R10G10B10A2_UNORM = auto()
-    DXGI_FORMAT_R10G10B10A2_UINT = auto()
-    DXGI_FORMAT_R11G11B10_FLOAT = auto()
-    DXGI_FORMAT_R8G8B8A8_TYPELESS = auto()
-    DXGI_FORMAT_R8G8B8A8_UNORM = auto()
-    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = auto()
-    DXGI_FORMAT_R8G8B8A8_UINT = auto()
-    DXGI_FORMAT_R8G8B8A8_SNORM = auto()
-    DXGI_FORMAT_R8G8B8A8_SINT = auto()
-    DXGI_FORMAT_R16G16_TYPELESS = auto()
-    DXGI_FORMAT_R16G16_FLOAT = auto()
-    DXGI_FORMAT_R16G16_UNORM = auto()
-    DXGI_FORMAT_R16G16_UINT = auto()
-    DXGI_FORMAT_R16G16_SNORM = auto()
-    DXGI_FORMAT_R16G16_SINT = auto()
-    DXGI_FORMAT_R32_TYPELESS = auto()
-    DXGI_FORMAT_D32_FLOAT = auto()
-    DXGI_FORMAT_R32_FLOAT = auto()
-    DXGI_FORMAT_R32_UINT = auto()
-    DXGI_FORMAT_R32_SINT = auto()
-    DXGI_FORMAT_R24G8_TYPELESS = auto()
-    DXGI_FORMAT_D24_UNORM_S8_UINT = auto()
-    DXGI_FORMAT_R24_UNORM_X8_TYPELESS = auto()
-    DXGI_FORMAT_X24_TYPELESS_G8_UINT = auto()
-    DXGI_FORMAT_R8G8_TYPELESS = auto()
-    DXGI_FORMAT_R8G8_UNORM = auto()
-    DXGI_FORMAT_R8G8_UINT = auto()
-    DXGI_FORMAT_R8G8_SNORM = auto()
-    DXGI_FORMAT_R8G8_SINT = auto()
-    DXGI_FORMAT_R16_TYPELESS = auto()
-    DXGI_FORMAT_R16_FLOAT = auto()
-    DXGI_FORMAT_D16_UNORM = auto()
-    DXGI_FORMAT_R16_UNORM = auto()
-    DXGI_FORMAT_R16_UINT = auto()
-    DXGI_FORMAT_R16_SNORM = auto()
-    DXGI_FORMAT_R16_SINT = auto()
-    DXGI_FORMAT_R8_TYPELESS = auto()
-    DXGI_FORMAT_R8_UNORM = auto()
-    DXGI_FORMAT_R8_UINT = auto()
-    DXGI_FORMAT_R8_SNORM = auto()
-    DXGI_FORMAT_R8_SINT = auto()
-    DXGI_FORMAT_A8_UNORM = auto()
-    DXGI_FORMAT_R1_UNORM = auto()
-    DXGI_FORMAT_R9G9B9E5_SHAREDEXP = auto()
-    DXGI_FORMAT_R8G8_B8G8_UNORM = auto()
-    DXGI_FORMAT_G8R8_G8B8_UNORM = auto()
-    DXGI_FORMAT_BC1_TYPELESS = auto()
-    DXGI_FORMAT_BC1_UNORM = auto()
-    DXGI_FORMAT_BC1_UNORM_SRGB = auto()
-    DXGI_FORMAT_BC2_TYPELESS = auto()
-    DXGI_FORMAT_BC2_UNORM = auto()
-    DXGI_FORMAT_BC2_UNORM_SRGB = auto()
-    DXGI_FORMAT_BC3_TYPELESS = auto()
-    DXGI_FORMAT_BC3_UNORM = auto()
-    DXGI_FORMAT_BC3_UNORM_SRGB = auto()
-    DXGI_FORMAT_BC4_TYPELESS = auto()
-    DXGI_FORMAT_BC4_UNORM = auto()
-    DXGI_FORMAT_BC4_SNORM = auto()
-    DXGI_FORMAT_BC5_TYPELESS = auto()
-    DXGI_FORMAT_BC5_UNORM = auto()
-    DXGI_FORMAT_BC5_SNORM = auto()
-    DXGI_FORMAT_B5G6R5_UNORM = auto()
-    DXGI_FORMAT_B5G5R5A1_UNORM = auto()
-    DXGI_FORMAT_B8G8R8A8_UNORM = auto()
-    DXGI_FORMAT_B8G8R8X8_UNORM = auto()
-    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = auto()
-    DXGI_FORMAT_B8G8R8A8_TYPELESS = auto()
-    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = auto()
-    DXGI_FORMAT_B8G8R8X8_TYPELESS = auto()
-    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = auto()
-    DXGI_FORMAT_BC6H_TYPELESS = auto()
-    DXGI_FORMAT_BC6H_UF16 = auto()
-    DXGI_FORMAT_BC6H_SF16 = auto()
-    DXGI_FORMAT_BC7_TYPELESS = auto()
-    DXGI_FORMAT_BC7_UNORM = auto()
-    DXGI_FORMAT_BC7_UNORM_SRGB = auto()
-    DXGI_FORMAT_AYUV = auto()
-    DXGI_FORMAT_Y410 = auto()
-    DXGI_FORMAT_Y416 = auto()
-    DXGI_FORMAT_NV12 = auto()
-    DXGI_FORMAT_P010 = auto()
-    DXGI_FORMAT_P016 = auto()
-    DXGI_FORMAT_420_OPAQUE = auto()
-    DXGI_FORMAT_YUY2 = auto()
-    DXGI_FORMAT_Y210 = auto()
-    DXGI_FORMAT_Y216 = auto()
-    DXGI_FORMAT_NV11 = auto()
-    DXGI_FORMAT_AI44 = auto()
-    DXGI_FORMAT_IA44 = auto()
-    DXGI_FORMAT_P8 = auto()
-    DXGI_FORMAT_A8P8 = auto()
-    DXGI_FORMAT_B4G4R4A4_UNORM = auto()
-    DXGI_FORMAT_P208 = auto()
-    DXGI_FORMAT_V208 = auto()
-    DXGI_FORMAT_V408 = auto()
-    DXGI_FORMAT_FORCE_UINT = auto()
-
-
-def DataclassFromBytes(dataclass):
-    class LoadableDataclass(dataclass):
-        def __init__(self, bytes=None):
-            super(LoadableDataclass, self).__init__()
-            if bytes:
-                self.fromBytes(bytes)
-
-        def fromStream(self, byteStream):
-            self.fromBytes(byteStream.read(struct.calcsize(self.structFormat)))
-
-        def fromBytes(self, bytes):
-            loaded = struct.unpack(self.structFormat, bytes)
-            fields = dataclasses.fields(self)
-            memberIndex = 0
-            for field in fields:
-                if field.metadata and "count" in field.metadata:
-                    # We have a list
-                    listed = field.type.__args__[0]
-                    myList = []
-                    for i in range(field.metadata["count"]):
-                        myList.append(listed(loaded[memberIndex]))
-                        memberIndex += 1
-                    self.__dict__[field.name] = myList
-                else:
-                    self.__dict__[field.name] = field.type(loaded[memberIndex])
-                    memberIndex += 1
-
-    return LoadableDataclass
-
-
-@DataclassFromBytes
-@dataclasses.dataclass
-class DDS_PIXELFORMAT:
-    structFormat: ClassVar[str] = "<II4sI4s4s4s4s"
-
-    class Flags(IntFlag):
-        DDPF_ALPHAPIXELS = 0x1
-        DDPF_ALPHA = 0x2
-        DDPF_FOURCC = 0x4
-        DDPF_RGB = 0x40
-        DDPF_YUV = 0x200
-        DDPF_LUMINANCE = 0x20000
-
-    dwSize: int = 0
-    dwFlags: Flags = 0
-    dwFourCC: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
-    dwRGBBitCount: int = 0
-    dwRBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
-    dwGBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
-    dwBBitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
-    dwABitMask: bytes = dataclasses.field(default_factory=lambda: b"\x00\x00\x00\x00")
-
-
-@DataclassFromBytes
-@dataclasses.dataclass
-class DDS_HEADER:
-    structFormat: ClassVar[str] = "<IIIIIII IIIIIIIIIII 32s IIIII"
-
-    class Flags(IntFlag):
-        DDSD_CAPS = 0x1
-        DDSD_HEIGHT = 0x2
-        DDSD_WIDTH = 0x4
-        DDSD_PITCH = 0x8
-        DDSD_PIXELFORMAT = 0x1000
-        DDSD_MIPMAPCOUNT = 0x20000
-        DDSD_LINEARSIZE = 0x80000
-        DDSD_DEPTH = 0x800000
-
-    class Caps(IntFlag):
-        DDSCAPS_COMPLEX = 0x8
-        DDSCAPS_MIPMAP = 0x400000
-        DDSCAPS_TEXTURE = 0x1000
-
-    class Caps2(IntFlag):
-        DDSCAPS2_CUBEMAP = 0x200
-        DDSCAPS2_CUBEMAP_POSITIVEX = 0x400
-        DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800
-        DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000
-        DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000
-        DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000
-        DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000
-        DDSCAPS2_VOLUME = 0x200000
-
-    dwSize: int = 0
-    dwFlags: Flags = 0
-    dwHeight: int = 0
-    dwWidth: int = 0
-    dwPitchOrLinearSize: int = 0
-    dwDepth: int = 0
-    dwMipMapCount: int = 0
-    dwReserved1: List[int] = dataclasses.field(default_factory=lambda: [0] * 11, metadata={"count": 11})
-    ddspf: DDS_PIXELFORMAT = dataclasses.field(default_factory=DDS_PIXELFORMAT)
-    dwCaps: Caps = 0
-    dwCaps2: Caps2 = 0
-    dwCaps3: int = 0
-    dwCaps4: int = 0
-    dwReserved2: int = 0
-
-
-@DataclassFromBytes
-@dataclasses.dataclass
-class DDS_HEADER_DXT10:
-    structFormat: ClassVar[str] = "<IIIII"
-
-    class MiscFlag(IntFlag):
-        DDS_RESOURCE_MISC_TEXTURECUBE = 0x4
-
-    class MiscFlags2(IntFlag):
-        DDS_ALPHA_MODE_UNKNOWN = 0x0
-        DDS_ALPHA_MODE_STRAIGHT = 0x1
-        DDS_ALPHA_MODE_PREMULTIPLIED = 0x2
-        DDS_ALPHA_MODE_OPAQUE = 0x3
-        DDS_ALPHA_MODE_CUSTOM = 0x4
-
-    dxgiFormat: DXGI_FORMAT = 0
-    resourceDimension: D3D10_RESOURCE_DIMENSION = 0
-    miscFlag: MiscFlag = 0
-    arraySize: int = 0
-    miscFlags2: MiscFlags2 = 0
-
-
-class UnsupportedDDSFormatException(Exception):
-    """Thrown when an unsupported DDS format or broken DDS file is given"""
-    pass
-
-
-def fourCCToDXGI(fourCC):
-    converter = {
-        b"DXT1": DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM,
-        b"DXT3": DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM,
-        b"DXT5": DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM,
-        b"BC4U": DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM,
-        b"BC4S": DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM,
-        b"ATI2": DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
-        b"BC5U": DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
-        b"BC5S": DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM,
-        b"RGBG": DXGI_FORMAT.DXGI_FORMAT_R8G8_B8G8_UNORM,
-        b"GRGB": DXGI_FORMAT.DXGI_FORMAT_G8R8_G8B8_UNORM,
-        (36).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UNORM,
-        (110).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SNORM,
-        (111).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16_FLOAT,
-        (112).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16_FLOAT,
-        (113).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_FLOAT,
-        (114).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT,
-        (115).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32G32_FLOAT,
-        (116).to_bytes(4, byteorder='little'): DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT
-        # Note: Some formats with a four character code don't have a DXGI format, e.g. pre-multiplied BC2/3 images
-    }
-    if fourCC in converter:
-        return converter[fourCC]
-
-
-dxgiToGL = {
-    DXGI_FORMAT.DXGI_FORMAT_UNKNOWN: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32F,
-                                                                            GL_IMAGE_FORMAT.GL_RGBA,
-                                                                            GL_IMAGE_FORMAT.GL_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32UI,
-                                                                           GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                           GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA32I,
-                                                                           GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                           GL_IMAGE_FORMAT.GL_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32F,
-                                                                         GL_IMAGE_FORMAT.GL_RGB,
-                                                                         GL_IMAGE_FORMAT.GL_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32UI,
-                                                                        GL_IMAGE_FORMAT.GL_RGB_INTEGER,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32B32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB32I,
-                                                                        GL_IMAGE_FORMAT.GL_RGB_INTEGER,
-                                                                        GL_IMAGE_FORMAT.GL_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
-                                                                            GL_IMAGE_FORMAT.GL_RGBA16F,
-                                                                            GL_IMAGE_FORMAT.GL_RGBA,
-                                                                            GL_IMAGE_FORMAT.GL_HALF_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16,
-                                                                            GL_IMAGE_FORMAT.GL_RGBA,
-                                                                            GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16UI,
-                                                                           GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                           GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16_SNORM,
-                                                                            GL_IMAGE_FORMAT.GL_RGBA,
-                                                                            GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16B16A16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA16I,
-                                                                           GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                           GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32G32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32F,
-                                                                      GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32UI,
-                                                                     GL_IMAGE_FORMAT.GL_RG_INTEGER,
-                                                                     GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG32I,
-                                                                     GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32G8X24_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_D32_FLOAT_S8X24_UINT: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32F,
-                                                                                  GL_IMAGE_FORMAT.GL_RG,
-                                                                                  GL_IMAGE_FORMAT.GL_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: None,
-    DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB10_A2,
-                                                                           GL_IMAGE_FORMAT.GL_RGBA,
-                                                                           GL_IMAGE_FORMAT.GL_UNSIGNED_INT_2_10_10_10_REV),
-    DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB10_A2UI,
-                                                                          GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                          GL_IMAGE_FORMAT.GL_UNSIGNED_INT_2_10_10_10_REV),
-    DXGI_FORMAT.DXGI_FORMAT_R11G11B10_FLOAT: UncompressedGLTextureFormat(((-1, 0), [b"EXT_packed_float"]),
-                                                                         GL_IMAGE_FORMAT.GL_R11F_G11F_B10F,
-                                                                         GL_IMAGE_FORMAT.GL_RGB,
-                                                                         GL_IMAGE_FORMAT.GL_UNSIGNED_INT_10F_11F_11F_REV_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8,
-                                                                        GL_IMAGE_FORMAT.GL_RGBA,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
-                                                                             GL_IMAGE_FORMAT.GL_SRGB8_ALPHA8,
-                                                                             GL_IMAGE_FORMAT.GL_RGBA,
-                                                                             GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8UI,
-                                                                       GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                       GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8_SNORM,
-                                                                        GL_IMAGE_FORMAT.GL_RGBA,
-                                                                        GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8I,
-                                                                       GL_IMAGE_FORMAT.GL_RGBA_INTEGER,
-                                                                       GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
-                                                                      GL_IMAGE_FORMAT.GL_RG16F, GL_IMAGE_FORMAT.GL_RG,
-                                                                      GL_IMAGE_FORMAT.GL_HALF_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16,
-                                                                      GL_IMAGE_FORMAT.GL_RG,
-                                                                      GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16UI,
-                                                                     GL_IMAGE_FORMAT.GL_RG_INTEGER,
-                                                                     GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16_SNORM,
-                                                                      GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16G16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG16I,
-                                                                     GL_IMAGE_FORMAT.GL_RG_INTEGER,
-                                                                     GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R32_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_D32_FLOAT: None,
-    DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32F,
-                                                                   GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_R32_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32UI,
-                                                                  GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                  GL_IMAGE_FORMAT.GL_UNSIGNED_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R32_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R32I,
-                                                                  GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                  GL_IMAGE_FORMAT.GL_INT),
-    DXGI_FORMAT.DXGI_FORMAT_R24G8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_D24_UNORM_S8_UINT: None,
-    DXGI_FORMAT.DXGI_FORMAT_R24_UNORM_X8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_X24_TYPELESS_G8_UINT: None,
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8, GL_IMAGE_FORMAT.GL_RG,
-                                                                    GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8UI,
-                                                                   GL_IMAGE_FORMAT.GL_RG_INTEGER,
-                                                                   GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8_SNORM,
-                                                                    GL_IMAGE_FORMAT.GL_RG, GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RG8I,
-                                                                   GL_IMAGE_FORMAT.GL_RG_INTEGER,
-                                                                   GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R16_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R16_FLOAT: UncompressedGLTextureFormat(((3, 0), [b"GL_ARB_half_float_pixel"]),
-                                                                   GL_IMAGE_FORMAT.GL_R16F, GL_IMAGE_FORMAT.GL_RED,
-                                                                   GL_IMAGE_FORMAT.GL_HALF_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_D16_UNORM: None,
-    DXGI_FORMAT.DXGI_FORMAT_R16_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16, GL_IMAGE_FORMAT.GL_RED,
-                                                                   GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16UI,
-                                                                  GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                  GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16_SNORM,
-                                                                   GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R16_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R16I,
-                                                                  GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                  GL_IMAGE_FORMAT.GL_SHORT),
-    DXGI_FORMAT.DXGI_FORMAT_R8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_R8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8, GL_IMAGE_FORMAT.GL_RED,
-                                                                  GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8_UINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8UI,
-                                                                 GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                 GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8_SNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8_SNORM,
-                                                                  GL_IMAGE_FORMAT.GL_RED, GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R8_SINT: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_R8I,
-                                                                 GL_IMAGE_FORMAT.GL_RED_INTEGER,
-                                                                 GL_IMAGE_FORMAT.GL_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_ALPHA8,
-                                                                  GL_IMAGE_FORMAT.GL_ALPHA,
-                                                                  GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R1_UNORM: None,
-    DXGI_FORMAT.DXGI_FORMAT_R9G9B9E5_SHAREDEXP: UncompressedGLTextureFormat(
-        ((3, 0), [b"GL_EXT_texture_shared_exponent"]), GL_IMAGE_FORMAT.GL_RGB9_E5, GL_IMAGE_FORMAT.GL_RGB,
-        GL_IMAGE_FORMAT.GL_UNSIGNED_INT_5_9_9_9_REV_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_R8G8_B8G8_UNORM: None,
-    DXGI_FORMAT.DXGI_FORMAT_G8R8_G8B8_UNORM: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                      GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                      GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB: CompressedGLTextureFormat(((-1, 0), [b"GL_EXT_texture_compression_s3tc"]),
-                                                                      GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT),
-    DXGI_FORMAT.DXGI_FORMAT_BC4_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RED_RGTC1),
-    DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_SIGNED_RED_RGTC1),
-    DXGI_FORMAT.DXGI_FORMAT_BC5_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RG_RGTC2),
-    DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM: CompressedGLTextureFormat(((3, 0), [b"GL_ARB_texture_compression_rgtc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_SIGNED_RG_RGTC2),
-    DXGI_FORMAT.DXGI_FORMAT_B5G6R5_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB,
-                                                                      GL_IMAGE_FORMAT.GL_RGB,
-                                                                      GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_5_6_5_REV),
-    DXGI_FORMAT.DXGI_FORMAT_B5G5R5A1_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB5_A1,
-                                                                        GL_IMAGE_FORMAT.GL_BGRA,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_1_5_5_5_REV),
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA8,
-                                                                        GL_IMAGE_FORMAT.GL_BGRA,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGB8,
-                                                                        GL_IMAGE_FORMAT.GL_BGRA,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: None,
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
-                                                                             GL_IMAGE_FORMAT.GL_SRGB8_ALPHA8,
-                                                                             GL_IMAGE_FORMAT.GL_BGRA,
-                                                                             GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: UncompressedGLTextureFormat(((2, 1), [b"GL_EXT_texture_sRGB"]),
-                                                                             GL_IMAGE_FORMAT.GL_SRGB8,
-                                                                             GL_IMAGE_FORMAT.GL_BGRA,
-                                                                             GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE),
-    DXGI_FORMAT.DXGI_FORMAT_BC6H_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC6H_UF16: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_BC6H_SF16: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT),
-    DXGI_FORMAT.DXGI_FORMAT_BC7_TYPELESS: None,
-    DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
-                                                                 GL_IMAGE_FORMAT.GL_COMPRESSED_RGBA_BPTC_UNORM),
-    DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM_SRGB: CompressedGLTextureFormat(((4, 2), [b"GL_ARB_texture_compression_bptc"]),
-                                                                      GL_IMAGE_FORMAT.GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM),
-    DXGI_FORMAT.DXGI_FORMAT_AYUV: None,
-    DXGI_FORMAT.DXGI_FORMAT_Y410: None,
-    DXGI_FORMAT.DXGI_FORMAT_Y416: None,
-    DXGI_FORMAT.DXGI_FORMAT_NV12: None,
-    DXGI_FORMAT.DXGI_FORMAT_P010: None,
-    DXGI_FORMAT.DXGI_FORMAT_P016: None,
-    DXGI_FORMAT.DXGI_FORMAT_420_OPAQUE: None,
-    DXGI_FORMAT.DXGI_FORMAT_YUY2: None,
-    DXGI_FORMAT.DXGI_FORMAT_Y210: None,
-    DXGI_FORMAT.DXGI_FORMAT_Y216: None,
-    DXGI_FORMAT.DXGI_FORMAT_NV11: None,
-    DXGI_FORMAT.DXGI_FORMAT_AI44: None,
-    DXGI_FORMAT.DXGI_FORMAT_IA44: None,
-    DXGI_FORMAT.DXGI_FORMAT_P8: None,
-    DXGI_FORMAT.DXGI_FORMAT_A8P8: None,
-    DXGI_FORMAT.DXGI_FORMAT_B4G4R4A4_UNORM: UncompressedGLTextureFormat(None, GL_IMAGE_FORMAT.GL_RGBA4,
-                                                                        GL_IMAGE_FORMAT.GL_BGRA,
-                                                                        GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_4_4_4_4_REV),
-    DXGI_FORMAT.DXGI_FORMAT_P208: None,
-    DXGI_FORMAT.DXGI_FORMAT_V208: None,
-    DXGI_FORMAT.DXGI_FORMAT_V408: None,
-    DXGI_FORMAT.DXGI_FORMAT_FORCE_UINT: None
-}
-
-
-def buildConverter(byteCount, usedBitCounts={8}, bitmasks=None, intmasks=None):
-    # A converter converts the data to boring BGRA with enough bits per channel to fit the original
-    glFormat = GL_IMAGE_FORMAT.GL_BGRA
-    biggestComponent = max(usedBitCounts)
-    biggestComponent = (biggestComponent + 7) // 8
-    if biggestComponent == 1:
-        packFormat = "=4B"
-        glType = GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE
-        glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA8
-    elif biggestComponent == 2:
-        packFormat = "=4H"
-        glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT
-        glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA16
-    elif biggestComponent <= 4:
-        biggestComponent == 4
-        packFormat = "=4I"
-        glType = GL_IMAGE_FORMAT.GL_UNSIGNED_INT
-        glInternalFormat = GL_IMAGE_FORMAT.GL_RGBA32F
-    multiplier = 255 ** biggestComponent
-
-    if byteCount == 1:
-        unpackFormat = "B"
-        unpackCombiner = lambda x: x
-    elif byteCount == 2:
-        unpackFormat = "H"
-        unpackCombiner = lambda x: x
-    elif byteCount == 3:
-        unpackFormat = "3s"
-
-        def unpackCombiner(x):
-            x = struct.unpack("<HB", x)
-            return x[0] + (x[1] << 16)
-    elif byteCount == 4:
-        unpackFormat = "I"
-        unpackCombiner = lambda x: x
-
-    if intmasks:
-        rIntMask, gIntMask, bIntMask, aIntMask = intmasks
-    else:
-        rIntMask = 0
-        gIntMask = 0
-        bIntMask = 0
-        aIntMask = 0
-
-    if bitmasks:
-        if "r" in bitmasks:
-            rIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["r"][:byteCount]))
-        if "g" in bitmasks:
-            gIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["g"][:byteCount]))
-        if "b" in bitmasks:
-            bIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["b"][:byteCount]))
-        if "a" in bitmasks:
-            aIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["a"][:byteCount]))
-        if "luminance" in bitmasks:
-            rIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
-            gIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
-            bIntMask = unpackCombiner(*struct.unpack("<" + unpackFormat, bitmasks["luminance"][:byteCount]))
-
-    rDivisor = 2 ** bin(rIntMask).count("1") - 1
-    gDivisor = 2 ** bin(gIntMask).count("1") - 1
-    bDivisor = 2 ** bin(bIntMask).count("1") - 1
-    aDivisor = 2 ** bin(aIntMask).count("1") - 1
-
-    rShift = (rIntMask & -rIntMask).bit_length() - 1
-    gShift = (gIntMask & -gIntMask).bit_length() - 1
-    bShift = (bIntMask & -bIntMask).bit_length() - 1
-    aShift = (aIntMask & -aIntMask).bit_length() - 1
-
-    def convert(imageData):
-        length = len(imageData) // byteCount
-        unpackString = "<" + ((str(length) + unpackFormat) if unpackFormat.isalpha() else unpackFormat * length)
-        unpacked = struct.unpack(unpackString, imageData)
-        repacked = bytearray(length * biggestComponent * 4)
-        repackIndex = 0
-        for pixel in unpacked:
-            pixel = unpackCombiner(pixel)
-            if rIntMask:
-                red = (((rIntMask & pixel) >> rShift) * multiplier) // rDivisor
-            else:
-                red = 0
-            if gIntMask:
-                green = (((gIntMask & pixel) >> gShift) * multiplier) // gDivisor
-            else:
-                green = 0
-            if bIntMask:
-                blue = (((bIntMask & pixel) >> bShift) * multiplier) // bDivisor
-            else:
-                blue = 0
-            if aIntMask:
-                alpha = (((aIntMask & pixel) >> aShift) * multiplier) // aDivisor
-            else:
-                alpha = multiplier
-            struct.pack_into(packFormat, repacked, repackIndex, blue, green, red, alpha)
-            repackIndex += biggestComponent * 4
-        return bytes(repacked)
-
-    return (convert, glInternalFormat, glFormat, glType)
-
-
-def getGLFormat(pixelFormat, dxt10Header=None):
-    # Half or more of this function may be unreachable or otherwise redundant.
-    glInternalFormat = None
-    dxgiFormat = None
-    if dxt10Header:
-        dxgiFormat = dxt10Header.dxgiFormat
-    flags = pixelFormat.dwFlags
-    if flags & pixelFormat.Flags.DDPF_FOURCC:
-        fourCC = pixelFormat.dwFourCC
-        if fourCC == b"DX10" and not dxt10Header:
-            raise UnsupportedDDSFormatException()
-        dxgiFormat = dxt10Header.dxgiFormat if dxt10Header else fourCCToDXGI(fourCC)
-
-    if dxgiFormat:
-        return dxgiToGL[dxgiFormat]
-    elif flags & (
-        pixelFormat.Flags.DDPF_ALPHA | pixelFormat.Flags.DDPF_RGB | pixelFormat.Flags.DDPF_YUV | pixelFormat.Flags.DDPF_LUMINANCE):
-        compressed = False
-
-        rBitmask = None
-        gBitmask = None
-        bBitmask = None
-        aBitmask = None
-        lumBitmask = None
-        if flags & (pixelFormat.Flags.DDPF_ALPHA | pixelFormat.Flags.DDPF_ALPHAPIXELS):
-            aBitmask = pixelFormat.dwABitMask
-        if flags & (pixelFormat.Flags.DDPF_RGB | pixelFormat.Flags.DDPF_YUV):
-            rBitmask = pixelFormat.dwRBitMask
-            gBitmask = pixelFormat.dwGBitMask
-            bBitmask = pixelFormat.dwBBitMask
-        if flags & pixelFormat.Flags.DDPF_LUMINANCE:
-            lumBitmask = pixelFormat.dwRBitMask
-
-        def bitCount(theBytes):
-            count = 0
-            for byte in theBytes:
-                count += bin(byte).count("1")
-            return count
-
-        def firstBit(theBytes):
-            index = 0
-            for byte in theBytes:
-                if byte != 0:
-                    return index + format(byte, 'b').find("1")
-                index += 8
-
-        bitCounts = dict()
-        starts = dict()
-        namedBitmasks = dict()
-        if rBitmask:
-            bitCounts["r"] = bitCount(rBitmask)
-            starts["r"] = firstBit(rBitmask)
-            namedBitmasks["r"] = rBitmask
-        if gBitmask:
-            bitCounts["g"] = bitCount(gBitmask)
-            starts["g"] = firstBit(gBitmask)
-            namedBitmasks["g"] = gBitmask
-        if bBitmask:
-            bitCounts["b"] = bitCount(bBitmask)
-            starts["b"] = firstBit(bBitmask)
-            namedBitmasks["b"] = bBitmask
-        if aBitmask:
-            bitCounts["a"] = bitCount(aBitmask)
-            starts["a"] = firstBit(aBitmask)
-            namedBitmasks["a"] = aBitmask
-        if lumBitmask:
-            bitCounts["luminance"] = bitCount(lumBitmask)
-            starts["luminance"] = firstBit(lumBitmask)
-            namedBitmasks["luminance"] = lumBitmask
-
-        toSort = []
-        for key in starts:
-            toSort.append((starts[key], key))
-        toSort.sort()
-
-        glInternalFormatName = ["GL"]
-        glRequirements = None
-
-        desc = "GL_"
-        lastBitCount = -1
-        usedBitCounts = set()
-        for pos, channel in toSort:
-            if lastBitCount != bitCounts[channel]:
-                if lastBitCount != -1:
-                    desc += str(lastBitCount)
-                lastBitCount = bitCounts[channel]
-                usedBitCounts.add(lastBitCount)
-            desc += channel
-        if len(usedBitCounts) != 1:
-            desc += str(lastBitCount)
-
-        desc = desc.upper()
-        glFormat = GL_IMAGE_FORMAT[desc] if desc in GL_IMAGE_FORMAT.__members__ else None
-
-        numComponents = len(toSort)
-        byteCount = (pixelFormat.dwRGBBitCount + 7) // 8
-        needsConversion = False
-        if len(usedBitCounts) == 1:
-            if lastBitCount == 8:
-                glType = GL_IMAGE_FORMAT.GL_UNSIGNED_BYTE
-            elif lastBitCount == 16:
-                glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT
-            elif lastBitCount == 32:
-                glType = GL_IMAGE_FORMAT.GL_UNSIGNED_INT
-            elif lastBitCount == 4:
-                if numComponents == 4:
-                    glType = GL_IMAGE_FORMAT.GL_UNSIGNED_SHORT_4_4_4_4_REV
-                else:
-                    needsConversion = True
-        if not glFormat or numComponents * lastBitCount != pixelFormat.dwRGBBitCount:
-            needsConversion = True
-
-        if needsConversion:
-            convert, glInternalFormat, glFormat, glType = buildConverter(byteCount, bitmasks=namedBitmasks)
-        else:
-            convert = None
-
-    if not glInternalFormat:
-        glInternalFormatName = "_".join(glInternalFormatName)
-        glInternalFormat = GL_IMAGE_FORMAT[
-            glInternalFormatName] if glInternalFormatName in GL_IMAGE_FORMAT.__members__ else GL_IMAGE_FORMAT.GL_RGBA
-
-    if compressed:
-        return CompressedGLTextureFormat(glRequirements, glInternalFormat)
-    else:
-        return UncompressedGLTextureFormat(glRequirements, glInternalFormat, glFormat, glType, convert)
-
-
-def sizeFromFormat(dxgiFormat, width, height):
-    blockCompressed = False
-    if dxgiFormat in {DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS,
-                      DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM,
-                      DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB,
-                      DXGI_FORMAT.DXGI_FORMAT_BC4_TYPELESS,
-                      DXGI_FORMAT.DXGI_FORMAT_BC4_UNORM,
-                      DXGI_FORMAT.DXGI_FORMAT_BC4_SNORM}:
-        blockCompressed = True
-        blockSize = 8
-    elif dxgiFormat in {DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS,
-                        DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM,
-                        DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB,
-                        DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS,
-                        DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM,
-                        DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB,
-                        DXGI_FORMAT.DXGI_FORMAT_BC5_TYPELESS,
-                        DXGI_FORMAT.DXGI_FORMAT_BC5_UNORM,
-                        DXGI_FORMAT.DXGI_FORMAT_BC5_SNORM,
-                        DXGI_FORMAT.DXGI_FORMAT_BC6H_TYPELESS,
-                        DXGI_FORMAT.DXGI_FORMAT_BC6H_UF16,
-                        DXGI_FORMAT.DXGI_FORMAT_BC6H_SF16,
-                        DXGI_FORMAT.DXGI_FORMAT_BC7_TYPELESS,
-                        DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM,
-                        DXGI_FORMAT.DXGI_FORMAT_BC7_UNORM_SRGB}:
-        blockCompressed = True
-        blockSize = 16
-
-    if blockCompressed:
-        return max(1, ((width + 3) // 4)) * max(1, ((height + 3) // 4)) * blockSize
-
-    if dxgiFormat <= DXGI_FORMAT.DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
-        name = dxgiFormat.name + "_"
-        count = 0
-        currentNum = ""
-        for char in name:
-            if char.isdecimal():
-                currentNum += char
-            elif currentNum != "":
-                count += int(currentNum)
-                currentNum = ""
-        pixelSize = (count + 7) // 8
-        return width * height * pixelSize
-    pass
diff --git a/libs/dds_header/src/DDS/DDSFile.py b/libs/dds_header/src/DDS/DDSFile.py
deleted file mode 100644
index 4592074..0000000
--- a/libs/dds_header/src/DDS/DDSFile.py
+++ /dev/null
@@ -1,220 +0,0 @@
-import io
-
-from PyQt6.QtCore import QCoreApplication, qCritical, QFile, QIODeviceBase
-from PyQt6.QtOpenGL import QOpenGLTexture
-
-from . import DDSDefinitions
-from .glstuff import GLTextureFormat
-
-
-class DDSReadException(Exception):
-    """Thrown if there was an error reading a DDS file"""
-    pass
-
-
-ddsCubemapFaces = {
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEX: QOpenGLTexture.CubeMapFace.CubeMapPositiveX,
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEX: QOpenGLTexture.CubeMapFace.CubeMapNegativeX,
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEY: QOpenGLTexture.CubeMapFace.CubeMapPositiveY,
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEY: QOpenGLTexture.CubeMapFace.CubeMapNegativeY,
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_POSITIVEZ: QOpenGLTexture.CubeMapFace.CubeMapPositiveZ,
-    DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP_NEGATIVEZ: QOpenGLTexture.CubeMapFace.CubeMapNegativeZ}
-
-
-class DDSFile:
-    def __init__(self, fileData: bytes, fileName: str):
-        self.fileName = fileName
-        self.header = DDSDefinitions.DDS_HEADER()
-        self.dxt10Header = None
-        self.glFormat: GLTextureFormat = None
-        self.fileData = fileData
-        self.data = None
-        self.isCubemap = None
-
-    @classmethod
-    def fromFile(cls, fileName: str):
-        file = QFile(fileName)
-        if file.open(QIODeviceBase.OpenModeFlag.ReadOnly):
-            fileData = file.readAll()
-        else:
-            raise DDSReadException()
-        return cls(fileData.data(), fileName)
-
-    def load(self):
-        with io.BytesIO(self.fileData) as file:
-            magicNumber = file.read(4)
-            if magicNumber != DDSDefinitions.DDS_MAGIC_NUMBER:
-                qCritical(self.tr("Magic number mismatch."))
-                raise DDSReadException()
-
-            self.header.fromStream(file)
-
-            if self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_FOURCC:
-                fourCC = self.header.ddspf.dwFourCC
-                if fourCC == b"DX10":
-                    self.dxt10Header = DDSDefinitions.DDS_HEADER_DXT10()
-                    self.dxt10Header.fromStream(file)
-            else:
-                fourCC = None
-
-            self.glFormat = DDSDefinitions.getGLFormat(self.header.ddspf, self.dxt10Header)
-            self.data = []
-            # Do this once per layer/mip level whatever, (times one per scanline if uncompressed). Also, potentially recompute this based on the format and size in case writers lie.
-            # self.data.append(file.read(self.header.dwPitchOrLinearSize))
-
-            layerCount = 1
-            if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
-                self.isCubemap = True
-                layerCount = 0
-                for face in ddsCubemapFaces:
-                    if self.header.dwCaps2 & face:
-                        layerCount += 1
-            else:
-                self.isCubemap = False
-
-            for layer in range(layerCount):
-                nextWidth = self.header.dwWidth
-                nextHeight = self.header.dwHeight
-                mipCount = self.mipLevels()
-                for level in range(mipCount):
-                    if self.header.ddspf.dwFlags & (
-                        DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHA | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_RGB | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_YUV | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_LUMINANCE):
-                        size = nextWidth * nextHeight * ((self.header.ddspf.dwRGBBitCount + 7) // 8)
-                    elif fourCC:
-                        if self.dxt10Header:
-                            dxgiFormat = self.dxt10Header.dxgiFormat
-                        else:
-                            dxgiFormat = DDSDefinitions.fourCCToDXGI(fourCC)
-                        size = DDSDefinitions.sizeFromFormat(dxgiFormat, nextWidth, nextHeight)
-                    self.data.append(file.read(size))
-                    nextWidth = max(nextWidth // 2, 1)
-                    nextHeight = max(nextHeight // 2, 1)
-
-    def getDescription(self):
-        format = ""
-        # DX10 header says the format enum
-        if self.dxt10Header is not None:
-            format = self.dxt10Header.dxgiFormat.name.replace("DXGI_FORMAT_", "")
-        # Pixel Format says the FourCC
-        elif self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_FOURCC:
-            fourCC = self.header.ddspf.dwFourCC
-            format = self.tr("{0} (equivalent to {1})").format(fourCC.decode('ascii'),
-                                                                 DDSDefinitions.fourCCToDXGI(fourCC).name.replace(
-                                                                     "DXGI_FORMAT_", ""))
-        # We've got bitmasks for the colour channels
-        else:
-            # This could be prettier if there was logic to detect that certain common bitmasks represented things more easily represented, like RGBA8
-            if self.header.ddspf.dwFlags & (
-                DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_RGB | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_YUV):
-                format += self.tr("Red bitmask {0}, Green bitmask {1}, Blue bitmask {2}").format(
-                    self.header.ddspf.dwRBitMask.hex().upper(), self.header.ddspf.dwGBitMask.hex().upper(),
-                    self.header.ddspf.dwBBitMask.hex().upper())
-            if self.header.ddspf.dwFlags & DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_LUMINANCE:
-                if format != "":
-                    format += ", "
-                format += self.tr("Luminance bitmask {0}").format(self.header.ddspf.dwRBitMask.hex().upper())
-            if self.header.ddspf.dwFlags & (
-                DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHA | DDSDefinitions.DDS_PIXELFORMAT.Flags.DDPF_ALPHAPIXELS):
-                if format != "":
-                    format += ", "
-                format += self.tr("Alpha bitmask {0}").format(self.header.ddspf.dwABitMask.hex().upper())
-
-        size = self.tr("{0}×{1}").format(self.header.dwWidth, self.header.dwHeight)
-
-        dimensions = self.tr("Cubemap") if self.isCubemap else self.tr("2D")
-
-        mipmaps = self.tr("Mipmapped") if self.mipLevels() != 1 else self.tr("No mipmaps")
-
-        return self.tr("{0}, {1} {2}, {3}").format(format, size, dimensions, mipmaps)
-
-    def mipLevels(self):
-        if self.header.dwFlags & DDSDefinitions.DDS_HEADER.Flags.DDSD_MIPMAPCOUNT:
-            return self.header.dwMipMapCount
-        else:
-            return 1
-
-    def asQOpenGLTexture(self, gl, context):
-        if not self.data:
-            return
-
-        if self.glFormat.requirements:
-            minVersion, extensions = self.glFormat.requirements
-            glVersion = (gl.glGetIntegerv(gl.GL_MAJOR_VERSION), gl.glGetIntegerv(gl.GL_MINOR_VERSION))
-            if glVersion < minVersion or minVersion < (1, 0):
-                compatible = False
-                for extension in extensions:
-                    if context.hasExtension(extension):
-                        compatible = True
-                        break
-                if not compatible:
-                    qCritical(self.tr("OpenGL driver incompatible with texture format."))
-                    return None
-
-        if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
-            texture = QOpenGLTexture(QOpenGLTexture.Target.TargetCubeMap)
-            if self.header.dwWidth != self.header.dwHeight:
-                qCritical(self.tr("Cubemap faces must be square"))
-                return None
-        else:
-            # Assume GL_TEXTURE_2D for now
-            texture = QOpenGLTexture(QOpenGLTexture.Target.Target2D)
-        # Assume single layer for now
-        # self.texture.setLayers(1)
-        mipCount = self.mipLevels()
-        texture.setAutoMipMapGenerationEnabled(False)
-        texture.setMipLevels(mipCount)
-        texture.setMipLevelRange(0, mipCount - 1)
-        texture.setSize(self.header.dwWidth, self.header.dwHeight)
-        texture.setFormat(QOpenGLTexture.TextureFormat(self.glFormat.internalFormat))
-        texture.allocateStorage()
-
-        if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
-            # Lisa hasn't whipped David Wang into shape yet. At least there are fewer bugs than under Raja.
-            # The specific bug has been reported and AMD "will try to reproduce it soon"
-            # MO 2.5.0: Radeon-specific code is causing crashing on the latest drivers
-            # Some cubemaps fail to render with or without these modifications
-            # noDSA = "Radeon" in gl.glGetString(gl.GL_RENDERER) and self.glFormat.compressed
-            noDSA = False
-            if noDSA:
-                texture.bind()
-            faceIndex = 0
-            for face in ddsCubemapFaces:
-                if self.header.dwCaps2 & face:
-                    for i in range(mipCount):
-                        if self.glFormat.compressed:
-                            if not noDSA:
-                                texture.setCompressedData(i, 0, ddsCubemapFaces[face],
-                                                          len(self.data[faceIndex * mipCount + i]),
-                                                          self.data[faceIndex * mipCount + i])
-                            else:
-                                gl.glCompressedTexSubImage2D(ddsCubemapFaces[face], i, 0, 0,
-                                                             max(self.header.dwWidth // 2 ** i, 1),
-                                                             max(self.header.dwHeight // 2 ** i, 1),
-                                                             self.glFormat.internalFormat,
-                                                             len(self.data[faceIndex * mipCount + i]),
-                                                             self.data[faceIndex * mipCount + i])
-                        else:
-                            texture.setData(i, 0, ddsCubemapFaces[face], QOpenGLTexture.PixelFormat(self.glFormat.format), QOpenGLTexture.PixelType(self.glFormat.type),
-                                            self.glFormat.converter(self.data[faceIndex * mipCount + i]))
-                    faceIndex += 1
-            if noDSA:
-                texture.release()
-        else:
-            for i in range(mipCount):
-                if self.glFormat.compressed:
-                    texture.setCompressedData(i, 0, len(self.data[i]), self.data[i])
-                else:
-
-                    texture.setData(i, 0, QOpenGLTexture.PixelFormat(self.glFormat.format), QOpenGLTexture.PixelType(self.glFormat.type),
-                                    self.glFormat.converter(self.data[i]))
-
-        texture.setWrapMode(QOpenGLTexture.WrapMode.ClampToEdge)
-
-        if self.glFormat.samplerType != "F":
-            # integer textures can't be filtered
-            texture.setMinMagFilters(QOpenGLTexture.Filter.NearestMipMapNearest, QOpenGLTexture.Filter.Nearest)
-
-        return texture
-
-    def tr(self, str):
-        return QCoreApplication.translate("DDSFile", str)
diff --git a/libs/dds_header/src/DDS/__init__.py b/libs/dds_header/src/DDS/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/libs/dds_header/src/DDS/__init__.py
+++ /dev/null
diff --git a/libs/dds_header/src/DDS/glstuff.py b/libs/dds_header/src/DDS/glstuff.py
deleted file mode 100644
index 314d48f..0000000
--- a/libs/dds_header/src/DDS/glstuff.py
+++ /dev/null
@@ -1,205 +0,0 @@
-from enum import IntEnum
-
-
-class GL_IMAGE_FORMAT(IntEnum):
-    GL_BYTE = 0x1400
-    GL_UNSIGNED_BYTE = 0x1401
-    GL_SHORT = 0x1402
-    GL_UNSIGNED_SHORT = 0x1403
-    GL_INT = 0x1404
-    GL_UNSIGNED_INT = 0x1405
-    GL_FLOAT = 0x1406
-    GL_HALF_FLOAT = 0x140B
-    GL_COLOR_INDEX = 0x1900
-    GL_STENCIL_INDEX = 0x1901
-    GL_DEPTH_COMPONENT = 0x1902
-    GL_RED = 0x1903
-    GL_GREEN = 0x1904
-    GL_BLUE = 0x1905
-    GL_ALPHA = 0x1906
-    GL_RGB = 0x1907
-    GL_RGBA = 0x1908
-    GL_LUMINANCE = 0x1909
-    GL_LUMINANCE_ALPHA = 0x190A
-    GL_BITMAP = 0x1A00
-    GL_R3_G3_B2 = 0x2A10
-    GL_UNSIGNED_BYTE_3_3_2 = 0x8032
-    GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033
-    GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034
-    GL_UNSIGNED_INT_8_8_8_8 = 0x8035
-    GL_UNSIGNED_INT_10_10_10_2 = 0x8036
-    GL_ALPHA4 = 0x803B
-    GL_ALPHA8 = 0x803C
-    GL_ALPHA12 = 0x803D
-    GL_ALPHA16 = 0x803E
-    GL_LUMINANCE4 = 0x803F
-    GL_LUMINANCE8 = 0x8040
-    GL_LUMINANCE12 = 0x8041
-    GL_LUMINANCE16 = 0x8042
-    GL_LUMINANCE4_ALPHA4 = 0x8043
-    GL_LUMINANCE6_ALPHA2 = 0x8044
-    GL_LUMINANCE8_ALPHA8 = 0x8045
-    GL_LUMINANCE12_ALPHA4 = 0x8046
-    GL_LUMINANCE12_ALPHA12 = 0x8047
-    GL_LUMINANCE16_ALPHA16 = 0x8048
-    GL_INTENSITY = 0x8049
-    GL_INTENSITY4 = 0x804A
-    GL_INTENSITY8 = 0x804B
-    GL_INTENSITY12 = 0x804C
-    GL_INTENSITY16 = 0x804D
-    GL_RGB4 = 0x804F
-    GL_RGB5 = 0x8050
-    GL_RGB8 = 0x8051
-    GL_RGB10 = 0x8052
-    GL_RGB12 = 0x8053
-    GL_RGB16 = 0x8054
-    GL_RGBA2 = 0x8055
-    GL_RGBA4 = 0x8056
-    GL_RGB5_A1 = 0x8057
-    GL_RGBA8 = 0x8058
-    GL_RGB10_A2 = 0x8059
-    GL_RGBA12 = 0x805A
-    GL_RGBA16 = 0x805B
-    GL_BGR = 0x80E0
-    GL_BGRA = 0x80E1
-    GL_DEPTH_COMPONENT16 = 0x81A5
-    GL_DEPTH_COMPONENT24 = 0x81A6
-    GL_DEPTH_COMPONENT32 = 0x81A7
-    GL_COMPRESSED_RED = 0x8225
-    GL_COMPRESSED_RG = 0x8226
-    GL_RG = 0x8227
-    GL_RG_INTEGER = 0x8228
-    GL_R8 = 0x8229
-    GL_R16 = 0x822A
-    GL_RG8 = 0x822B
-    GL_RG16 = 0x822C
-    GL_R16F = 0x822D
-    GL_R32F = 0x822E
-    GL_RG16F = 0x822F
-    GL_RG32F = 0x8230
-    GL_R8I = 0x8231
-    GL_R8UI = 0x8232
-    GL_R16I = 0x8233
-    GL_R16UI = 0x8234
-    GL_R32I = 0x8235
-    GL_R32UI = 0x8236
-    GL_RG8I = 0x8237
-    GL_RG8UI = 0x8238
-    GL_RG16I = 0x8239
-    GL_RG16UI = 0x823A
-    GL_RG32I = 0x823B
-    GL_RG32UI = 0x823C
-    GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362
-    GL_UNSIGNED_SHORT_5_6_5 = 0x8363
-    GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364
-    GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365
-    GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366
-    GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367
-    GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368
-    GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0
-    GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1
-    GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2
-    GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3
-    GL_COMPRESSED_ALPHA = 0x84E9
-    GL_COMPRESSED_LUMINANCE = 0x84EA
-    GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB
-    GL_COMPRESSED_INTENSITY = 0x84EC
-    GL_COMPRESSED_RGB = 0x84ED
-    GL_COMPRESSED_RGBA = 0x84EE
-    GL_DEPTH_STENCIL = 0x84F9
-    GL_RGBA32F = 0x8814
-    GL_RGB32F = 0x8815
-    GL_RGBA16F = 0x881A
-    GL_RGB16F = 0x881B
-    GL_R11F_G11F_B10F = 0x8C3A
-    GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B  # EXT_packed_float
-    GL_RGB9_E5 = 0x8C3D
-    GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E  # EXT_texture_shared_exponent
-    GL_SRGB = 0x8C40
-    GL_SRGB8 = 0x8C41
-    GL_SRGB_ALPHA = 0x8C42
-    GL_SRGB8_ALPHA8 = 0x8C43
-    GL_SLUMINANCE_ALPHA = 0x8C44
-    GL_SLUMINANCE8_ALPHA8 = 0x8C45
-    GL_SLUMINANCE = 0x8C46
-    GL_SLUMINANCE8 = 0x8C47
-    GL_COMPRESSED_SRGB = 0x8C48
-    GL_COMPRESSED_SRGB_ALPHA = 0x8C49
-    GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C
-    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D
-    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E
-    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F
-    GL_RGBA32UI = 0x8D70
-    GL_RGB32UI = 0x8D71
-    GL_RGBA16UI = 0x8D76
-    GL_RGB16UI = 0x8D77
-    GL_RGBA8UI = 0x8D7C
-    GL_RGB8UI = 0x8D7D
-    GL_RGBA32I = 0x8D82
-    GL_RGB32I = 0x8D83
-    GL_RGBA16I = 0x8D88
-    GL_RGB16I = 0x8D89
-    GL_RGBA8I = 0x8D8E
-    GL_RGB8I = 0x8D8F
-    GL_RED_INTEGER = 0x8D94
-    GL_RGB_INTEGER = 0x8D98
-    GL_RGBA_INTEGER = 0x8D99
-    GL_BGR_INTEGER = 0x8D9A
-    GL_BGRA_INTEGER = 0x8D9B
-    GL_COMPRESSED_RED_RGTC1 = 0x8DBB
-    GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC
-    GL_COMPRESSED_RG_RGTC2 = 0x8DBD
-    GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE
-    GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C
-    GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D
-    GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E
-    GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F
-    GL_R8_SNORM = 0x8F94
-    GL_RG8_SNORM = 0x8F95
-    GL_RGB8_SNORM = 0x8F96
-    GL_RGBA8_SNORM = 0x8F97
-    GL_R16_SNORM = 0x8F98
-    GL_RG16_SNORM = 0x8F99
-    GL_RGB16_SNORM = 0x8F9A
-    GL_RGBA16_SNORM = 0x8F9B
-    GL_RGB10_A2UI = 0x906F
-    GL_COMPRESSED_R11_EAC = 0x9270
-    GL_COMPRESSED_SIGNED_R11_EAC = 0x9271
-    GL_COMPRESSED_RG11_EAC = 0x9272
-    GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273
-    GL_COMPRESSED_RGB8_ETC2 = 0x9274
-    GL_COMPRESSED_SRGB8_ETC2 = 0x9275
-    GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276
-    GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277
-    GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278
-    GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279
-
-
-class GLTextureFormat:
-    def __init__(self, requirements, internalFormat, compressed):
-        self.requirements = requirements
-        self.internalFormat = internalFormat
-        self.compressed = compressed
-
-        if internalFormat.name.endswith("UI"):
-            self.samplerType = "UI"
-        elif internalFormat.name.endswith("I"):
-            self.samplerType = "I"
-        else:
-            self.samplerType = "F"
-
-
-class CompressedGLTextureFormat(GLTextureFormat):
-    def __init__(self, requirements, internalFormat):
-        super().__init__(requirements, internalFormat, True)
-
-
-class UncompressedGLTextureFormat(GLTextureFormat):
-    def __init__(self, requirements, internalFormat, format, type, converter=None):
-        super().__init__(requirements, internalFormat, False)
-        self.format = format
-        self.type = type
-        if converter:
-            self.converter = converter
-        else:
-            self.converter = lambda x: x
diff --git a/libs/dds_header/src/DDSPreview.py b/libs/dds_header/src/DDSPreview.py
deleted file mode 100644
index 78ffffc..0000000
--- a/libs/dds_header/src/DDSPreview.py
+++ /dev/null
@@ -1,528 +0,0 @@
-import struct
-import sys
-import threading
-import enum
-
-from PyQt6.QtCore import QCoreApplication, qDebug, Qt, QSize
-from PyQt6.QtGui import QColor, QOpenGLContext, QSurfaceFormat, QMatrix4x4, QVector4D
-from PyQt6.QtOpenGLWidgets import QOpenGLWidget
-from PyQt6.QtWidgets import QGridLayout, QLabel, QPushButton, QWidget, QColorDialog, QComboBox
-from PyQt6.QtOpenGL import QOpenGLBuffer, QOpenGLDebugLogger, QOpenGLShader, QOpenGLShaderProgram, QOpenGLTexture, \
-    QOpenGLVersionProfile, QOpenGLVertexArrayObject, QOpenGLFunctions_4_1_Core, QOpenGLVersionFunctionsFactory
-
-from DDS.DDSFile import DDSFile
-
-if "mobase" not in sys.modules:
-    import mobase
-
-vertexShader2D = """
-#version 150
-
-uniform float aspectRatioRatio;
-
-in vec4 position;
-in vec2 texCoordIn;
-
-out vec2 texCoord;
-
-void main()
-{
-    texCoord = texCoordIn;
-    gl_Position = position;
-    if (aspectRatioRatio >= 1.0)
-        gl_Position.y /= aspectRatioRatio;
-    else
-        gl_Position.x *= aspectRatioRatio;
-}
-"""
-
-vertexShaderCube = """
-#version 150
-
-uniform float aspectRatioRatio;
-
-in vec4 position;
-in vec2 texCoordIn;
-
-out vec2 texCoord;
-
-void main()
-{
-    texCoord = texCoordIn;
-    gl_Position = position;
-}
-"""
-
-fragmentShaderFloat = """
-#version 150
-
-uniform sampler2D aTexture;
-uniform mat4 channelMatrix;
-uniform vec4 channelOffset;
-
-in vec2 texCoord;
-
-void main()
-{
-    gl_FragData[0] = channelMatrix *  texture(aTexture, texCoord) + channelOffset;
-}
-"""
-
-fragmentShaderUInt = """
-#version 150
-
-uniform usampler2D aTexture;
-uniform mat4 channelMatrix;
-uniform vec4 channelOffset;
-
-in vec2 texCoord;
-
-void main()
-{
-    // autofilled alpha is 1, so if we have a scaling factor, we need separate ones for luminance and alpha
-    gl_FragData[0] = channelMatrix * texture(aTexture, texCoord) + channelOffset;
-}
-"""
-
-fragmentShaderSInt = """
-#version 150
-
-uniform isampler2D aTexture;
-uniform mat4 channelMatrix;
-uniform vec4 channelOffset;
-
-in vec2 texCoord;
-
-void main()
-{
-    // autofilled alpha is 1, so if we have a scaling factor and offset, we need separate ones for luminance and alpha
-    gl_FragData[0] = channelMatrix * texture(aTexture, texCoord) + channelOffset;
-}
-"""
-
-fragmentShaderCube = """
-#version 150
-
-uniform samplerCube aTexture;
-uniform mat4 channelMatrix;
-uniform vec4 channelOffset;
-
-in vec2 texCoord;
-
-const float PI = 3.1415926535897932384626433832795;
-
-void main()
-{
-    float theta = -2.0 * PI * texCoord.x;
-    float phi = PI * texCoord.y;
-    gl_FragData[0] = channelMatrix * texture(aTexture, vec3(sin(theta) * sin(phi), cos(theta) * sin(phi), cos(phi))) + channelOffset;
-}
-"""
-
-transparencyVS = """
-#version 150
-
-in vec4 position;
-
-void main()
-{
-    gl_Position = position;
-}
-"""
-
-transparencyFS = """
-#version 150
-
-uniform vec4 backgroundColour;
-
-void main()
-{
-    float x = gl_FragCoord.x;
-    float y = gl_FragCoord.y;
-    x = mod(x, 16.0);
-    y = mod(y, 16.0);
-    gl_FragData[0] = x < 8.0 ^^ y < 8.0 ? vec4(vec3(191.0/255.0), 1.0) : vec4(1.0);
-    gl_FragData[0].rgb = backgroundColour.rgb * backgroundColour.a + gl_FragData[0].rgb * (1.0 - backgroundColour.a);
-}
-"""
-
-vertices = [
-    # vertex coordinates        texture coordinates
-    -1.0, -1.0, 0.5, 1.0, 0.0, 1.0,
-    -1.0, 1.0, 0.5, 1.0, 0.0, 0.0,
-    1.0, 1.0, 0.5, 1.0, 1.0, 0.0,
-
-    -1.0, -1.0, 0.5, 1.0, 0.0, 1.0,
-    1.0, 1.0, 0.5, 1.0, 1.0, 0.0,
-    1.0, -1.0, 0.5, 1.0, 1.0, 1.0,
-]
-
-
-class DDSOptions:
-    def __init__(self, colour: QColor = QColor(0, 0, 0, 0), channelMatrix: QMatrix4x4 = QMatrix4x4(),
-                 channelOffset: QVector4D = QVector4D()):
-        # QMatrix4x4 with no arguments is the identity matrix, so no channel transformations
-        # declare member variables with None values
-        self.backgroundColour = None
-        self.channelMatrix = None
-        self.channelOffset = None
-        # initialize member variables with error checks
-        self.setBackgroundColour(colour)
-        self.setChannelMatrix(channelMatrix)
-        self.setChannelOffset(channelOffset)
-
-    def setBackgroundColour(self, colour: QColor):
-        if isinstance(colour, QColor) and colour.isValid():
-            self.backgroundColour = colour
-        else:
-            raise TypeError(str(colour) + " is not a valid QColor object.")
-
-    def getBackgroundColour(self) -> QColor:
-        return self.backgroundColour
-
-    def getChannelMatrix(self) -> QMatrix4x4:
-        return self.channelMatrix
-
-    def setChannelMatrix(self, matrix):
-        self.channelMatrix = QMatrix4x4(matrix)
-
-    def getChannelOffset(self) -> QVector4D:
-        return self.channelOffset
-
-    def setChannelOffset(self, vector):
-        self.channelOffset = QVector4D(vector)
-
-
-glVersionProfile = QOpenGLVersionProfile()
-glVersionProfile.setVersion(2, 1)
-
-
-class DDSWidget(QOpenGLWidget):
-    def __init__(self, ddsFile, ddsOptions=DDSOptions(), debugContext=False, parent=None, f=Qt.WindowType(0)):
-        super(DDSWidget, self).__init__(parent, f)
-
-        self.ddsFile = ddsFile
-
-        self.ddsOptions = ddsOptions
-
-        self.clean = True
-
-        self.logger = None
-
-        self.program = None
-        self.transparecyProgram = None
-        self.texture = None
-        self.vbo = None
-        self.vao = None
-
-        if debugContext:
-            format = QSurfaceFormat()
-            format.setOption(QSurfaceFormat.FormatOption.DebugContext)
-            self.setFormat(format)
-            self.logger = QOpenGLDebugLogger(self)
-
-    def __del__(self):
-        self.cleanup()
-
-    def __dtor__(self):
-        self.cleanup()
-
-    def initializeGL(self):
-        if self.logger:
-            self.logger.initialize()
-            self.logger.messageLogged.connect(
-                lambda message: qDebug(self.tr("OpenGL debug message: {0}").format(message.message())))
-            self.logger.startLogging()
-
-        gl = QOpenGLVersionFunctionsFactory.get(glVersionProfile)
-        QOpenGLContext.currentContext().aboutToBeDestroyed.connect(self.cleanup)
-
-        self.clean = False
-
-        fragmentShader = None
-        vertexShader = vertexShader2D
-        if self.ddsFile.isCubemap:
-            fragmentShader = fragmentShaderCube
-            vertexShader = vertexShaderCube
-            if QOpenGLContext.currentContext().hasExtension(b"GL_ARB_seamless_cube_map"):
-                GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F
-                gl.glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
-        elif self.ddsFile.glFormat.samplerType == "F":
-            fragmentShader = fragmentShaderFloat
-        elif self.ddsFile.glFormat.samplerType == "UI":
-            fragmentShader = fragmentShaderUInt
-        else:
-            fragmentShader = fragmentShaderSInt
-
-        self.program = QOpenGLShaderProgram(self)
-        self.program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Vertex, vertexShader)
-        self.program.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Fragment, fragmentShader)
-        self.program.bindAttributeLocation("position", 0)
-        self.program.bindAttributeLocation("texCoordIn", 1)
-        self.program.link()
-
-        self.transparecyProgram = QOpenGLShaderProgram(self)
-        self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Vertex, transparencyVS)
-        self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.ShaderTypeBit.Fragment, transparencyFS)
-        self.transparecyProgram.bindAttributeLocation("position", 0)
-        self.transparecyProgram.link()
-
-        self.vao = QOpenGLVertexArrayObject(self)
-        vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
-
-        self.vbo = QOpenGLBuffer(QOpenGLBuffer.Type.VertexBuffer)
-        self.vbo.create()
-        self.vbo.bind()
-
-        theBytes = struct.pack("%sf" % len(vertices), *vertices)
-        self.vbo.allocate(theBytes, len(theBytes))
-
-        gl.glEnableVertexAttribArray(0)
-        gl.glEnableVertexAttribArray(1)
-        gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, False, 6 * 4, 0)
-        gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 6 * 4, 4 * 4)
-
-        self.texture = self.ddsFile.asQOpenGLTexture(gl, QOpenGLContext.currentContext())
-
-    def resizeGL(self, w, h):
-        aspectRatioTex = self.texture.width() / self.texture.height() if self.texture else 1.0
-        aspectRatioWidget = w / h
-        ratioRatio = aspectRatioTex / aspectRatioWidget
-
-        self.program.bind()
-        self.program.setUniformValue("aspectRatioRatio", ratioRatio)
-        self.program.release()
-
-    def paintGL(self):
-        gl = QOpenGLVersionFunctionsFactory.get(glVersionProfile)
-
-        vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
-
-        # Draw checkerboard so transparency is obvious
-        self.transparecyProgram.bind()
-
-        backgroundColour = self.ddsOptions.getBackgroundColour()
-        if backgroundColour and backgroundColour.isValid():
-            self.transparecyProgram.setUniformValue("backgroundColour", backgroundColour)
-
-        gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
-
-        self.transparecyProgram.release()
-
-        self.program.bind()
-
-        if self.texture:
-            self.texture.bind()
-
-        gl.glEnable(gl.GL_BLEND)
-        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
-
-        self.program.setUniformValue("channelMatrix", self.ddsOptions.getChannelMatrix())
-        self.program.setUniformValue("channelOffset", self.ddsOptions.getChannelOffset())
-
-        gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
-
-        if self.texture:
-            self.texture.release()
-        self.program.release()
-
-    def cleanup(self):
-        if not self.clean:
-            self.makeCurrent()
-
-            self.program = None
-            self.transparecyProgram = None
-            if self.texture:
-                self.texture.destroy()
-            self.texture = None
-            self.vbo.destroy()
-            self.vbo = None
-            self.vao.destroy()
-            self.vao = None
-
-            self.doneCurrent()
-            self.clean = True
-
-    def tr(self, str):
-        return QCoreApplication.translate("DDSWidget", str)
-
-
-class ColourChannels(enum.Enum):
-    RGBA = "Colour and Alpha"
-    RGB = "Colour"
-    A = "Alpha"
-    R = "Red"
-    G = "Green"
-    B = "Blue"
-
-
-class DDSChannelManager:
-    def __init__(self, channels: ColourChannels):
-        self.channels = channels
-
-    def setChannels(self, options: DDSOptions, channels: ColourChannels):
-        self.channels = channels
-
-        def drawColour(alpha: bool):
-            colorMatrix = QMatrix4x4()
-            colorOffset = QVector4D()
-            if not alpha:
-                colorMatrix[3, 3] = 0
-                colorOffset.setW(1.0)
-            options.setChannelMatrix(colorMatrix)
-            options.setChannelOffset(colorOffset)
-
-        def drawGrayscale(channel: ColourChannels):
-            colorOffset = QVector4D(0, 0, 0, 1)
-            channelVector = [0, 0, 0, 0]
-            if channels == ColourChannels.R:
-                channelVector[0] = 1
-            elif channel == ColourChannels.G:
-                channelVector[1] = 1
-            elif channel == ColourChannels.B:
-                channelVector[2] = 1
-            elif channels == ColourChannels.A:
-                channelVector[3] = 1
-            else:
-                raise ValueError("channel must be a single color channel.")
-            alphaVector = [0, 0, 0, 0]
-            colorMatrix = channelVector * 3 + alphaVector
-            options.setChannelMatrix(colorMatrix)
-            options.setChannelOffset(colorOffset)
-
-        if channels == ColourChannels.RGBA:
-            drawColour(True)
-        elif channels == ColourChannels.RGB:
-            drawColour(False)
-        else:
-            drawGrayscale(channels)
-
-
-class DDSPreview(mobase.IPluginPreview):
-
-    def __init__(self):
-        super().__init__()
-        self.__organizer = None
-        self.options = None
-        self.channelManager = None
-
-    def init(self, organizer: mobase.IOrganizer):
-        self.__organizer = organizer
-        savedColour = QColor(self.pluginSetting("background r"), self.pluginSetting("background g"),
-                             self.pluginSetting("background b"), self.pluginSetting("background a"))
-        try:
-            savedChannels = ColourChannels[self.pluginSetting("channels")]
-        except KeyError:
-            savedChannels = ColourChannels.RGBA
-        self.options = DDSOptions(savedColour)
-        self.channelManager = DDSChannelManager(savedChannels)
-        self.channelManager.setChannels(self.options, savedChannels)
-        return True
-
-    def pluginSetting(self, name):
-        return self.__organizer.pluginSetting(self.name(), name)
-
-    def setPluginSetting(self, name, value):
-        self.__organizer.setPluginSetting(self.name(), name, value)
-
-    def name(self):
-        return "DDS Preview Plugin"
-
-    def author(self):
-        return "AnyOldName3"
-
-    def description(self):
-        return self.tr("Lets you preview DDS files by actually uploading them to the GPU.")
-
-    def version(self):
-        return mobase.VersionInfo(1, 0, 1, 0)
-
-    def settings(self):
-        return [mobase.PluginSetting("log gl errors", self.tr(
-            "If enabled, log OpenGL errors and debug messages. May decrease performance."), False),
-                mobase.PluginSetting("background r", self.tr("Red channel of background colour"), 0),
-                mobase.PluginSetting("background g", self.tr("Green channel of background colour"), 0),
-                mobase.PluginSetting("background b", self.tr("Blue channel of background colour"), 0),
-                mobase.PluginSetting("background a", self.tr("Alpha channel of background colour"), 0),
-                mobase.PluginSetting("channels", self.tr("The colour channels that are displayed."),
-                                     ColourChannels.RGBA.name)]
-
-    def supportedExtensions(self) -> set[str]:
-        return {"dds"}
-
-    def supportsArchives(self) -> bool:
-        return True
-
-    def genFilePreview(self, fileName: str, maxSize: QSize) -> QWidget:
-        return self.previewFromDDSFile(DDSFile.fromFile(fileName))
-
-    def genDataPreview(self, fileData: bytes, fileName: str, maxSize: QSize) -> QWidget:
-        return self.previewFromDDSFile(DDSFile(fileData, fileName))
-
-    def previewFromDDSFile(self, ddsFile: DDSFile) -> QWidget:
-        ddsFile.load()
-        layout = QGridLayout()
-        # Image grows before label and button
-        layout.setRowStretch(0, 1)
-        # Label grows before button
-        layout.setColumnStretch(0, 1)
-        layout.addWidget(self.__makeLabel(ddsFile), 1, 0, 1, 1)
-
-        ddsWidget = DDSWidget(ddsFile, self.options, self.__organizer.pluginSetting(self.name(), "log gl errors"))
-        layout.addWidget(ddsWidget, 0, 0, 1, 3)
-
-        layout.addWidget(self.__makeColourButton(ddsWidget), 1, 2, 1, 1)
-        layout.addWidget(self.__makeChannelsButton(ddsWidget), 1, 1, 1, 1)
-
-        widget = QWidget()
-        widget.setLayout(layout)
-        return widget
-
-    def tr(self, str):
-        return QCoreApplication.translate("DDSPreview", str)
-
-    def __makeLabel(self, ddsFile):
-        label = QLabel(ddsFile.getDescription())
-        label.setWordWrap(True)
-        label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
-        return label
-
-    def __makeColourButton(self, ddsWidget):
-        button = QPushButton(self.tr("Pick background colour"))
-
-        def pickColour(unused):
-            newColour = QColorDialog.getColor(self.options.getBackgroundColour(), button, "Background colour",
-                                              QColorDialog.ColorDialogOption.ShowAlphaChannel)
-            if newColour.isValid():
-                self.setPluginSetting("background r", newColour.red())
-                self.setPluginSetting("background g", newColour.green())
-                self.setPluginSetting("background b", newColour.blue())
-                self.setPluginSetting("background a", newColour.alpha())
-                self.options.setBackgroundColour(newColour)
-                ddsWidget.update()
-
-        button.clicked.connect(pickColour)
-        return button
-
-    def __makeChannelsButton(self, ddsWidget):
-        listwidget = QComboBox()
-        channelKeys = [e.name for e in ColourChannels]
-        channelNames = [e.value for e in ColourChannels]
-
-        listwidget.addItems(channelNames)
-        listwidget.setCurrentText(self.channelManager.channels.value)
-        listwidget.setToolTip(self.tr("Select what colour channels are displayed."))
-
-        listwidget.showEvent = lambda _: listwidget.setCurrentText(self.channelManager.channels.value)
-
-        def onChanged(newIndex):
-            self.channelManager.setChannels(self.options, ColourChannels[channelKeys[newIndex]])
-            self.setPluginSetting("channels", self.channelManager.channels.name)
-            ddsWidget.update()
-
-        listwidget.currentIndexChanged.connect(onChanged)
-        return listwidget
-
-
-def createPlugin():
-    return DDSPreview()
diff --git a/libs/dds_header/src/DDSPreview_en.ts b/libs/dds_header/src/DDSPreview_en.ts
deleted file mode 100644
index bc6308a..0000000
--- a/libs/dds_header/src/DDSPreview_en.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE TS>
-<TS version="2.0">
-  <context>
-    <name>DDSFile</name>
-    <message>
-      <location filename="DDS\DDSFile.py" line="47" />
-      <source>Magic number mismatch.</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="101" />
-      <source>{0} (equivalent to {1})</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="109" />
-      <source>Red bitmask {0}, Green bitmask {1}, Blue bitmask {2}</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="115" />
-      <source>Luminance bitmask {0}</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="120" />
-      <source>Alpha bitmask {0}</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="122" />
-      <source>{0}×{1}</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="124" />
-      <source>Cubemap</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="124" />
-      <source>2D</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="126" />
-      <source>Mipmapped</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="126" />
-      <source>No mipmaps</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="128" />
-      <source>{0}, {1} {2}, {3}</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="150" />
-      <source>OpenGL driver incompatible with texture format.</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDS\DDSFile.py" line="156" />
-      <source>Cubemap faces must be square</source>
-      <translation type="unfinished" />
-    </message>
-  </context>
-  <context>
-    <name>DDSPreview</name>
-    <message>
-      <location filename="DDSPreview.py" line="435" />
-      <source>Lets you preview DDS files by actually uploading them to the GPU.</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="441" />
-      <source>If enabled, log OpenGL errors and debug messages. May decrease performance.</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="443" />
-      <source>Red channel of background colour</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="444" />
-      <source>Green channel of background colour</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="445" />
-      <source>Blue channel of background colour</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="446" />
-      <source>Alpha channel of background colour</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="447" />
-      <source>The colour channels that are displayed.</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="491" />
-      <source>Pick background colour</source>
-      <translation type="unfinished" />
-    </message>
-    <message>
-      <location filename="DDSPreview.py" line="514" />
-      <source>Select what colour channels are displayed.</source>
-      <translation type="unfinished" />
-    </message>
-  </context>
-  <context>
-    <name>DDSWidget</name>
-    <message>
-      <location filename="DDSPreview.py" line="234" />
-      <source>OpenGL debug message: {0}</source>
-      <translation type="unfinished" />
-    </message>
-  </context>
-</TS>