luboslenco
1515 lines
53 KiB
C
1515 lines
53 KiB
C
//
|
|
// Copyright(c) 2019 benikabocha.
|
|
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
|
|
//
|
|
|
|
#ifndef TINYDDSLOADER_H_
|
|
#define TINYDDSLOADER_H_
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
namespace tinyddsloader {
|
|
|
|
enum Result {
|
|
Success,
|
|
ErrorFileOpen,
|
|
ErrorRead,
|
|
ErrorMagicWord,
|
|
ErrorSize,
|
|
ErrorVerify,
|
|
ErrorNotSupported,
|
|
ErrorInvalidData,
|
|
};
|
|
|
|
class DDSFile {
|
|
public:
|
|
static const char Magic[4];
|
|
|
|
enum class PixelFormatFlagBits : uint32_t {
|
|
FourCC = 0x00000004,
|
|
RGB = 0x00000040,
|
|
RGBA = 0x00000041,
|
|
Luminance = 0x00020000,
|
|
LuminanceA = 0x00020001,
|
|
AlphaPixels = 0x00000001,
|
|
Alpha = 0x00000002,
|
|
Palette8 = 0x00000020,
|
|
Palette8A = 0x00000021,
|
|
BumpDUDV = 0x00080000
|
|
};
|
|
|
|
enum class DXGIFormat : uint32_t {
|
|
Unknown = 0,
|
|
R32G32B32A32_Typeless = 1,
|
|
R32G32B32A32_Float = 2,
|
|
R32G32B32A32_UInt = 3,
|
|
R32G32B32A32_SInt = 4,
|
|
R32G32B32_Typeless = 5,
|
|
R32G32B32_Float = 6,
|
|
R32G32B32_UInt = 7,
|
|
R32G32B32_SInt = 8,
|
|
R16G16B16A16_Typeless = 9,
|
|
R16G16B16A16_Float = 10,
|
|
R16G16B16A16_UNorm = 11,
|
|
R16G16B16A16_UInt = 12,
|
|
R16G16B16A16_SNorm = 13,
|
|
R16G16B16A16_SInt = 14,
|
|
R32G32_Typeless = 15,
|
|
R32G32_Float = 16,
|
|
R32G32_UInt = 17,
|
|
R32G32_SInt = 18,
|
|
R32G8X24_Typeless = 19,
|
|
D32_Float_S8X24_UInt = 20,
|
|
R32_Float_X8X24_Typeless = 21,
|
|
X32_Typeless_G8X24_UInt = 22,
|
|
R10G10B10A2_Typeless = 23,
|
|
R10G10B10A2_UNorm = 24,
|
|
R10G10B10A2_UInt = 25,
|
|
R11G11B10_Float = 26,
|
|
R8G8B8A8_Typeless = 27,
|
|
R8G8B8A8_UNorm = 28,
|
|
R8G8B8A8_UNorm_SRGB = 29,
|
|
R8G8B8A8_UInt = 30,
|
|
R8G8B8A8_SNorm = 31,
|
|
R8G8B8A8_SInt = 32,
|
|
R16G16_Typeless = 33,
|
|
R16G16_Float = 34,
|
|
R16G16_UNorm = 35,
|
|
R16G16_UInt = 36,
|
|
R16G16_SNorm = 37,
|
|
R16G16_SInt = 38,
|
|
R32_Typeless = 39,
|
|
D32_Float = 40,
|
|
R32_Float = 41,
|
|
R32_UInt = 42,
|
|
R32_SInt = 43,
|
|
R24G8_Typeless = 44,
|
|
D24_UNorm_S8_UInt = 45,
|
|
R24_UNorm_X8_Typeless = 46,
|
|
X24_Typeless_G8_UInt = 47,
|
|
R8G8_Typeless = 48,
|
|
R8G8_UNorm = 49,
|
|
R8G8_UInt = 50,
|
|
R8G8_SNorm = 51,
|
|
R8G8_SInt = 52,
|
|
R16_Typeless = 53,
|
|
R16_Float = 54,
|
|
D16_UNorm = 55,
|
|
R16_UNorm = 56,
|
|
R16_UInt = 57,
|
|
R16_SNorm = 58,
|
|
R16_SInt = 59,
|
|
R8_Typeless = 60,
|
|
R8_UNorm = 61,
|
|
R8_UInt = 62,
|
|
R8_SNorm = 63,
|
|
R8_SInt = 64,
|
|
A8_UNorm = 65,
|
|
R1_UNorm = 66,
|
|
R9G9B9E5_SHAREDEXP = 67,
|
|
R8G8_B8G8_UNorm = 68,
|
|
G8R8_G8B8_UNorm = 69,
|
|
BC1_Typeless = 70,
|
|
BC1_UNorm = 71,
|
|
BC1_UNorm_SRGB = 72,
|
|
BC2_Typeless = 73,
|
|
BC2_UNorm = 74,
|
|
BC2_UNorm_SRGB = 75,
|
|
BC3_Typeless = 76,
|
|
BC3_UNorm = 77,
|
|
BC3_UNorm_SRGB = 78,
|
|
BC4_Typeless = 79,
|
|
BC4_UNorm = 80,
|
|
BC4_SNorm = 81,
|
|
BC5_Typeless = 82,
|
|
BC5_UNorm = 83,
|
|
BC5_SNorm = 84,
|
|
B5G6R5_UNorm = 85,
|
|
B5G5R5A1_UNorm = 86,
|
|
B8G8R8A8_UNorm = 87,
|
|
B8G8R8X8_UNorm = 88,
|
|
R10G10B10_XR_BIAS_A2_UNorm = 89,
|
|
B8G8R8A8_Typeless = 90,
|
|
B8G8R8A8_UNorm_SRGB = 91,
|
|
B8G8R8X8_Typeless = 92,
|
|
B8G8R8X8_UNorm_SRGB = 93,
|
|
BC6H_Typeless = 94,
|
|
BC6H_UF16 = 95,
|
|
BC6H_SF16 = 96,
|
|
BC7_Typeless = 97,
|
|
BC7_UNorm = 98,
|
|
BC7_UNorm_SRGB = 99,
|
|
AYUV = 100,
|
|
Y410 = 101,
|
|
Y416 = 102,
|
|
NV12 = 103,
|
|
P010 = 104,
|
|
P016 = 105,
|
|
YUV420_OPAQUE = 106,
|
|
YUY2 = 107,
|
|
Y210 = 108,
|
|
Y216 = 109,
|
|
NV11 = 110,
|
|
AI44 = 111,
|
|
IA44 = 112,
|
|
P8 = 113,
|
|
A8P8 = 114,
|
|
B4G4R4A4_UNorm = 115,
|
|
P208 = 130,
|
|
V208 = 131,
|
|
V408 = 132,
|
|
};
|
|
|
|
enum class HeaderFlagBits : uint32_t {
|
|
Height = 0x00000002,
|
|
Width = 0x00000004,
|
|
Texture = 0x00001007,
|
|
Mipmap = 0x00020000,
|
|
Volume = 0x00800000,
|
|
Pitch = 0x00000008,
|
|
LinearSize = 0x00080000,
|
|
};
|
|
|
|
enum class HeaderCaps2FlagBits : uint32_t {
|
|
CubemapPositiveX = 0x00000600,
|
|
CubemapNegativeX = 0x00000a00,
|
|
CubemapPositiveY = 0x00001200,
|
|
CubemapNegativeY = 0x00002200,
|
|
CubemapPositiveZ = 0x00004200,
|
|
CubemapNegativeZ = 0x00008200,
|
|
CubemapAllFaces = CubemapPositiveX | CubemapNegativeX |
|
|
CubemapPositiveY | CubemapNegativeY |
|
|
CubemapPositiveZ | CubemapNegativeZ,
|
|
Volume = 0x00200000,
|
|
};
|
|
|
|
struct PixelFormat {
|
|
uint32_t m_size;
|
|
uint32_t m_flags;
|
|
uint32_t m_fourCC;
|
|
uint32_t m_bitCount;
|
|
uint32_t m_RBitMask;
|
|
uint32_t m_GBitMask;
|
|
uint32_t m_BBitMask;
|
|
uint32_t m_ABitMask;
|
|
};
|
|
|
|
struct Header {
|
|
uint32_t m_size;
|
|
uint32_t m_flags;
|
|
uint32_t m_height;
|
|
uint32_t m_width;
|
|
uint32_t m_pitchOrLinerSize;
|
|
uint32_t m_depth;
|
|
uint32_t m_mipMapCount;
|
|
uint32_t m_reserved1[11];
|
|
PixelFormat m_pixelFormat;
|
|
uint32_t m_caps;
|
|
uint32_t m_caps2;
|
|
uint32_t m_caps3;
|
|
uint32_t m_caps4;
|
|
uint32_t m_reserved2;
|
|
};
|
|
|
|
enum class TextureDimension : uint32_t {
|
|
Unknown = 0,
|
|
Texture1D = 2,
|
|
Texture2D = 3,
|
|
Texture3D = 4
|
|
};
|
|
|
|
enum class DXT10MiscFlagBits : uint32_t { TextureCube = 0x4 };
|
|
|
|
struct HeaderDXT10 {
|
|
DXGIFormat m_format;
|
|
TextureDimension m_resourceDimension;
|
|
uint32_t m_miscFlag;
|
|
uint32_t m_arraySize;
|
|
uint32_t m_miscFlag2;
|
|
};
|
|
|
|
struct ImageData {
|
|
uint32_t m_width;
|
|
uint32_t m_height;
|
|
uint32_t m_depth;
|
|
void* m_mem;
|
|
uint32_t m_memPitch;
|
|
uint32_t m_memSlicePitch;
|
|
};
|
|
|
|
struct BC1Block {
|
|
uint16_t m_color0;
|
|
uint16_t m_color1;
|
|
uint8_t m_row0;
|
|
uint8_t m_row1;
|
|
uint8_t m_row2;
|
|
uint8_t m_row3;
|
|
};
|
|
|
|
struct BC2Block {
|
|
uint16_t m_alphaRow0;
|
|
uint16_t m_alphaRow1;
|
|
uint16_t m_alphaRow2;
|
|
uint16_t m_alphaRow3;
|
|
uint16_t m_color0;
|
|
uint16_t m_color1;
|
|
uint8_t m_row0;
|
|
uint8_t m_row1;
|
|
uint8_t m_row2;
|
|
uint8_t m_row3;
|
|
};
|
|
|
|
struct BC3Block {
|
|
uint8_t m_alpha0;
|
|
uint8_t m_alpha1;
|
|
uint8_t m_alphaR0;
|
|
uint8_t m_alphaR1;
|
|
uint8_t m_alphaR2;
|
|
uint8_t m_alphaR3;
|
|
uint8_t m_alphaR4;
|
|
uint8_t m_alphaR5;
|
|
uint16_t m_color0;
|
|
uint16_t m_color1;
|
|
uint8_t m_row0;
|
|
uint8_t m_row1;
|
|
uint8_t m_row2;
|
|
uint8_t m_row3;
|
|
};
|
|
|
|
struct BC4Block {
|
|
uint8_t m_red0;
|
|
uint8_t m_red1;
|
|
uint8_t m_redR0;
|
|
uint8_t m_redR1;
|
|
uint8_t m_redR2;
|
|
uint8_t m_redR3;
|
|
uint8_t m_redR4;
|
|
uint8_t m_redR5;
|
|
};
|
|
|
|
struct BC5Block {
|
|
uint8_t m_red0;
|
|
uint8_t m_red1;
|
|
uint8_t m_redR0;
|
|
uint8_t m_redR1;
|
|
uint8_t m_redR2;
|
|
uint8_t m_redR3;
|
|
uint8_t m_redR4;
|
|
uint8_t m_redR5;
|
|
uint8_t m_green0;
|
|
uint8_t m_green1;
|
|
uint8_t m_greenR0;
|
|
uint8_t m_greenR1;
|
|
uint8_t m_greenR2;
|
|
uint8_t m_greenR3;
|
|
uint8_t m_greenR4;
|
|
uint8_t m_greenR5;
|
|
};
|
|
|
|
public:
|
|
static bool IsCompressed(DXGIFormat fmt);
|
|
static uint32_t MakeFourCC(char ch0, char ch1, char ch2, char ch3);
|
|
static DXGIFormat GetDXGIFormat(const PixelFormat& pf);
|
|
static uint32_t GetBitsPerPixel(DXGIFormat fmt);
|
|
|
|
Result Load(const char* filepath);
|
|
Result Load(std::istream& input);
|
|
Result Load(const uint8_t* data, size_t size);
|
|
Result Load(std::vector<uint8_t>&& dds);
|
|
|
|
const ImageData* GetImageData(uint32_t mipIdx = 0,
|
|
uint32_t arrayIdx = 0) const {
|
|
if (mipIdx < m_mipCount && arrayIdx < m_arraySize) {
|
|
return &m_imageDatas[m_mipCount * arrayIdx + mipIdx];
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool Flip();
|
|
|
|
uint32_t GetWidth() const { return m_width; }
|
|
uint32_t GetHeight() const { return m_height; }
|
|
uint32_t GetDepth() const { return m_depth; }
|
|
uint32_t GetMipCount() const { return m_mipCount; }
|
|
uint32_t GetArraySize() const { return m_arraySize; }
|
|
DXGIFormat GetFormat() const { return m_format; }
|
|
bool IsCubemap() const { return m_isCubemap; }
|
|
TextureDimension GetTextureDimension() const { return m_texDim; }
|
|
|
|
private:
|
|
void GetImageInfo(uint32_t w, uint32_t h, DXGIFormat fmt,
|
|
uint32_t* outNumBytes, uint32_t* outRowBytes,
|
|
uint32_t* outNumRows);
|
|
bool FlipImage(ImageData& imageData);
|
|
bool FlipCompressedImage(ImageData& imageData);
|
|
void FlipCompressedImageBC1(ImageData& imageData);
|
|
void FlipCompressedImageBC2(ImageData& imageData);
|
|
void FlipCompressedImageBC3(ImageData& imageData);
|
|
void FlipCompressedImageBC4(ImageData& imageData);
|
|
void FlipCompressedImageBC5(ImageData& imageData);
|
|
|
|
private:
|
|
std::vector<uint8_t> m_dds;
|
|
std::vector<ImageData> m_imageDatas;
|
|
|
|
uint32_t m_height;
|
|
uint32_t m_width;
|
|
uint32_t m_depth;
|
|
uint32_t m_mipCount;
|
|
uint32_t m_arraySize;
|
|
DXGIFormat m_format;
|
|
bool m_isCubemap;
|
|
TextureDimension m_texDim;
|
|
};
|
|
|
|
} // namespace tinyddsloader
|
|
|
|
#ifdef TINYDDSLOADER_IMPLEMENTATION
|
|
|
|
#if _WIN32
|
|
#undef min
|
|
#undef max
|
|
#endif // _Win32
|
|
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
|
|
namespace tinyddsloader {
|
|
|
|
const char DDSFile::Magic[4] = {'D', 'D', 'S', ' '};
|
|
|
|
bool DDSFile::IsCompressed(DXGIFormat fmt) {
|
|
switch (fmt) {
|
|
case DXGIFormat::BC1_Typeless:
|
|
case DXGIFormat::BC1_UNorm:
|
|
case DXGIFormat::BC1_UNorm_SRGB:
|
|
case DXGIFormat::BC2_Typeless:
|
|
case DXGIFormat::BC2_UNorm:
|
|
case DXGIFormat::BC2_UNorm_SRGB:
|
|
case DXGIFormat::BC3_Typeless:
|
|
case DXGIFormat::BC3_UNorm:
|
|
case DXGIFormat::BC3_UNorm_SRGB:
|
|
case DXGIFormat::BC4_Typeless:
|
|
case DXGIFormat::BC4_UNorm:
|
|
case DXGIFormat::BC4_SNorm:
|
|
case DXGIFormat::BC5_Typeless:
|
|
case DXGIFormat::BC5_UNorm:
|
|
case DXGIFormat::BC5_SNorm:
|
|
case DXGIFormat::BC6H_Typeless:
|
|
case DXGIFormat::BC6H_UF16:
|
|
case DXGIFormat::BC6H_SF16:
|
|
case DXGIFormat::BC7_Typeless:
|
|
case DXGIFormat::BC7_UNorm:
|
|
case DXGIFormat::BC7_UNorm_SRGB:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint32_t DDSFile::MakeFourCC(char ch0, char ch1, char ch2, char ch3) {
|
|
return (uint32_t(uint8_t(ch0)) | (uint32_t(uint8_t(ch1)) << 8) |
|
|
(uint32_t(uint8_t(ch2)) << 16) | (uint32_t(uint8_t(ch3)) << 24));
|
|
}
|
|
|
|
DDSFile::DXGIFormat DDSFile::GetDXGIFormat(const PixelFormat& pf) {
|
|
if (pf.m_flags & uint32_t(PixelFormatFlagBits::RGB)) {
|
|
switch (pf.m_bitCount) {
|
|
case 32:
|
|
if (pf.m_RBitMask == 0x000000ff &&
|
|
pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x00ff0000 &&
|
|
pf.m_ABitMask == 0xff000000) {
|
|
return DXGIFormat::R8G8B8A8_UNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0x00ff0000 &&
|
|
pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x000000ff &&
|
|
pf.m_ABitMask == 0xff000000) {
|
|
return DXGIFormat::B8G8R8A8_UNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0x00ff0000 &&
|
|
pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x000000ff &&
|
|
pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::B8G8R8X8_UNorm;
|
|
}
|
|
|
|
if (pf.m_RBitMask == 0x0000ffff &&
|
|
pf.m_GBitMask == 0xffff0000 &&
|
|
pf.m_BBitMask == 0x00000000 &&
|
|
pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R16G16_UNorm;
|
|
}
|
|
|
|
if (pf.m_RBitMask == 0xffffffff &&
|
|
pf.m_GBitMask == 0x00000000 &&
|
|
pf.m_BBitMask == 0x00000000 &&
|
|
pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R32_Float;
|
|
}
|
|
break;
|
|
case 24:
|
|
break;
|
|
case 16:
|
|
if (pf.m_RBitMask == 0x7c00 && pf.m_GBitMask == 0x03e0 &&
|
|
pf.m_BBitMask == 0x001f && pf.m_ABitMask == 0x8000) {
|
|
return DXGIFormat::B5G5R5A1_UNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0xf800 && pf.m_GBitMask == 0x07e0 &&
|
|
pf.m_BBitMask == 0x001f && pf.m_ABitMask == 0x0000) {
|
|
return DXGIFormat::B5G6R5_UNorm;
|
|
}
|
|
|
|
if (pf.m_RBitMask == 0x0f00 && pf.m_GBitMask == 0x00f0 &&
|
|
pf.m_BBitMask == 0x000f && pf.m_ABitMask == 0xf000) {
|
|
return DXGIFormat::B4G4R4A4_UNorm;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (pf.m_flags & uint32_t(PixelFormatFlagBits::Luminance)) {
|
|
if (8 == pf.m_bitCount) {
|
|
if (pf.m_RBitMask == 0x000000ff && pf.m_GBitMask == 0x00000000 &&
|
|
pf.m_BBitMask == 0x00000000 && pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R8_UNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0x000000ff && pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x00000000 && pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R8G8_UNorm;
|
|
}
|
|
}
|
|
if (16 == pf.m_bitCount) {
|
|
if (pf.m_RBitMask == 0x0000ffff && pf.m_GBitMask == 0x00000000 &&
|
|
pf.m_BBitMask == 0x00000000 && pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R16_UNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0x000000ff && pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x00000000 && pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R8G8_UNorm;
|
|
}
|
|
}
|
|
} else if (pf.m_flags & uint32_t(PixelFormatFlagBits::Alpha)) {
|
|
if (8 == pf.m_bitCount) {
|
|
return DXGIFormat::A8_UNorm;
|
|
}
|
|
} else if (pf.m_flags & uint32_t(PixelFormatFlagBits::BumpDUDV)) {
|
|
if (16 == pf.m_bitCount) {
|
|
if (pf.m_RBitMask == 0x00ff && pf.m_GBitMask == 0xff00 &&
|
|
pf.m_BBitMask == 0x0000 && pf.m_ABitMask == 0x0000) {
|
|
return DXGIFormat::R8G8_SNorm;
|
|
}
|
|
}
|
|
if (32 == pf.m_bitCount) {
|
|
if (pf.m_RBitMask == 0x000000ff && pf.m_GBitMask == 0x0000ff00 &&
|
|
pf.m_BBitMask == 0x00ff0000 && pf.m_ABitMask == 0xff000000) {
|
|
return DXGIFormat::R8G8B8A8_SNorm;
|
|
}
|
|
if (pf.m_RBitMask == 0x0000ffff && pf.m_GBitMask == 0xffff0000 &&
|
|
pf.m_BBitMask == 0x00000000 && pf.m_ABitMask == 0x00000000) {
|
|
return DXGIFormat::R16G16_SNorm;
|
|
}
|
|
}
|
|
} else if (pf.m_flags & uint32_t(PixelFormatFlagBits::FourCC)) {
|
|
if (MakeFourCC('D', 'X', 'T', '1') == pf.m_fourCC) {
|
|
return DXGIFormat::BC1_UNorm;
|
|
}
|
|
if (MakeFourCC('D', 'X', 'T', '3') == pf.m_fourCC) {
|
|
return DXGIFormat::BC2_UNorm;
|
|
}
|
|
if (MakeFourCC('D', 'X', 'T', '5') == pf.m_fourCC) {
|
|
return DXGIFormat::BC3_UNorm;
|
|
}
|
|
|
|
if (MakeFourCC('D', 'X', 'T', '4') == pf.m_fourCC) {
|
|
return DXGIFormat::BC2_UNorm;
|
|
}
|
|
if (MakeFourCC('D', 'X', 'T', '5') == pf.m_fourCC) {
|
|
return DXGIFormat::BC3_UNorm;
|
|
}
|
|
|
|
if (MakeFourCC('A', 'T', 'I', '1') == pf.m_fourCC) {
|
|
return DXGIFormat::BC4_UNorm;
|
|
}
|
|
if (MakeFourCC('B', 'C', '4', 'U') == pf.m_fourCC) {
|
|
return DXGIFormat::BC4_UNorm;
|
|
}
|
|
if (MakeFourCC('B', 'C', '4', 'S') == pf.m_fourCC) {
|
|
return DXGIFormat::BC4_SNorm;
|
|
}
|
|
|
|
if (MakeFourCC('A', 'T', 'I', '2') == pf.m_fourCC) {
|
|
return DXGIFormat::BC5_UNorm;
|
|
}
|
|
if (MakeFourCC('B', 'C', '5', 'U') == pf.m_fourCC) {
|
|
return DXGIFormat::BC5_UNorm;
|
|
}
|
|
if (MakeFourCC('B', 'C', '5', 'S') == pf.m_fourCC) {
|
|
return DXGIFormat::BC5_SNorm;
|
|
}
|
|
|
|
if (MakeFourCC('R', 'G', 'B', 'G') == pf.m_fourCC) {
|
|
return DXGIFormat::R8G8_B8G8_UNorm;
|
|
}
|
|
if (MakeFourCC('G', 'R', 'G', 'B') == pf.m_fourCC) {
|
|
return DXGIFormat::G8R8_G8B8_UNorm;
|
|
}
|
|
|
|
if (MakeFourCC('Y', 'U', 'Y', '2') == pf.m_fourCC) {
|
|
return DXGIFormat::YUY2;
|
|
}
|
|
|
|
switch (pf.m_fourCC) {
|
|
case 36:
|
|
return DXGIFormat::R16G16B16A16_UNorm;
|
|
case 110:
|
|
return DXGIFormat::R16G16B16A16_SNorm;
|
|
case 111:
|
|
return DXGIFormat::R16_Float;
|
|
case 112:
|
|
return DXGIFormat::R16G16_Float;
|
|
case 113:
|
|
return DXGIFormat::R16G16B16A16_Float;
|
|
case 114:
|
|
return DXGIFormat::R32_Float;
|
|
case 115:
|
|
return DXGIFormat::R32G32_Float;
|
|
case 116:
|
|
return DXGIFormat::R32G32B32A32_Float;
|
|
}
|
|
}
|
|
|
|
return DXGIFormat::Unknown;
|
|
}
|
|
|
|
uint32_t DDSFile::GetBitsPerPixel(DXGIFormat fmt) {
|
|
switch (fmt) {
|
|
case DXGIFormat::R32G32B32A32_Typeless:
|
|
case DXGIFormat::R32G32B32A32_Float:
|
|
case DXGIFormat::R32G32B32A32_UInt:
|
|
case DXGIFormat::R32G32B32A32_SInt:
|
|
return 128;
|
|
|
|
case DXGIFormat::R32G32B32_Typeless:
|
|
case DXGIFormat::R32G32B32_Float:
|
|
case DXGIFormat::R32G32B32_UInt:
|
|
case DXGIFormat::R32G32B32_SInt:
|
|
return 96;
|
|
|
|
case DXGIFormat::R16G16B16A16_Typeless:
|
|
case DXGIFormat::R16G16B16A16_Float:
|
|
case DXGIFormat::R16G16B16A16_UNorm:
|
|
case DXGIFormat::R16G16B16A16_UInt:
|
|
case DXGIFormat::R16G16B16A16_SNorm:
|
|
case DXGIFormat::R16G16B16A16_SInt:
|
|
case DXGIFormat::R32G32_Typeless:
|
|
case DXGIFormat::R32G32_Float:
|
|
case DXGIFormat::R32G32_UInt:
|
|
case DXGIFormat::R32G32_SInt:
|
|
case DXGIFormat::R32G8X24_Typeless:
|
|
case DXGIFormat::D32_Float_S8X24_UInt:
|
|
case DXGIFormat::R32_Float_X8X24_Typeless:
|
|
case DXGIFormat::X32_Typeless_G8X24_UInt:
|
|
case DXGIFormat::Y416:
|
|
case DXGIFormat::Y210:
|
|
case DXGIFormat::Y216:
|
|
return 64;
|
|
|
|
case DXGIFormat::R10G10B10A2_Typeless:
|
|
case DXGIFormat::R10G10B10A2_UNorm:
|
|
case DXGIFormat::R10G10B10A2_UInt:
|
|
case DXGIFormat::R11G11B10_Float:
|
|
case DXGIFormat::R8G8B8A8_Typeless:
|
|
case DXGIFormat::R8G8B8A8_UNorm:
|
|
case DXGIFormat::R8G8B8A8_UNorm_SRGB:
|
|
case DXGIFormat::R8G8B8A8_UInt:
|
|
case DXGIFormat::R8G8B8A8_SNorm:
|
|
case DXGIFormat::R8G8B8A8_SInt:
|
|
case DXGIFormat::R16G16_Typeless:
|
|
case DXGIFormat::R16G16_Float:
|
|
case DXGIFormat::R16G16_UNorm:
|
|
case DXGIFormat::R16G16_UInt:
|
|
case DXGIFormat::R16G16_SNorm:
|
|
case DXGIFormat::R16G16_SInt:
|
|
case DXGIFormat::R32_Typeless:
|
|
case DXGIFormat::D32_Float:
|
|
case DXGIFormat::R32_Float:
|
|
case DXGIFormat::R32_UInt:
|
|
case DXGIFormat::R32_SInt:
|
|
case DXGIFormat::R24G8_Typeless:
|
|
case DXGIFormat::D24_UNorm_S8_UInt:
|
|
case DXGIFormat::R24_UNorm_X8_Typeless:
|
|
case DXGIFormat::X24_Typeless_G8_UInt:
|
|
case DXGIFormat::R9G9B9E5_SHAREDEXP:
|
|
case DXGIFormat::R8G8_B8G8_UNorm:
|
|
case DXGIFormat::G8R8_G8B8_UNorm:
|
|
case DXGIFormat::B8G8R8A8_UNorm:
|
|
case DXGIFormat::B8G8R8X8_UNorm:
|
|
case DXGIFormat::R10G10B10_XR_BIAS_A2_UNorm:
|
|
case DXGIFormat::B8G8R8A8_Typeless:
|
|
case DXGIFormat::B8G8R8A8_UNorm_SRGB:
|
|
case DXGIFormat::B8G8R8X8_Typeless:
|
|
case DXGIFormat::B8G8R8X8_UNorm_SRGB:
|
|
case DXGIFormat::AYUV:
|
|
case DXGIFormat::Y410:
|
|
case DXGIFormat::YUY2:
|
|
return 32;
|
|
|
|
case DXGIFormat::P010:
|
|
case DXGIFormat::P016:
|
|
return 24;
|
|
|
|
case DXGIFormat::R8G8_Typeless:
|
|
case DXGIFormat::R8G8_UNorm:
|
|
case DXGIFormat::R8G8_UInt:
|
|
case DXGIFormat::R8G8_SNorm:
|
|
case DXGIFormat::R8G8_SInt:
|
|
case DXGIFormat::R16_Typeless:
|
|
case DXGIFormat::R16_Float:
|
|
case DXGIFormat::D16_UNorm:
|
|
case DXGIFormat::R16_UNorm:
|
|
case DXGIFormat::R16_UInt:
|
|
case DXGIFormat::R16_SNorm:
|
|
case DXGIFormat::R16_SInt:
|
|
case DXGIFormat::B5G6R5_UNorm:
|
|
case DXGIFormat::B5G5R5A1_UNorm:
|
|
case DXGIFormat::A8P8:
|
|
case DXGIFormat::B4G4R4A4_UNorm:
|
|
return 16;
|
|
|
|
case DXGIFormat::NV12:
|
|
case DXGIFormat::YUV420_OPAQUE:
|
|
case DXGIFormat::NV11:
|
|
return 12;
|
|
|
|
case DXGIFormat::R8_Typeless:
|
|
case DXGIFormat::R8_UNorm:
|
|
case DXGIFormat::R8_UInt:
|
|
case DXGIFormat::R8_SNorm:
|
|
case DXGIFormat::R8_SInt:
|
|
case DXGIFormat::A8_UNorm:
|
|
case DXGIFormat::AI44:
|
|
case DXGIFormat::IA44:
|
|
case DXGIFormat::P8:
|
|
return 8;
|
|
|
|
case DXGIFormat::R1_UNorm:
|
|
return 1;
|
|
|
|
case DXGIFormat::BC1_Typeless:
|
|
case DXGIFormat::BC1_UNorm:
|
|
case DXGIFormat::BC1_UNorm_SRGB:
|
|
case DXGIFormat::BC4_Typeless:
|
|
case DXGIFormat::BC4_UNorm:
|
|
case DXGIFormat::BC4_SNorm:
|
|
return 4;
|
|
|
|
case DXGIFormat::BC2_Typeless:
|
|
case DXGIFormat::BC2_UNorm:
|
|
case DXGIFormat::BC2_UNorm_SRGB:
|
|
case DXGIFormat::BC3_Typeless:
|
|
case DXGIFormat::BC3_UNorm:
|
|
case DXGIFormat::BC3_UNorm_SRGB:
|
|
case DXGIFormat::BC5_Typeless:
|
|
case DXGIFormat::BC5_UNorm:
|
|
case DXGIFormat::BC5_SNorm:
|
|
case DXGIFormat::BC6H_Typeless:
|
|
case DXGIFormat::BC6H_UF16:
|
|
case DXGIFormat::BC6H_SF16:
|
|
case DXGIFormat::BC7_Typeless:
|
|
case DXGIFormat::BC7_UNorm:
|
|
case DXGIFormat::BC7_UNorm_SRGB:
|
|
return 8;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Result DDSFile::Load(const char* filepath) {
|
|
std::ifstream ifs(filepath, std::ios_base::binary);
|
|
if (!ifs.is_open()) {
|
|
return Result::ErrorFileOpen;
|
|
}
|
|
|
|
return Load(ifs);
|
|
}
|
|
|
|
Result DDSFile::Load(std::istream& input) {
|
|
m_dds.clear();
|
|
|
|
input.seekg(0, std::ios_base::beg);
|
|
auto begPos = input.tellg();
|
|
input.seekg(0, std::ios_base::end);
|
|
auto endPos = input.tellg();
|
|
input.seekg(0, std::ios_base::beg);
|
|
|
|
auto fileSize = endPos - begPos;
|
|
if (fileSize == 0) {
|
|
return Result::ErrorRead;
|
|
}
|
|
std::vector<uint8_t> dds(fileSize);
|
|
|
|
input.read(reinterpret_cast<char*>(dds.data()), fileSize);
|
|
|
|
if (input.bad()) {
|
|
return Result::ErrorRead;
|
|
}
|
|
|
|
return Load(std::move(dds));
|
|
}
|
|
|
|
Result DDSFile::Load(const uint8_t* data, size_t size) {
|
|
std::vector<uint8_t> dds(data, data + size);
|
|
return Load(std::move(dds));
|
|
}
|
|
|
|
Result DDSFile::Load(std::vector<uint8_t>&& dds) {
|
|
m_dds.clear();
|
|
|
|
if (dds.size() < 4) {
|
|
return Result::ErrorSize;
|
|
}
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
if (dds[i] != Magic[i]) {
|
|
return Result::ErrorMagicWord;
|
|
}
|
|
}
|
|
|
|
if ((sizeof(uint32_t) + sizeof(Header)) >= dds.size()) {
|
|
return Result::ErrorSize;
|
|
}
|
|
auto header =
|
|
reinterpret_cast<const Header*>(dds.data() + sizeof(uint32_t));
|
|
|
|
if (header->m_size != sizeof(Header) ||
|
|
header->m_pixelFormat.m_size != sizeof(PixelFormat)) {
|
|
return Result::ErrorVerify;
|
|
}
|
|
bool dxt10Header = false;
|
|
if ((header->m_pixelFormat.m_flags &
|
|
uint32_t(PixelFormatFlagBits::FourCC)) &&
|
|
(MakeFourCC('D', 'X', '1', '0') == header->m_pixelFormat.m_fourCC)) {
|
|
if ((sizeof(uint32_t) + sizeof(Header) + sizeof(HeaderDXT10)) >=
|
|
dds.size()) {
|
|
return Result::ErrorSize;
|
|
}
|
|
dxt10Header = true;
|
|
}
|
|
ptrdiff_t offset = sizeof(uint32_t) + sizeof(Header) +
|
|
(dxt10Header ? sizeof(HeaderDXT10) : 0);
|
|
|
|
m_height = header->m_height;
|
|
m_width = header->m_width;
|
|
m_texDim = TextureDimension::Unknown;
|
|
m_arraySize = 1;
|
|
m_format = DXGIFormat::Unknown;
|
|
m_isCubemap = false;
|
|
m_mipCount = header->m_mipMapCount;
|
|
if (0 == m_mipCount) {
|
|
m_mipCount = 1;
|
|
}
|
|
|
|
if (dxt10Header) {
|
|
auto dxt10Header = reinterpret_cast<const HeaderDXT10*>(
|
|
reinterpret_cast<const char*>(header) + sizeof(Header));
|
|
|
|
m_arraySize = dxt10Header->m_arraySize;
|
|
if (m_arraySize == 0) {
|
|
return Result::ErrorInvalidData;
|
|
}
|
|
|
|
switch (dxt10Header->m_format) {
|
|
case DXGIFormat::AI44:
|
|
case DXGIFormat::IA44:
|
|
case DXGIFormat::P8:
|
|
case DXGIFormat::A8P8:
|
|
return Result::ErrorNotSupported;
|
|
default:
|
|
if (GetBitsPerPixel(dxt10Header->m_format) == 0) {
|
|
return Result::ErrorNotSupported;
|
|
}
|
|
}
|
|
|
|
m_format = dxt10Header->m_format;
|
|
|
|
switch (dxt10Header->m_resourceDimension) {
|
|
case TextureDimension::Texture1D:
|
|
if ((header->m_flags & uint32_t(HeaderFlagBits::Height) &&
|
|
(m_height != 1))) {
|
|
return Result::ErrorInvalidData;
|
|
}
|
|
m_height = m_depth = 1;
|
|
break;
|
|
case TextureDimension::Texture2D:
|
|
if (dxt10Header->m_miscFlag &
|
|
uint32_t(DXT10MiscFlagBits::TextureCube)) {
|
|
m_arraySize *= 6;
|
|
m_isCubemap = true;
|
|
}
|
|
m_depth = 1;
|
|
break;
|
|
case TextureDimension::Texture3D:
|
|
if (!(header->m_flags & uint32_t(HeaderFlagBits::Volume))) {
|
|
return Result::ErrorInvalidData;
|
|
}
|
|
if (m_arraySize > 1) {
|
|
return Result::ErrorNotSupported;
|
|
}
|
|
break;
|
|
default:
|
|
return Result::ErrorNotSupported;
|
|
}
|
|
|
|
m_texDim = dxt10Header->m_resourceDimension;
|
|
} else {
|
|
m_format = GetDXGIFormat(header->m_pixelFormat);
|
|
if (m_format == DXGIFormat::Unknown) {
|
|
return Result::ErrorNotSupported;
|
|
}
|
|
|
|
if (header->m_flags & uint32_t(HeaderFlagBits::Volume)) {
|
|
m_texDim = TextureDimension::Texture3D;
|
|
} else {
|
|
auto caps2 = header->m_caps2 &
|
|
uint32_t(HeaderCaps2FlagBits::CubemapAllFaces);
|
|
if (caps2) {
|
|
if (caps2 != uint32_t(HeaderCaps2FlagBits::CubemapAllFaces)) {
|
|
return Result::ErrorNotSupported;
|
|
}
|
|
m_arraySize = 6;
|
|
m_isCubemap = true;
|
|
}
|
|
|
|
m_depth = 1;
|
|
m_texDim = TextureDimension::Texture2D;
|
|
}
|
|
}
|
|
|
|
std::vector<ImageData> imageDatas(m_mipCount * m_arraySize);
|
|
uint8_t* srcBits = dds.data() + offset;
|
|
uint8_t* endBits = dds.data() + dds.size();
|
|
uint32_t idx = 0;
|
|
for (uint32_t j = 0; j < m_arraySize; j++) {
|
|
uint32_t w = m_width;
|
|
uint32_t h = m_height;
|
|
uint32_t d = m_depth;
|
|
for (uint32_t i = 0; i < m_mipCount; i++) {
|
|
uint32_t numBytes;
|
|
uint32_t rowBytes;
|
|
GetImageInfo(w, h, m_format, &numBytes, &rowBytes, nullptr);
|
|
|
|
imageDatas[idx].m_width = w;
|
|
imageDatas[idx].m_height = h;
|
|
imageDatas[idx].m_depth = d;
|
|
imageDatas[idx].m_mem = srcBits;
|
|
imageDatas[idx].m_memPitch = rowBytes;
|
|
imageDatas[idx].m_memSlicePitch = numBytes;
|
|
idx++;
|
|
|
|
if (srcBits + (numBytes * d) > endBits) {
|
|
return Result::ErrorInvalidData;
|
|
}
|
|
srcBits += numBytes * d;
|
|
w = std::max<uint32_t>(1, w / 2);
|
|
h = std::max<uint32_t>(1, h / 2);
|
|
d = std::max<uint32_t>(1, d / 2);
|
|
}
|
|
}
|
|
|
|
m_dds = std::move(dds);
|
|
m_imageDatas = std::move(imageDatas);
|
|
|
|
return Result::Success;
|
|
}
|
|
|
|
void DDSFile::GetImageInfo(uint32_t w, uint32_t h, DXGIFormat fmt,
|
|
uint32_t* outNumBytes, uint32_t* outRowBytes,
|
|
uint32_t* outNumRows) {
|
|
uint32_t numBytes = 0;
|
|
uint32_t rowBytes = 0;
|
|
uint32_t numRows = 0;
|
|
|
|
bool bc = false;
|
|
bool packed = false;
|
|
bool planar = false;
|
|
uint32_t bpe = 0;
|
|
switch (fmt) {
|
|
case DXGIFormat::BC1_Typeless:
|
|
case DXGIFormat::BC1_UNorm:
|
|
case DXGIFormat::BC1_UNorm_SRGB:
|
|
case DXGIFormat::BC4_Typeless:
|
|
case DXGIFormat::BC4_UNorm:
|
|
case DXGIFormat::BC4_SNorm:
|
|
bc = true;
|
|
bpe = 8;
|
|
break;
|
|
|
|
case DXGIFormat::BC2_Typeless:
|
|
case DXGIFormat::BC2_UNorm:
|
|
case DXGIFormat::BC2_UNorm_SRGB:
|
|
case DXGIFormat::BC3_Typeless:
|
|
case DXGIFormat::BC3_UNorm:
|
|
case DXGIFormat::BC3_UNorm_SRGB:
|
|
case DXGIFormat::BC5_Typeless:
|
|
case DXGIFormat::BC5_UNorm:
|
|
case DXGIFormat::BC5_SNorm:
|
|
case DXGIFormat::BC6H_Typeless:
|
|
case DXGIFormat::BC6H_UF16:
|
|
case DXGIFormat::BC6H_SF16:
|
|
case DXGIFormat::BC7_Typeless:
|
|
case DXGIFormat::BC7_UNorm:
|
|
case DXGIFormat::BC7_UNorm_SRGB:
|
|
bc = true;
|
|
bpe = 16;
|
|
break;
|
|
|
|
case DXGIFormat::R8G8_B8G8_UNorm:
|
|
case DXGIFormat::G8R8_G8B8_UNorm:
|
|
case DXGIFormat::YUY2:
|
|
packed = true;
|
|
bpe = 4;
|
|
break;
|
|
|
|
case DXGIFormat::Y210:
|
|
case DXGIFormat::Y216:
|
|
packed = true;
|
|
bpe = 8;
|
|
break;
|
|
|
|
case DXGIFormat::NV12:
|
|
case DXGIFormat::YUV420_OPAQUE:
|
|
planar = true;
|
|
bpe = 2;
|
|
break;
|
|
|
|
case DXGIFormat::P010:
|
|
case DXGIFormat::P016:
|
|
planar = true;
|
|
bpe = 4;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (bc) {
|
|
uint32_t numBlocksWide = 0;
|
|
if (w > 0) {
|
|
numBlocksWide = std::max<uint32_t>(1, (w + 3) / 4);
|
|
}
|
|
uint32_t numBlocksHigh = 0;
|
|
if (h > 0) {
|
|
numBlocksHigh = std::max<uint32_t>(1, (h + 3) / 4);
|
|
}
|
|
rowBytes = numBlocksWide * bpe;
|
|
numRows = numBlocksHigh;
|
|
numBytes = rowBytes * numBlocksHigh;
|
|
} else if (packed) {
|
|
rowBytes = ((w + 1) >> 1) * bpe;
|
|
numRows = h;
|
|
numBytes = rowBytes * h;
|
|
} else if (fmt == DXGIFormat::NV11) {
|
|
rowBytes = ((w + 3) >> 2) * 4;
|
|
numRows = h * 2;
|
|
numBytes = rowBytes + numRows;
|
|
} else if (planar) {
|
|
rowBytes = ((w + 1) >> 1) * bpe;
|
|
numBytes = (rowBytes * h) + ((rowBytes * h + 1) >> 1);
|
|
numRows = h + ((h + 1) >> 1);
|
|
} else {
|
|
uint32_t bpp = GetBitsPerPixel(fmt);
|
|
rowBytes = (w * bpp + 7) / 8;
|
|
numRows = h;
|
|
numBytes = rowBytes * h;
|
|
}
|
|
|
|
if (outNumBytes) {
|
|
*outNumBytes = numBytes;
|
|
}
|
|
if (outRowBytes) {
|
|
*outRowBytes = rowBytes;
|
|
}
|
|
if (outNumRows) {
|
|
*outNumRows = numRows;
|
|
}
|
|
}
|
|
|
|
bool DDSFile::Flip() {
|
|
if (IsCompressed(m_format)) {
|
|
for (auto& imageData : m_imageDatas) {
|
|
if (!FlipCompressedImage(imageData)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
for (auto& imageData : m_imageDatas) {
|
|
if (!FlipImage(imageData)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DDSFile::FlipImage(ImageData& imageData) {
|
|
for (uint32_t y = 0; y < imageData.m_height / 2; y++) {
|
|
auto line0 = (uint8_t*)imageData.m_mem + y * imageData.m_memPitch;
|
|
auto line1 = (uint8_t*)imageData.m_mem +
|
|
(imageData.m_height - y - 1) * imageData.m_memPitch;
|
|
for (uint32_t i = 0; i < imageData.m_memPitch; i++) {
|
|
std::swap(*line0, *line1);
|
|
line0++;
|
|
line1++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DDSFile::FlipCompressedImage(ImageData& imageData) {
|
|
if (DXGIFormat::BC1_Typeless == m_format ||
|
|
DXGIFormat::BC1_UNorm == m_format ||
|
|
DXGIFormat::BC1_UNorm_SRGB == m_format) {
|
|
FlipCompressedImageBC1(imageData);
|
|
return true;
|
|
} else if (DXGIFormat::BC2_Typeless == m_format ||
|
|
DXGIFormat::BC2_UNorm == m_format ||
|
|
DXGIFormat::BC2_UNorm_SRGB == m_format) {
|
|
FlipCompressedImageBC2(imageData);
|
|
return true;
|
|
} else if (DXGIFormat::BC3_Typeless == m_format ||
|
|
DXGIFormat::BC3_UNorm == m_format ||
|
|
DXGIFormat::BC3_UNorm_SRGB == m_format) {
|
|
FlipCompressedImageBC3(imageData);
|
|
return true;
|
|
} else if (DXGIFormat::BC4_Typeless == m_format ||
|
|
DXGIFormat::BC4_UNorm == m_format ||
|
|
DXGIFormat::BC4_SNorm == m_format) {
|
|
FlipCompressedImageBC4(imageData);
|
|
return true;
|
|
} else if (DXGIFormat::BC5_Typeless == m_format ||
|
|
DXGIFormat::BC5_UNorm == m_format ||
|
|
DXGIFormat::BC5_SNorm == m_format) {
|
|
FlipCompressedImageBC5(imageData);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DDSFile::FlipCompressedImageBC1(ImageData& imageData) {
|
|
uint32_t numXBlocks = (imageData.m_width + 3) / 4;
|
|
uint32_t numYBlocks = (imageData.m_height + 3) / 4;
|
|
if (imageData.m_height == 1) {
|
|
} else if (imageData.m_height == 2) {
|
|
auto blocks = (BC1Block*)imageData.m_mem;
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block = blocks + x;
|
|
std::swap(block->m_row0, block->m_row1);
|
|
std::swap(block->m_row2, block->m_row3);
|
|
}
|
|
} else {
|
|
for (uint32_t y = 0; y < (numYBlocks + 1) / 2; y++) {
|
|
auto blocks0 = (BC1Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * y);
|
|
auto blocks1 =
|
|
(BC1Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * (numYBlocks - y - 1));
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block0 = blocks0 + x;
|
|
auto block1 = blocks1 + x;
|
|
if (blocks0 != blocks1) {
|
|
std::swap(block0->m_color0, block1->m_color0);
|
|
std::swap(block0->m_color1, block1->m_color1);
|
|
std::swap(block0->m_row0, block1->m_row3);
|
|
std::swap(block0->m_row1, block1->m_row2);
|
|
std::swap(block0->m_row2, block1->m_row1);
|
|
std::swap(block0->m_row3, block1->m_row0);
|
|
} else {
|
|
std::swap(block0->m_row0, block0->m_row3);
|
|
std::swap(block0->m_row1, block0->m_row2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DDSFile::FlipCompressedImageBC2(ImageData& imageData) {
|
|
uint32_t numXBlocks = (imageData.m_width + 3) / 4;
|
|
uint32_t numYBlocks = (imageData.m_height + 3) / 4;
|
|
if (imageData.m_height == 1) {
|
|
} else if (imageData.m_height == 2) {
|
|
auto blocks = (BC2Block*)imageData.m_mem;
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block = blocks + x;
|
|
std::swap(block->m_alphaRow0, block->m_alphaRow1);
|
|
std::swap(block->m_alphaRow2, block->m_alphaRow3);
|
|
std::swap(block->m_row0, block->m_row1);
|
|
std::swap(block->m_row2, block->m_row3);
|
|
}
|
|
} else {
|
|
for (uint32_t y = 0; y < (numYBlocks + 1) / 2; y++) {
|
|
auto blocks0 = (BC2Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * y);
|
|
auto blocks1 =
|
|
(BC2Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * (numYBlocks - y - 1));
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block0 = blocks0 + x;
|
|
auto block1 = blocks1 + x;
|
|
if (block0 != block1) {
|
|
std::swap(block0->m_alphaRow0, block1->m_alphaRow3);
|
|
std::swap(block0->m_alphaRow1, block1->m_alphaRow2);
|
|
std::swap(block0->m_alphaRow2, block1->m_alphaRow1);
|
|
std::swap(block0->m_alphaRow3, block1->m_alphaRow0);
|
|
std::swap(block0->m_color0, block1->m_color0);
|
|
std::swap(block0->m_color1, block1->m_color1);
|
|
std::swap(block0->m_row0, block1->m_row3);
|
|
std::swap(block0->m_row1, block1->m_row2);
|
|
std::swap(block0->m_row2, block1->m_row1);
|
|
std::swap(block0->m_row3, block1->m_row0);
|
|
} else {
|
|
std::swap(block0->m_alphaRow0, block0->m_alphaRow3);
|
|
std::swap(block0->m_alphaRow1, block0->m_alphaRow2);
|
|
std::swap(block0->m_row0, block0->m_row3);
|
|
std::swap(block0->m_row1, block0->m_row2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DDSFile::FlipCompressedImageBC3(ImageData& imageData) {
|
|
uint32_t numXBlocks = (imageData.m_width + 3) / 4;
|
|
uint32_t numYBlocks = (imageData.m_height + 3) / 4;
|
|
if (imageData.m_height == 1) {
|
|
} else if (imageData.m_height == 2) {
|
|
auto blocks = (BC3Block*)imageData.m_mem;
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block = blocks + x;
|
|
uint8_t r0 = (block->m_alphaR1 >> 4) | (block->m_alphaR2 << 4);
|
|
uint8_t r1 = (block->m_alphaR2 >> 4) | (block->m_alphaR0 << 4);
|
|
uint8_t r2 = (block->m_alphaR0 >> 4) | (block->m_alphaR1 << 4);
|
|
uint8_t r3 = (block->m_alphaR4 >> 4) | (block->m_alphaR5 << 4);
|
|
uint8_t r4 = (block->m_alphaR5 >> 4) | (block->m_alphaR3 << 4);
|
|
uint8_t r5 = (block->m_alphaR3 >> 4) | (block->m_alphaR4 << 4);
|
|
|
|
block->m_alphaR0 = r0;
|
|
block->m_alphaR1 = r1;
|
|
block->m_alphaR2 = r2;
|
|
block->m_alphaR3 = r3;
|
|
block->m_alphaR4 = r4;
|
|
block->m_alphaR5 = r5;
|
|
std::swap(block->m_row0, block->m_row1);
|
|
std::swap(block->m_row2, block->m_row3);
|
|
}
|
|
} else {
|
|
for (uint32_t y = 0; y < (numYBlocks + 1) / 2; y++) {
|
|
auto blocks0 = (BC3Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * y);
|
|
auto blocks1 =
|
|
(BC3Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * (numYBlocks - y - 1));
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block0 = blocks0 + x;
|
|
auto block1 = blocks1 + x;
|
|
if (block0 != block1) {
|
|
std::swap(block0->m_alpha0, block1->m_alpha0);
|
|
std::swap(block0->m_alpha1, block1->m_alpha1);
|
|
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_alphaR4 >> 4) | (block0->m_alphaR5 << 4);
|
|
r0[1] = (block0->m_alphaR5 >> 4) | (block0->m_alphaR3 << 4);
|
|
r0[2] = (block0->m_alphaR3 >> 4) | (block0->m_alphaR4 << 4);
|
|
r0[3] = (block0->m_alphaR1 >> 4) | (block0->m_alphaR2 << 4);
|
|
r0[4] = (block0->m_alphaR2 >> 4) | (block0->m_alphaR0 << 4);
|
|
r0[5] = (block0->m_alphaR0 >> 4) | (block0->m_alphaR1 << 4);
|
|
uint8_t r1[6];
|
|
r1[0] = (block1->m_alphaR4 >> 4) | (block1->m_alphaR5 << 4);
|
|
r1[1] = (block1->m_alphaR5 >> 4) | (block1->m_alphaR3 << 4);
|
|
r1[2] = (block1->m_alphaR3 >> 4) | (block1->m_alphaR4 << 4);
|
|
r1[3] = (block1->m_alphaR1 >> 4) | (block1->m_alphaR2 << 4);
|
|
r1[4] = (block1->m_alphaR2 >> 4) | (block1->m_alphaR0 << 4);
|
|
r1[5] = (block1->m_alphaR0 >> 4) | (block1->m_alphaR1 << 4);
|
|
|
|
block0->m_alphaR0 = r1[0];
|
|
block0->m_alphaR1 = r1[1];
|
|
block0->m_alphaR2 = r1[2];
|
|
block0->m_alphaR3 = r1[3];
|
|
block0->m_alphaR4 = r1[4];
|
|
block0->m_alphaR5 = r1[5];
|
|
|
|
block1->m_alphaR0 = r0[0];
|
|
block1->m_alphaR1 = r0[1];
|
|
block1->m_alphaR2 = r0[2];
|
|
block1->m_alphaR3 = r0[3];
|
|
block1->m_alphaR4 = r0[4];
|
|
block1->m_alphaR5 = r0[5];
|
|
|
|
std::swap(block0->m_color0, block1->m_color0);
|
|
std::swap(block0->m_color1, block1->m_color1);
|
|
std::swap(block0->m_row0, block1->m_row3);
|
|
std::swap(block0->m_row1, block1->m_row2);
|
|
std::swap(block0->m_row2, block1->m_row1);
|
|
std::swap(block0->m_row3, block1->m_row0);
|
|
} else {
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_alphaR4 >> 4) | (block0->m_alphaR5 << 4);
|
|
r0[1] = (block0->m_alphaR5 >> 4) | (block0->m_alphaR3 << 4);
|
|
r0[2] = (block0->m_alphaR3 >> 4) | (block0->m_alphaR4 << 4);
|
|
r0[3] = (block0->m_alphaR1 >> 4) | (block0->m_alphaR2 << 4);
|
|
r0[4] = (block0->m_alphaR2 >> 4) | (block0->m_alphaR0 << 4);
|
|
r0[5] = (block0->m_alphaR0 >> 4) | (block0->m_alphaR1 << 4);
|
|
|
|
block0->m_alphaR0 = r0[0];
|
|
block0->m_alphaR1 = r0[1];
|
|
block0->m_alphaR2 = r0[2];
|
|
block0->m_alphaR3 = r0[3];
|
|
block0->m_alphaR4 = r0[4];
|
|
block0->m_alphaR5 = r0[5];
|
|
|
|
std::swap(block0->m_row0, block0->m_row3);
|
|
std::swap(block0->m_row1, block0->m_row2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DDSFile::FlipCompressedImageBC4(ImageData& imageData) {
|
|
uint32_t numXBlocks = (imageData.m_width + 3) / 4;
|
|
uint32_t numYBlocks = (imageData.m_height + 3) / 4;
|
|
if (imageData.m_height == 1) {
|
|
} else if (imageData.m_height == 2) {
|
|
auto blocks = (BC4Block*)imageData.m_mem;
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block = blocks + x;
|
|
uint8_t r0 = (block->m_redR1 >> 4) | (block->m_redR2 << 4);
|
|
uint8_t r1 = (block->m_redR2 >> 4) | (block->m_redR0 << 4);
|
|
uint8_t r2 = (block->m_redR0 >> 4) | (block->m_redR1 << 4);
|
|
uint8_t r3 = (block->m_redR4 >> 4) | (block->m_redR5 << 4);
|
|
uint8_t r4 = (block->m_redR5 >> 4) | (block->m_redR3 << 4);
|
|
uint8_t r5 = (block->m_redR3 >> 4) | (block->m_redR4 << 4);
|
|
|
|
block->m_redR0 = r0;
|
|
block->m_redR1 = r1;
|
|
block->m_redR2 = r2;
|
|
block->m_redR3 = r3;
|
|
block->m_redR4 = r4;
|
|
block->m_redR5 = r5;
|
|
}
|
|
} else {
|
|
for (uint32_t y = 0; y < (numYBlocks + 1) / 2; y++) {
|
|
auto blocks0 = (BC4Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * y);
|
|
auto blocks1 =
|
|
(BC4Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * (numYBlocks - y - 1));
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block0 = blocks0 + x;
|
|
auto block1 = blocks1 + x;
|
|
if (block0 != block1) {
|
|
std::swap(block0->m_red0, block1->m_red0);
|
|
std::swap(block0->m_red1, block1->m_red1);
|
|
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_redR4 >> 4) | (block0->m_redR5 << 4);
|
|
r0[1] = (block0->m_redR5 >> 4) | (block0->m_redR3 << 4);
|
|
r0[2] = (block0->m_redR3 >> 4) | (block0->m_redR4 << 4);
|
|
r0[3] = (block0->m_redR1 >> 4) | (block0->m_redR2 << 4);
|
|
r0[4] = (block0->m_redR2 >> 4) | (block0->m_redR0 << 4);
|
|
r0[5] = (block0->m_redR0 >> 4) | (block0->m_redR1 << 4);
|
|
uint8_t r1[6];
|
|
r1[0] = (block1->m_redR4 >> 4) | (block1->m_redR5 << 4);
|
|
r1[1] = (block1->m_redR5 >> 4) | (block1->m_redR3 << 4);
|
|
r1[2] = (block1->m_redR3 >> 4) | (block1->m_redR4 << 4);
|
|
r1[3] = (block1->m_redR1 >> 4) | (block1->m_redR2 << 4);
|
|
r1[4] = (block1->m_redR2 >> 4) | (block1->m_redR0 << 4);
|
|
r1[5] = (block1->m_redR0 >> 4) | (block1->m_redR1 << 4);
|
|
|
|
block0->m_redR0 = r1[0];
|
|
block0->m_redR1 = r1[1];
|
|
block0->m_redR2 = r1[2];
|
|
block0->m_redR3 = r1[3];
|
|
block0->m_redR4 = r1[4];
|
|
block0->m_redR5 = r1[5];
|
|
|
|
block1->m_redR0 = r0[0];
|
|
block1->m_redR1 = r0[1];
|
|
block1->m_redR2 = r0[2];
|
|
block1->m_redR3 = r0[3];
|
|
block1->m_redR4 = r0[4];
|
|
block1->m_redR5 = r0[5];
|
|
|
|
} else {
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_redR4 >> 4) | (block0->m_redR5 << 4);
|
|
r0[1] = (block0->m_redR5 >> 4) | (block0->m_redR3 << 4);
|
|
r0[2] = (block0->m_redR3 >> 4) | (block0->m_redR4 << 4);
|
|
r0[3] = (block0->m_redR1 >> 4) | (block0->m_redR2 << 4);
|
|
r0[4] = (block0->m_redR2 >> 4) | (block0->m_redR0 << 4);
|
|
r0[5] = (block0->m_redR0 >> 4) | (block0->m_redR1 << 4);
|
|
|
|
block0->m_redR0 = r0[0];
|
|
block0->m_redR1 = r0[1];
|
|
block0->m_redR2 = r0[2];
|
|
block0->m_redR3 = r0[3];
|
|
block0->m_redR4 = r0[4];
|
|
block0->m_redR5 = r0[5];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DDSFile::FlipCompressedImageBC5(ImageData& imageData) {
|
|
uint32_t numXBlocks = (imageData.m_width + 3) / 4;
|
|
uint32_t numYBlocks = (imageData.m_height + 3) / 4;
|
|
if (imageData.m_height == 1) {
|
|
} else if (imageData.m_height == 2) {
|
|
auto blocks = (BC5Block*)imageData.m_mem;
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block = blocks + x;
|
|
uint8_t r0 = (block->m_redR1 >> 4) | (block->m_redR2 << 4);
|
|
uint8_t r1 = (block->m_redR2 >> 4) | (block->m_redR0 << 4);
|
|
uint8_t r2 = (block->m_redR0 >> 4) | (block->m_redR1 << 4);
|
|
uint8_t r3 = (block->m_redR4 >> 4) | (block->m_redR5 << 4);
|
|
uint8_t r4 = (block->m_redR5 >> 4) | (block->m_redR3 << 4);
|
|
uint8_t r5 = (block->m_redR3 >> 4) | (block->m_redR4 << 4);
|
|
|
|
block->m_redR0 = r0;
|
|
block->m_redR1 = r1;
|
|
block->m_redR2 = r2;
|
|
block->m_redR3 = r3;
|
|
block->m_redR4 = r4;
|
|
block->m_redR5 = r5;
|
|
|
|
uint8_t g0 = (block->m_greenR1 >> 4) | (block->m_greenR2 << 4);
|
|
uint8_t g1 = (block->m_greenR2 >> 4) | (block->m_greenR0 << 4);
|
|
uint8_t g2 = (block->m_greenR0 >> 4) | (block->m_greenR1 << 4);
|
|
uint8_t g3 = (block->m_greenR4 >> 4) | (block->m_greenR5 << 4);
|
|
uint8_t g4 = (block->m_greenR5 >> 4) | (block->m_greenR3 << 4);
|
|
uint8_t g5 = (block->m_greenR3 >> 4) | (block->m_greenR4 << 4);
|
|
|
|
block->m_greenR0 = g0;
|
|
block->m_greenR1 = g1;
|
|
block->m_greenR2 = g2;
|
|
block->m_greenR3 = g3;
|
|
block->m_greenR4 = g4;
|
|
block->m_greenR5 = g5;
|
|
}
|
|
} else {
|
|
for (uint32_t y = 0; y < (numYBlocks + 1) / 2; y++) {
|
|
auto blocks0 = (BC5Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * y);
|
|
auto blocks1 =
|
|
(BC5Block*)((uint8_t*)imageData.m_mem +
|
|
imageData.m_memPitch * (numYBlocks - y - 1));
|
|
for (uint32_t x = 0; x < numXBlocks; x++) {
|
|
auto block0 = blocks0 + x;
|
|
auto block1 = blocks1 + x;
|
|
if (block0 != block1) {
|
|
std::swap(block0->m_red0, block1->m_red0);
|
|
std::swap(block0->m_red1, block1->m_red1);
|
|
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_redR4 >> 4) | (block0->m_redR5 << 4);
|
|
r0[1] = (block0->m_redR5 >> 4) | (block0->m_redR3 << 4);
|
|
r0[2] = (block0->m_redR3 >> 4) | (block0->m_redR4 << 4);
|
|
r0[3] = (block0->m_redR1 >> 4) | (block0->m_redR2 << 4);
|
|
r0[4] = (block0->m_redR2 >> 4) | (block0->m_redR0 << 4);
|
|
r0[5] = (block0->m_redR0 >> 4) | (block0->m_redR1 << 4);
|
|
uint8_t r1[6];
|
|
r1[0] = (block1->m_redR4 >> 4) | (block1->m_redR5 << 4);
|
|
r1[1] = (block1->m_redR5 >> 4) | (block1->m_redR3 << 4);
|
|
r1[2] = (block1->m_redR3 >> 4) | (block1->m_redR4 << 4);
|
|
r1[3] = (block1->m_redR1 >> 4) | (block1->m_redR2 << 4);
|
|
r1[4] = (block1->m_redR2 >> 4) | (block1->m_redR0 << 4);
|
|
r1[5] = (block1->m_redR0 >> 4) | (block1->m_redR1 << 4);
|
|
|
|
block0->m_redR0 = r1[0];
|
|
block0->m_redR1 = r1[1];
|
|
block0->m_redR2 = r1[2];
|
|
block0->m_redR3 = r1[3];
|
|
block0->m_redR4 = r1[4];
|
|
block0->m_redR5 = r1[5];
|
|
|
|
block1->m_redR0 = r0[0];
|
|
block1->m_redR1 = r0[1];
|
|
block1->m_redR2 = r0[2];
|
|
block1->m_redR3 = r0[3];
|
|
block1->m_redR4 = r0[4];
|
|
block1->m_redR5 = r0[5];
|
|
|
|
std::swap(block0->m_green0, block1->m_green0);
|
|
std::swap(block0->m_green1, block1->m_green1);
|
|
|
|
uint8_t g0[6];
|
|
g0[0] = (block0->m_greenR4 >> 4) | (block0->m_greenR5 << 4);
|
|
g0[1] = (block0->m_greenR5 >> 4) | (block0->m_greenR3 << 4);
|
|
g0[2] = (block0->m_greenR3 >> 4) | (block0->m_greenR4 << 4);
|
|
g0[3] = (block0->m_greenR1 >> 4) | (block0->m_greenR2 << 4);
|
|
g0[4] = (block0->m_greenR2 >> 4) | (block0->m_greenR0 << 4);
|
|
g0[5] = (block0->m_greenR0 >> 4) | (block0->m_greenR1 << 4);
|
|
uint8_t g1[6];
|
|
g1[0] = (block1->m_greenR4 >> 4) | (block1->m_greenR5 << 4);
|
|
g1[1] = (block1->m_greenR5 >> 4) | (block1->m_greenR3 << 4);
|
|
g1[2] = (block1->m_greenR3 >> 4) | (block1->m_greenR4 << 4);
|
|
g1[3] = (block1->m_greenR1 >> 4) | (block1->m_greenR2 << 4);
|
|
g1[4] = (block1->m_greenR2 >> 4) | (block1->m_greenR0 << 4);
|
|
g1[5] = (block1->m_greenR0 >> 4) | (block1->m_greenR1 << 4);
|
|
|
|
block0->m_greenR0 = g1[0];
|
|
block0->m_greenR1 = g1[1];
|
|
block0->m_greenR2 = g1[2];
|
|
block0->m_greenR3 = g1[3];
|
|
block0->m_greenR4 = g1[4];
|
|
block0->m_greenR5 = g1[5];
|
|
|
|
block1->m_greenR0 = g0[0];
|
|
block1->m_greenR1 = g0[1];
|
|
block1->m_greenR2 = g0[2];
|
|
block1->m_greenR3 = g0[3];
|
|
block1->m_greenR4 = g0[4];
|
|
block1->m_greenR5 = g0[5];
|
|
} else {
|
|
uint8_t r0[6];
|
|
r0[0] = (block0->m_redR4 >> 4) | (block0->m_redR5 << 4);
|
|
r0[1] = (block0->m_redR5 >> 4) | (block0->m_redR3 << 4);
|
|
r0[2] = (block0->m_redR3 >> 4) | (block0->m_redR4 << 4);
|
|
r0[3] = (block0->m_redR1 >> 4) | (block0->m_redR2 << 4);
|
|
r0[4] = (block0->m_redR2 >> 4) | (block0->m_redR0 << 4);
|
|
r0[5] = (block0->m_redR0 >> 4) | (block0->m_redR1 << 4);
|
|
|
|
block0->m_redR0 = r0[0];
|
|
block0->m_redR1 = r0[1];
|
|
block0->m_redR2 = r0[2];
|
|
block0->m_redR3 = r0[3];
|
|
block0->m_redR4 = r0[4];
|
|
block0->m_redR5 = r0[5];
|
|
|
|
uint8_t g0[6];
|
|
g0[0] = (block0->m_greenR4 >> 4) | (block0->m_greenR5 << 4);
|
|
g0[1] = (block0->m_greenR5 >> 4) | (block0->m_greenR3 << 4);
|
|
g0[2] = (block0->m_greenR3 >> 4) | (block0->m_greenR4 << 4);
|
|
g0[3] = (block0->m_greenR1 >> 4) | (block0->m_greenR2 << 4);
|
|
g0[4] = (block0->m_greenR2 >> 4) | (block0->m_greenR0 << 4);
|
|
g0[5] = (block0->m_greenR0 >> 4) | (block0->m_greenR1 << 4);
|
|
|
|
block0->m_greenR0 = g0[0];
|
|
block0->m_greenR1 = g0[1];
|
|
block0->m_greenR2 = g0[2];
|
|
block0->m_greenR3 = g0[3];
|
|
block0->m_greenR4 = g0[4];
|
|
block0->m_greenR5 = g0[5];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace tinyddsloader
|
|
|
|
#endif // !TINYDDSLOADER_IMPLEMENTATION
|
|
|
|
#endif // !TINYDDSLOADER_H_
|