Yidhra/DirectXTex
2
0
Fork 0
mirror of https://github.com/microsoft/DirectXTex.git synced 2025-07-16 15:00:14 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Sync DDS header

Browse Source
This commit is contained in:
Chuck Walbourn 2018-02-23 23:46:30 -08:00
parent dc45c1d964
commit 56956f817a
2 changed files with 121 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
DirectXTex/DDS.h
View File

@ -12,17 +12,12 @@
// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/?LinkId=248926
// http://go.microsoft.com/fwlink/?LinkId=248929
// http://go.microsoft.com/fwlink/?LinkID=615561
//--------------------------------------------------------------------------------------
#pragma once
#if defined(_XBOX_ONE) && defined(_TITLE)
#include <d3d11_x.h>
#else
#include <dxgiformat.h>
#endif
#include <stdint.h>
namespace DirectX
{
@ -33,14 +28,14 @@ const uint32_t DDS_MAGIC = 0x20534444; // "DDS "
struct DDS_PIXELFORMAT
{
uint32_t dwSize;
uint32_t dwFlags;
uint32_t dwFourCC;
uint32_t dwRGBBitCount;
uint32_t dwRBitMask;
uint32_t dwGBitMask;
uint32_t dwBBitMask;
uint32_t dwABitMask;
uint32_t size;
uint32_t flags;
uint32_t fourCC;
uint32_t RGBBitCount;
uint32_t RBitMask;
uint32_t GBitMask;
uint32_t BBitMask;
uint32_t ABitMask;
};
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC
@ -48,6 +43,7 @@ struct DDS_PIXELFORMAT
#define DDS_RGBA 0x00000041 // DDPF_RGB | DDPF_ALPHAPIXELS
#define DDS_LUMINANCE 0x00020000 // DDPF_LUMINANCE
#define DDS_LUMINANCEA 0x00020001 // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
#define DDS_ALPHAPIXELS 0x00000001 // DDPF_ALPHAPIXELS
#define DDS_ALPHA 0x00000002 // DDPF_ALPHA
#define DDS_PAL8 0x00000020 // DDPF_PALETTEINDEXED8
#define DDS_PAL8A 0x00000021 // DDPF_PALETTEINDEXED8 | DDPF_ALPHAPIXELS
@ -210,27 +206,27 @@ enum DDS_ALPHA_MODE
struct DDS_HEADER
{
uint32_t dwSize;
uint32_t dwFlags;
uint32_t dwHeight;
uint32_t dwWidth;
uint32_t dwPitchOrLinearSize;
uint32_t dwDepth; // only if DDS_HEADER_FLAGS_VOLUME is set in dwFlags
uint32_t dwMipMapCount;
uint32_t dwReserved1[11];
uint32_t size;
uint32_t flags;
uint32_t height;
uint32_t width;
uint32_t pitchOrLinearSize;
uint32_t depth; // only if DDS_HEADER_FLAGS_VOLUME is set in flags
uint32_t mipMapCount;
uint32_t reserved1[11];
DDS_PIXELFORMAT ddspf;
uint32_t dwCaps;
uint32_t dwCaps2;
uint32_t dwCaps3;
uint32_t dwCaps4;
uint32_t dwReserved2;
uint32_t caps;
uint32_t caps2;
uint32_t caps3;
uint32_t caps4;
uint32_t reserved2;
};
struct DDS_HEADER_DXT10
{
DXGI_FORMAT dxgiFormat;
uint32_t resourceDimension;
uint32_t miscFlag; // see DDS_RESOURCE_MISC_FLAG
uint32_t miscFlag; // see D3D11_RESOURCE_MISC_FLAG
uint32_t arraySize;
uint32_t miscFlags2; // see DDS_MISC_FLAGS2
};

176
DirectXTex/DirectXTexDDS.cpp
View File

@ -153,8 +153,8 @@ namespace
DXGI_FORMAT GetDXGIFormat(const DDS_HEADER& hdr, const DDS_PIXELFORMAT& ddpf, DWORD flags, _Inout_ DWORD& convFlags)
{
uint32_t ddpfFlags = ddpf.dwFlags;
if (hdr.dwReserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
uint32_t ddpfFlags = ddpf.flags;
if (hdr.reserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
{
// Clear out non-standard nVidia DDS flags
ddpfFlags &= ~0xC0000000 /* DDPF_SRGB | DDPF_NORMAL */;
@ -166,68 +166,68 @@ namespace
{
const LegacyDDS* entry = &g_LegacyDDSMap[index];
if (ddpfFlags == entry->ddpf.dwFlags)
if (ddpfFlags == entry->ddpf.flags)
{
if (entry->ddpf.dwFlags & DDS_FOURCC)
if (entry->ddpf.flags & DDS_FOURCC)
{
if (ddpf.dwFourCC == entry->ddpf.dwFourCC)
if (ddpf.fourCC == entry->ddpf.fourCC)
break;
}
else if (entry->ddpf.dwFlags & DDS_PAL8)
else if (entry->ddpf.flags & DDS_PAL8)
{
if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount)
if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount)
break;
}
else if (entry->ddpf.dwFlags & DDS_ALPHA)
else if (entry->ddpf.flags & DDS_ALPHA)
{
if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount
&& ddpf.dwABitMask == entry->ddpf.dwABitMask)
if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
&& ddpf.ABitMask == entry->ddpf.ABitMask)
break;
}
else if (entry->ddpf.dwFlags & DDS_LUMINANCE)
else if (entry->ddpf.flags & DDS_LUMINANCE)
{
if (entry->ddpf.dwFlags & 0x1 /*DDPF_ALPHAPIXELS*/)
if (entry->ddpf.flags & DDS_ALPHAPIXELS)
{
// LUMINANCEA
if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount
&& ddpf.dwRBitMask == entry->ddpf.dwRBitMask
&& ddpf.dwABitMask == entry->ddpf.dwABitMask)
if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
&& ddpf.RBitMask == entry->ddpf.RBitMask
&& ddpf.ABitMask == entry->ddpf.ABitMask)
break;
}
else
{
// LUMINANCE
if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount
&& ddpf.dwRBitMask == entry->ddpf.dwRBitMask)
if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
&& ddpf.RBitMask == entry->ddpf.RBitMask)
break;
}
}
else if (entry->ddpf.dwFlags & DDS_BUMPDUDV)
else if (entry->ddpf.flags & DDS_BUMPDUDV)
{
if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount
&& ddpf.dwRBitMask == entry->ddpf.dwRBitMask
&& ddpf.dwGBitMask == entry->ddpf.dwGBitMask
&& ddpf.dwBBitMask == entry->ddpf.dwBBitMask
&& ddpf.dwABitMask == entry->ddpf.dwABitMask)
if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount
&& ddpf.RBitMask == entry->ddpf.RBitMask
&& ddpf.GBitMask == entry->ddpf.GBitMask
&& ddpf.BBitMask == entry->ddpf.BBitMask
&& ddpf.ABitMask == entry->ddpf.ABitMask)
break;
}
else if (ddpf.dwRGBBitCount == entry->ddpf.dwRGBBitCount)
else if (ddpf.RGBBitCount == entry->ddpf.RGBBitCount)
{
if (entry->ddpf.dwFlags & 0x1 /*DDPF_ALPHAPIXELS*/)
if (entry->ddpf.flags & DDS_ALPHAPIXELS)
{
// RGBA
if (ddpf.dwRBitMask == entry->ddpf.dwRBitMask
&& ddpf.dwGBitMask == entry->ddpf.dwGBitMask
&& ddpf.dwBBitMask == entry->ddpf.dwBBitMask
&& ddpf.dwABitMask == entry->ddpf.dwABitMask)
if (ddpf.RBitMask == entry->ddpf.RBitMask
&& ddpf.GBitMask == entry->ddpf.GBitMask
&& ddpf.BBitMask == entry->ddpf.BBitMask
&& ddpf.ABitMask == entry->ddpf.ABitMask)
break;
}
else
{
// RGB
if (ddpf.dwRBitMask == entry->ddpf.dwRBitMask
&& ddpf.dwGBitMask == entry->ddpf.dwGBitMask
&& ddpf.dwBBitMask == entry->ddpf.dwBBitMask)
if (ddpf.RBitMask == entry->ddpf.RBitMask
&& ddpf.GBitMask == entry->ddpf.GBitMask
&& ddpf.BBitMask == entry->ddpf.BBitMask)
break;
}
}
@ -248,8 +248,8 @@ namespace
cflags ^= CONV_FLAGS_SWIZZLE;
}
if ((hdr.dwReserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
&& (ddpf.dwFlags & 0x40000000 /* DDPF_SRGB */))
if ((hdr.reserved1[9] == MAKEFOURCC('N', 'V', 'T', 'T'))
&& (ddpf.flags & 0x40000000 /* DDPF_SRGB */))
{
format = MakeSRGB(format);
}
@ -290,19 +290,19 @@ namespace
auto pHeader = reinterpret_cast<const DDS_HEADER*>((const uint8_t*)pSource + sizeof(uint32_t));
// Verify header to validate DDS file
if (pHeader->dwSize != sizeof(DDS_HEADER)
|| pHeader->ddspf.dwSize != sizeof(DDS_PIXELFORMAT))
if (pHeader->size != sizeof(DDS_HEADER)
|| pHeader->ddspf.size != sizeof(DDS_PIXELFORMAT))
{
return E_FAIL;
}
metadata.mipLevels = pHeader->dwMipMapCount;
metadata.mipLevels = pHeader->mipMapCount;
if (metadata.mipLevels == 0)
metadata.mipLevels = 1;
// Check for DX10 extension
if ((pHeader->ddspf.dwFlags & DDS_FOURCC)
&& (MAKEFOURCC('D', 'X', '1', '0') == pHeader->ddspf.dwFourCC))
if ((pHeader->ddspf.flags & DDS_FOURCC)
&& (MAKEFOURCC('D', 'X', '1', '0') == pHeader->ddspf.fourCC))
{
// Buffer must be big enough for both headers and magic value
if (size < (sizeof(DDS_HEADER) + sizeof(uint32_t) + sizeof(DDS_HEADER_DXT10)))
@ -334,12 +334,12 @@ namespace
case DDS_DIMENSION_TEXTURE1D:
// D3DX writes 1D textures with a fixed Height of 1
if ((pHeader->dwFlags & DDS_HEIGHT) && pHeader->dwHeight != 1)
if ((pHeader->flags & DDS_HEIGHT) && pHeader->height != 1)
{
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
}
metadata.width = pHeader->dwWidth;
metadata.width = pHeader->width;
metadata.height = 1;
metadata.depth = 1;
metadata.dimension = TEX_DIMENSION_TEXTURE1D;
@ -352,14 +352,14 @@ namespace
metadata.arraySize *= 6;
}
metadata.width = pHeader->dwWidth;
metadata.height = pHeader->dwHeight;
metadata.width = pHeader->width;
metadata.height = pHeader->height;
metadata.depth = 1;
metadata.dimension = TEX_DIMENSION_TEXTURE2D;
break;
case DDS_DIMENSION_TEXTURE3D:
if (!(pHeader->dwFlags & DDS_HEADER_FLAGS_VOLUME))
if (!(pHeader->flags & DDS_HEADER_FLAGS_VOLUME))
{
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
}
@ -367,9 +367,9 @@ namespace
if (metadata.arraySize > 1)
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
metadata.width = pHeader->dwWidth;
metadata.height = pHeader->dwHeight;
metadata.depth = pHeader->dwDepth;
metadata.width = pHeader->width;
metadata.height = pHeader->height;
metadata.depth = pHeader->depth;
metadata.dimension = TEX_DIMENSION_TEXTURE3D;
break;
@ -391,27 +391,27 @@ namespace
{
metadata.arraySize = 1;
if (pHeader->dwFlags & DDS_HEADER_FLAGS_VOLUME)
if (pHeader->flags & DDS_HEADER_FLAGS_VOLUME)
{
metadata.width = pHeader->dwWidth;
metadata.height = pHeader->dwHeight;
metadata.depth = pHeader->dwDepth;
metadata.width = pHeader->width;
metadata.height = pHeader->height;
metadata.depth = pHeader->depth;
metadata.dimension = TEX_DIMENSION_TEXTURE3D;
}
else
{
if (pHeader->dwCaps2 & DDS_CUBEMAP)
if (pHeader->caps2 & DDS_CUBEMAP)
{
// We require all six faces to be defined
if ((pHeader->dwCaps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
if ((pHeader->caps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
metadata.arraySize = 6;
metadata.miscFlags |= TEX_MISC_TEXTURECUBE;
}
metadata.width = pHeader->dwWidth;
metadata.height = pHeader->dwHeight;
metadata.width = pHeader->width;
metadata.height = pHeader->height;
metadata.depth = 1;
metadata.dimension = TEX_DIMENSION_TEXTURE2D;
@ -578,28 +578,28 @@ HRESULT DirectX::_EncodeDDSHeader(
// Legacy D3DX formats using D3DFMT enum value as FourCC
case DXGI_FORMAT_R32G32B32A32_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 116; // D3DFMT_A32B32G32R32F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 116; // D3DFMT_A32B32G32R32F
break;
case DXGI_FORMAT_R16G16B16A16_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 113; // D3DFMT_A16B16G16R16F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 113; // D3DFMT_A16B16G16R16F
break;
case DXGI_FORMAT_R16G16B16A16_UNORM:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 36; // D3DFMT_A16B16G16R16
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 36; // D3DFMT_A16B16G16R16
break;
case DXGI_FORMAT_R16G16B16A16_SNORM:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 110; // D3DFMT_Q16W16V16U16
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 110; // D3DFMT_Q16W16V16U16
break;
case DXGI_FORMAT_R32G32_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 115; // D3DFMT_G32R32F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 115; // D3DFMT_G32R32F
break;
case DXGI_FORMAT_R16G16_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 112; // D3DFMT_G16R16F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 112; // D3DFMT_G16R16F
break;
case DXGI_FORMAT_R32_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 114; // D3DFMT_R32F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 114; // D3DFMT_R32F
break;
case DXGI_FORMAT_R16_FLOAT:
ddpf.dwSize = sizeof(DDS_PIXELFORMAT); ddpf.dwFlags = DDS_FOURCC; ddpf.dwFourCC = 111; // D3DFMT_R16F
ddpf.size = sizeof(DDS_PIXELFORMAT); ddpf.flags = DDS_FOURCC; ddpf.fourCC = 111; // D3DFMT_R16F
break;
default:
@ -609,7 +609,7 @@ HRESULT DirectX::_EncodeDDSHeader(
required = sizeof(uint32_t) + sizeof(DDS_HEADER);
if (ddpf.dwSize == 0)
if (ddpf.size == 0)
required += sizeof(DDS_HEADER_DXT10);
if (!pDestination)
@ -624,21 +624,21 @@ HRESULT DirectX::_EncodeDDSHeader(
assert(header);
memset(header, 0, sizeof(DDS_HEADER));
header->dwSize = sizeof(DDS_HEADER);
header->dwFlags = DDS_HEADER_FLAGS_TEXTURE;
header->dwCaps = DDS_SURFACE_FLAGS_TEXTURE;
header->size = sizeof(DDS_HEADER);
header->flags = DDS_HEADER_FLAGS_TEXTURE;
header->caps = DDS_SURFACE_FLAGS_TEXTURE;
if (metadata.mipLevels > 0)
{
header->dwFlags |= DDS_HEADER_FLAGS_MIPMAP;
header->flags |= DDS_HEADER_FLAGS_MIPMAP;
if (metadata.mipLevels > UINT16_MAX)
return E_INVALIDARG;
header->dwMipMapCount = static_cast<uint32_t>(metadata.mipLevels);
header->mipMapCount = static_cast<uint32_t>(metadata.mipLevels);
if (header->dwMipMapCount > 1)
header->dwCaps |= DDS_SURFACE_FLAGS_MIPMAP;
if (header->mipMapCount > 1)
header->caps |= DDS_SURFACE_FLAGS_MIPMAP;
}
switch (metadata.dimension)
@ -647,8 +647,8 @@ HRESULT DirectX::_EncodeDDSHeader(
if (metadata.width > UINT32_MAX)
return E_INVALIDARG;
header->dwWidth = static_cast<uint32_t>(metadata.width);
header->dwHeight = header->dwDepth = 1;
header->width = static_cast<uint32_t>(metadata.width);
header->height = header->depth = 1;
break;
case TEX_DIMENSION_TEXTURE2D:
@ -656,14 +656,14 @@ HRESULT DirectX::_EncodeDDSHeader(
|| metadata.width > UINT32_MAX)
return E_INVALIDARG;
header->dwHeight = static_cast<uint32_t>(metadata.height);
header->dwWidth = static_cast<uint32_t>(metadata.width);
header->dwDepth = 1;
header->height = static_cast<uint32_t>(metadata.height);
header->width = static_cast<uint32_t>(metadata.width);
header->depth = 1;
if (metadata.IsCubemap())
{
header->dwCaps |= DDS_SURFACE_FLAGS_CUBEMAP;
header->dwCaps2 |= DDS_CUBEMAP_ALLFACES;
header->caps |= DDS_SURFACE_FLAGS_CUBEMAP;
header->caps2 |= DDS_CUBEMAP_ALLFACES;
}
break;
@ -673,11 +673,11 @@ HRESULT DirectX::_EncodeDDSHeader(
|| metadata.depth > UINT16_MAX)
return E_INVALIDARG;
header->dwFlags |= DDS_HEADER_FLAGS_VOLUME;
header->dwCaps2 |= DDS_FLAGS_VOLUME;
header->dwHeight = static_cast<uint32_t>(metadata.height);
header->dwWidth = static_cast<uint32_t>(metadata.width);
header->dwDepth = static_cast<uint32_t>(metadata.depth);
header->flags |= DDS_HEADER_FLAGS_VOLUME;
header->caps2 |= DDS_FLAGS_VOLUME;
header->height = static_cast<uint32_t>(metadata.height);
header->width = static_cast<uint32_t>(metadata.width);
header->depth = static_cast<uint32_t>(metadata.depth);
break;
default:
@ -693,16 +693,16 @@ HRESULT DirectX::_EncodeDDSHeader(
if (IsCompressed(metadata.format))
{
header->dwFlags |= DDS_HEADER_FLAGS_LINEARSIZE;
header->dwPitchOrLinearSize = static_cast<uint32_t>(slicePitch);
header->flags |= DDS_HEADER_FLAGS_LINEARSIZE;
header->pitchOrLinearSize = static_cast<uint32_t>(slicePitch);
}
else
{
header->dwFlags |= DDS_HEADER_FLAGS_PITCH;
header->dwPitchOrLinearSize = static_cast<uint32_t>(rowPitch);
header->flags |= DDS_HEADER_FLAGS_PITCH;
header->pitchOrLinearSize = static_cast<uint32_t>(rowPitch);
}
if (ddpf.dwSize == 0)
if (ddpf.size == 0)
{
memcpy_s(&header->ddspf, sizeof(header->ddspf), &DDSPF_DX10, sizeof(DDS_PIXELFORMAT));