diff options
Diffstat (limited to 'libs/dds_header/src/DDS')
| -rw-r--r-- | libs/dds_header/src/DDS/DDSDefinitions.py | 808 | ||||
| -rw-r--r-- | libs/dds_header/src/DDS/DDSFile.py | 220 | ||||
| -rw-r--r-- | libs/dds_header/src/DDS/__init__.py | 0 | ||||
| -rw-r--r-- | libs/dds_header/src/DDS/glstuff.py | 205 |
4 files changed, 1233 insertions, 0 deletions
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 |