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

70
DirectXTex/DDS.h
View File

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

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