aboutsummaryrefslogtreecommitdiff
path: root/libs/dds_header/src
diff options
context:
space:
mode:
authorSulfurNitride <SulfurNitride@users.noreply.github.com>2026-02-11 02:37:39 -0600
committerSulfurNitride <SulfurNitride@users.noreply.github.com>2026-02-11 02:37:39 -0600
commit7ee008e150bc5bcf76082d726f719ee0fdfda982 (patch)
tree27fb39be241fdb5ac2734c574de678977d1856d0 /libs/dds_header/src
Fluorine Manager: full Linux port of Mod Organizer 2
Complete native Linux port with FUSE-based virtual filesystem, Proton/umu-run integration, and Flatpak packaging. Key features: - FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak) - Proton/GE-Proton/umu-run launcher with env var forwarding - Flatpak support (sandbox-aware VFS, NXM handler, umu-run) - Wine prefix management UI - Case-insensitive path resolution for Linux filesystems - QSettings-safe INI handling (avoids Bethesda INI corruption) - Portable instance support with auto-generated launcher scripts Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Diffstat (limited to 'libs/dds_header/src')
-rw-r--r--libs/dds_header/src/CMakeLists.txt6
-rw-r--r--libs/dds_header/src/DDS/DDSDefinitions.py808
-rw-r--r--libs/dds_header/src/DDS/DDSFile.py220
-rw-r--r--libs/dds_header/src/DDS/__init__.py0
-rw-r--r--libs/dds_header/src/DDS/glstuff.py205
-rw-r--r--libs/dds_header/src/DDSPreview.py528
-rw-r--r--libs/dds_header/src/DDSPreview_en.ts128
7 files changed, 1895 insertions, 0 deletions
diff --git a/libs/dds_header/src/CMakeLists.txt b/libs/dds_header/src/CMakeLists.txt
new file mode 100644
index 0000000..f4f0587
--- /dev/null
+++ b/libs/dds_header/src/CMakeLists.txt
@@ -0,0 +1,6 @@
+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
new file mode 100644
index 0000000..2d44812
--- /dev/null
+++ b/libs/dds_header/src/DDS/DDSDefinitions.py
@@ -0,0 +1,808 @@
+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
new file mode 100644
index 0000000..4592074
--- /dev/null
+++ b/libs/dds_header/src/DDS/DDSFile.py
@@ -0,0 +1,220 @@
+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
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libs/dds_header/src/DDS/__init__.py
diff --git a/libs/dds_header/src/DDS/glstuff.py b/libs/dds_header/src/DDS/glstuff.py
new file mode 100644
index 0000000..314d48f
--- /dev/null
+++ b/libs/dds_header/src/DDS/glstuff.py
@@ -0,0 +1,205 @@
+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
new file mode 100644
index 0000000..78ffffc
--- /dev/null
+++ b/libs/dds_header/src/DDSPreview.py
@@ -0,0 +1,528 @@
+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
new file mode 100644
index 0000000..bc6308a
--- /dev/null
+++ b/libs/dds_header/src/DDSPreview_en.ts
@@ -0,0 +1,128 @@
+<?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>
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-22 10:08:32 +0000