AuroraMiddleware/DirectXTex
1
0
Fork 0
mirror of https://github.com/microsoft/DirectXTex synced 2024-11-21 12:00:06 +00:00
Code Issues Releases Wiki Activity

.edtiorconfig driven reformat of source (#271)

Browse Source
This commit is contained in:
Chuck Walbourn 2022-04-04 15:03:02 -07:00 committed by GitHub
parent 091835fa86
commit b1001d15b3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
48 changed files with 5645 additions and 5531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
.editorconfig
View File

@ -1,9 +1,74 @@
root = true root = true
[*.{cpp,h,inl,fx,hlsl}] [*.{fx,fxh,hlsl,hlsli}]
indent_size = 4 indent_size = 4
indent_style = space indent_style = space
trim_trailing_whitespace = true trim_trailing_whitespace = true
insert_final_newline = true insert_final_newline = true
end_of_line = crlf end_of_line = crlf
charset = latin1 charset = latin1
cpp_space_before_function_open_parenthesis = remove
cpp_space_around_binary_operator = ignore
cpp_space_pointer_reference_alignment = ignore
[*.{cpp,h,hpp,inl}]
indent_size = 4
indent_style = space
trim_trailing_whitespace = true
insert_final_newline = true
end_of_line = crlf
charset = latin1
cpp_indent_braces = false
cpp_indent_multi_line_relative_to = innermost_parenthesis
cpp_indent_within_parentheses = indent
cpp_indent_preserve_within_parentheses = false
cpp_indent_case_contents = true
cpp_indent_case_labels = false
cpp_indent_case_contents_when_block = true
cpp_indent_lambda_braces_when_parameter = true
cpp_indent_preprocessor = one_left
cpp_indent_access_specifiers = false
cpp_indent_namespace_contents = true
cpp_indent_preserve_comments = true
cpp_new_line_before_open_brace_namespace = new_line
cpp_new_line_before_open_brace_type = new_line
cpp_new_line_before_open_brace_function = new_line
cpp_new_line_before_open_brace_block = new_line
cpp_new_line_before_open_brace_lambda = new_line
cpp_new_line_scope_braces_on_separate_lines = true
cpp_new_line_close_brace_same_line_empty_type = true
cpp_new_line_close_brace_same_line_empty_function = true
cpp_new_line_before_catch = true
cpp_new_line_before_else = true
cpp_new_line_before_while_in_do_while = true
cpp_space_before_function_open_parenthesis = remove
cpp_space_within_parameter_list_parentheses = false
cpp_space_between_empty_parameter_list_parentheses = false
cpp_space_after_keywords_in_control_flow_statements = true
cpp_space_within_control_flow_statement_parentheses = false
cpp_space_before_lambda_open_parenthesis = false
cpp_space_within_cast_parentheses = false
cpp_space_after_cast_close_parenthesis = false
cpp_space_within_expression_parentheses = false
cpp_space_before_initializer_list_open_brace = false
cpp_space_within_initializer_list_braces = true
cpp_space_before_open_square_bracket = false
cpp_space_within_square_brackets = false
cpp_space_before_empty_square_brackets = false
cpp_space_between_empty_square_brackets = false
cpp_space_group_square_brackets = true
cpp_space_within_lambda_brackets = false
cpp_space_between_empty_lambda_brackets = false
cpp_space_before_comma = false
cpp_space_after_comma = true
cpp_space_remove_around_member_operators = true
cpp_space_before_inheritance_colon = true
cpp_space_before_constructor_colon = true
cpp_space_remove_before_semicolon = true
cpp_space_after_semicolon = false
cpp_space_remove_around_unary_operator = false
cpp_space_around_binary_operator = ignore
cpp_space_around_assignment_operator = insert
cpp_space_pointer_reference_alignment = ignore
cpp_space_around_ternary_operator = insert
cpp_wrap_preserve_blocks = one_liners

28
DDSTextureLoader/DDSTextureLoader11.cpp
View File

@ -43,7 +43,7 @@ using namespace DirectX;
// Macros // Macros
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */ #endif /* defined(MAKEFOURCC) */
@ -136,7 +136,7 @@ namespace
inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; } inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
template<UINT TNameLength> template<UINT TNameLength>
inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_ const char (&name)[TNameLength]) noexcept inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_ const char(&name)[TNameLength]) noexcept
{ {
#if defined(_DEBUG) || defined(PROFILE) #if defined(_DEBUG) || defined(PROFILE)
resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name); resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name);
@ -229,13 +229,13 @@ namespace
*bitSize = 0; *bitSize = 0;
// open the file // open the file
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
ScopedHandle hFile(safe_handle(CreateFile2(fileName, ScopedHandle hFile(safe_handle(CreateFile2(fileName,
GENERIC_READ, GENERIC_READ,
FILE_SHARE_READ, FILE_SHARE_READ,
OPEN_EXISTING, OPEN_EXISTING,
nullptr))); nullptr)));
#else #else
ScopedHandle hFile(safe_handle(CreateFileW(fileName, ScopedHandle hFile(safe_handle(CreateFileW(fileName,
GENERIC_READ, GENERIC_READ,
FILE_SHARE_READ, FILE_SHARE_READ,
@ -243,7 +243,7 @@ namespace
OPEN_EXISTING, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL,
nullptr))); nullptr)));
#endif #endif
if (!hFile) if (!hFile)
{ {
@ -611,13 +611,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -637,7 +637,7 @@ namespace
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a ) #define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a )
DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT& ddpf) noexcept DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT& ddpf) noexcept
{ {
@ -904,10 +904,10 @@ namespace
return DXGI_FORMAT_UNKNOWN; return DXGI_FORMAT_UNKNOWN;
} }
#undef ISBITMASK #undef ISBITMASK
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
DXGI_FORMAT MakeSRGB(_In_ DXGI_FORMAT format) noexcept DXGI_FORMAT MakeSRGB(_In_ DXGI_FORMAT format) noexcept
{ {
switch (format) switch (format)
@ -1682,7 +1682,7 @@ namespace
_In_opt_ ID3D11Resource** texture, _In_opt_ ID3D11Resource** texture,
_In_opt_ ID3D11ShaderResourceView** textureView) noexcept _In_opt_ ID3D11ShaderResourceView** textureView) noexcept
{ {
#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
if (texture || textureView) if (texture || textureView)
{ {
CHAR strFileA[MAX_PATH]; CHAR strFileA[MAX_PATH];
@ -1724,11 +1724,11 @@ namespace
} }
} }
} }
#else #else
UNREFERENCED_PARAMETER(fileName); UNREFERENCED_PARAMETER(fileName);
UNREFERENCED_PARAMETER(texture); UNREFERENCED_PARAMETER(texture);
UNREFERENCED_PARAMETER(textureView); UNREFERENCED_PARAMETER(textureView);
#endif #endif
} }
} // anonymous namespace } // anonymous namespace

40
DDSTextureLoader/DDSTextureLoader12.cpp
View File

@ -59,7 +59,7 @@ using namespace DirectX;
// Macros // Macros
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */ #endif /* defined(MAKEFOURCC) */
@ -274,7 +274,7 @@ namespace
*bitSize = 0; *bitSize = 0;
#ifdef WIN32 #ifdef WIN32
// open the file // open the file
ScopedHandle hFile(safe_handle(CreateFile2(fileName, ScopedHandle hFile(safe_handle(CreateFile2(fileName,
GENERIC_READ, GENERIC_READ,
@ -334,7 +334,7 @@ namespace
size_t len = fileInfo.EndOfFile.LowPart; size_t len = fileInfo.EndOfFile.LowPart;
#else // !WIN32 #else // !WIN32
std::ifstream inFile(std::filesystem::path(fileName), std::ios::in | std::ios::binary | std::ios::ate); std::ifstream inFile(std::filesystem::path(fileName), std::ios::in | std::ios::binary | std::ios::ate);
if (!inFile) if (!inFile)
return E_FAIL; return E_FAIL;
@ -368,7 +368,7 @@ namespace
inFile.close(); inFile.close();
size_t len = fileLen; size_t len = fileLen;
#endif #endif
// DDS files always start with the same magic number ("DDS ") // DDS files always start with the same magic number ("DDS ")
auto const dwMagicNumber = *reinterpret_cast<const uint32_t*>(ddsData.get()); auto const dwMagicNumber = *reinterpret_cast<const uint32_t*>(ddsData.get());
@ -690,13 +690,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -716,7 +716,7 @@ namespace
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a ) #define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a )
DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT& ddpf) noexcept DXGI_FORMAT GetDXGIFormat(const DDS_PIXELFORMAT& ddpf) noexcept
{ {
@ -983,10 +983,10 @@ namespace
return DXGI_FORMAT_UNKNOWN; return DXGI_FORMAT_UNKNOWN;
} }
#undef ISBITMASK #undef ISBITMASK
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
DXGI_FORMAT MakeSRGB(_In_ DXGI_FORMAT format) noexcept DXGI_FORMAT MakeSRGB(_In_ DXGI_FORMAT format) noexcept
{ {
switch (format) switch (format)
@ -1503,15 +1503,15 @@ namespace
} }
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
DDS_ALPHA_MODE GetAlphaMode( _In_ const DDS_HEADER* header ) noexcept DDS_ALPHA_MODE GetAlphaMode(_In_ const DDS_HEADER* header) noexcept
{ {
if ( header->ddspf.flags & DDS_FOURCC ) if (header->ddspf.flags & DDS_FOURCC)
{ {
if ( MAKEFOURCC( 'D', 'X', '1', '0' ) == header->ddspf.fourCC ) if (MAKEFOURCC('D', 'X', '1', '0') == header->ddspf.fourCC)
{ {
auto d3d10ext = reinterpret_cast<const DDS_HEADER_DXT10*>(reinterpret_cast<const uint8_t*>(header) + sizeof(DDS_HEADER)); auto d3d10ext = reinterpret_cast<const DDS_HEADER_DXT10*>(reinterpret_cast<const uint8_t*>(header) + sizeof(DDS_HEADER));
auto const mode = static_cast<DDS_ALPHA_MODE>( d3d10ext->miscFlags2 & DDS_MISC_FLAGS2_ALPHA_MODE_MASK ); auto const mode = static_cast<DDS_ALPHA_MODE>(d3d10ext->miscFlags2 & DDS_MISC_FLAGS2_ALPHA_MODE_MASK);
switch( mode ) switch (mode)
{ {
case DDS_ALPHA_MODE_STRAIGHT: case DDS_ALPHA_MODE_STRAIGHT:
case DDS_ALPHA_MODE_PREMULTIPLIED: case DDS_ALPHA_MODE_PREMULTIPLIED:
@ -1524,8 +1524,8 @@ namespace
break; break;
} }
} }
else if ( ( MAKEFOURCC( 'D', 'X', 'T', '2' ) == header->ddspf.fourCC ) else if ((MAKEFOURCC('D', 'X', 'T', '2') == header->ddspf.fourCC)
|| ( MAKEFOURCC( 'D', 'X', 'T', '4' ) == header->ddspf.fourCC ) ) || (MAKEFOURCC('D', 'X', 'T', '4') == header->ddspf.fourCC))
{ {
return DDS_ALPHA_MODE_PREMULTIPLIED; return DDS_ALPHA_MODE_PREMULTIPLIED;
} }
@ -1539,7 +1539,7 @@ namespace
_In_z_ const wchar_t* fileName, _In_z_ const wchar_t* fileName,
_In_ ID3D12Resource** texture) noexcept _In_ ID3D12Resource** texture) noexcept
{ {
#if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) #if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
if (texture && *texture) if (texture && *texture)
{ {
const wchar_t* pstrName = wcsrchr(fileName, '\\'); const wchar_t* pstrName = wcsrchr(fileName, '\\');
@ -1554,10 +1554,10 @@ namespace
(*texture)->SetName(pstrName); (*texture)->SetName(pstrName);
} }
#else #else
UNREFERENCED_PARAMETER(fileName); UNREFERENCED_PARAMETER(fileName);
UNREFERENCED_PARAMETER(texture); UNREFERENCED_PARAMETER(texture);
#endif #endif
} }
} // anonymous namespace } // anonymous namespace

32
DDSTextureLoader/DDSTextureLoader9.cpp
View File

@ -47,7 +47,7 @@ using Microsoft::WRL::ComPtr;
// Macros // Macros
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */ #endif /* defined(MAKEFOURCC) */
@ -199,13 +199,13 @@ namespace
*bitSize = 0; *bitSize = 0;
// open the file // open the file
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
ScopedHandle hFile(safe_handle(CreateFile2(fileName, ScopedHandle hFile(safe_handle(CreateFile2(fileName,
GENERIC_READ, GENERIC_READ,
FILE_SHARE_READ, FILE_SHARE_READ,
OPEN_EXISTING, OPEN_EXISTING,
nullptr))); nullptr)));
#else #else
ScopedHandle hFile(safe_handle(CreateFileW(fileName, ScopedHandle hFile(safe_handle(CreateFileW(fileName,
GENERIC_READ, GENERIC_READ,
FILE_SHARE_READ, FILE_SHARE_READ,
@ -213,7 +213,7 @@ namespace
OPEN_EXISTING, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL,
nullptr))); nullptr)));
#endif #endif
if (!hFile) if (!hFile)
{ {
@ -338,9 +338,9 @@ namespace
case D3DFMT_INDEX32: case D3DFMT_INDEX32:
case D3DFMT_G16R16F: case D3DFMT_G16R16F:
case D3DFMT_R32F: case D3DFMT_R32F:
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_D32_LOCKABLE: case D3DFMT_D32_LOCKABLE:
#endif #endif
return 32; return 32;
case D3DFMT_R8G8B8: case D3DFMT_R8G8B8:
@ -383,9 +383,9 @@ namespace
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directshow/htm/directxvideoaccelerationdxvavideosubtypes.asp // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directshow/htm/directxvideoaccelerationdxvavideosubtypes.asp
case MAKEFOURCC('A', 'I', '4', '4'): case MAKEFOURCC('A', 'I', '4', '4'):
case MAKEFOURCC('I', 'A', '4', '4'): case MAKEFOURCC('I', 'A', '4', '4'):
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_S8_LOCKABLE: case D3DFMT_S8_LOCKABLE:
#endif #endif
return 8; return 8;
case D3DFMT_DXT1: case D3DFMT_DXT1:
@ -394,10 +394,10 @@ namespace
case MAKEFOURCC('Y', 'V', '1', '2'): case MAKEFOURCC('Y', 'V', '1', '2'):
return 12; return 12;
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_A1: case D3DFMT_A1:
return 1; return 1;
#endif #endif
default: default:
return 0; return 0;
@ -483,13 +483,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -509,7 +509,7 @@ namespace
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a ) #define ISBITMASK( r,g,b,a ) ( ddpf.RBitMask == r && ddpf.GBitMask == g && ddpf.BBitMask == b && ddpf.ABitMask == a )
D3DFORMAT GetD3D9Format(const DDS_PIXELFORMAT& ddpf) noexcept D3DFORMAT GetD3D9Format(const DDS_PIXELFORMAT& ddpf) noexcept
{ {
@ -766,10 +766,10 @@ namespace
return D3DFMT_UNKNOWN; return D3DFMT_UNKNOWN;
} }
#undef ISBITMASK #undef ISBITMASK
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
HRESULT CreateTextureFromDDS( HRESULT CreateTextureFromDDS(
_In_ LPDIRECT3DDEVICE9 device, _In_ LPDIRECT3DDEVICE9 device,
_In_ const DDS_HEADER* header, _In_ const DDS_HEADER* header,

30
DirectXTex/BC.cpp
View File

@ -84,9 +84,9 @@ namespace
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++) for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
{ {
#ifdef COLOR_WEIGHTS #ifdef COLOR_WEIGHTS
if (pPoints[iPoint].a > 0.0f) if (pPoints[iPoint].a > 0.0f)
#endif // COLOR_WEIGHTS #endif // COLOR_WEIGHTS
{ {
if (pPoints[iPoint].r < X.r) if (pPoints[iPoint].r < X.r)
X.r = pPoints[iPoint].r; X.r = pPoints[iPoint].r;
@ -144,7 +144,7 @@ namespace
float f; float f;
#ifdef COLOR_WEIGHTS #ifdef COLOR_WEIGHTS
f = Pt.r + Pt.g + Pt.b; f = Pt.r + Pt.g + Pt.b;
fDir[0] += pPoints[iPoint].a * f * f; fDir[0] += pPoints[iPoint].a * f * f;
@ -156,7 +156,7 @@ namespace
f = Pt.r - Pt.g - Pt.b; f = Pt.r - Pt.g - Pt.b;
fDir[3] += pPoints[iPoint].a * f * f; fDir[3] += pPoints[iPoint].a * f * f;
#else #else
f = Pt.r + Pt.g + Pt.b; f = Pt.r + Pt.g + Pt.b;
fDir[0] += f * f; fDir[0] += f * f;
@ -168,7 +168,7 @@ namespace
f = Pt.r - Pt.g - Pt.b; f = Pt.r - Pt.g - Pt.b;
fDir[3] += f * f; fDir[3] += f * f;
#endif // COLOR_WEIGHTS #endif // COLOR_WEIGHTS
} }
float fDirMax = fDir[0]; float fDirMax = fDir[0];
@ -264,13 +264,13 @@ namespace
Diff.b = pSteps[iStep].b - pPoints[iPoint].b; Diff.b = pSteps[iStep].b - pPoints[iPoint].b;
Diff.a = 0.0f; Diff.a = 0.0f;
#ifdef COLOR_WEIGHTS #ifdef COLOR_WEIGHTS
const float fC = pC[iStep] * pPoints[iPoint].a * (1.0f / 8.0f); const float fC = pC[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
const float fD = pD[iStep] * pPoints[iPoint].a * (1.0f / 8.0f); const float fD = pD[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
#else #else
const float fC = pC[iStep] * (1.0f / 8.0f); const float fC = pC[iStep] * (1.0f / 8.0f);
const float fD = pD[iStep] * (1.0f / 8.0f); const float fD = pD[iStep] * (1.0f / 8.0f);
#endif // COLOR_WEIGHTS #endif // COLOR_WEIGHTS
d2X += fC * pC[iStep]; d2X += fC * pC[iStep];
dX.r += fC * Diff.r; dX.r += fC * Diff.r;
@ -434,11 +434,11 @@ namespace
Color[i].g = static_cast<float>(static_cast<int32_t>(Clr.g * 63.0f + 0.5f)) * (1.0f / 63.0f); Color[i].g = static_cast<float>(static_cast<int32_t>(Clr.g * 63.0f + 0.5f)) * (1.0f / 63.0f);
Color[i].b = static_cast<float>(static_cast<int32_t>(Clr.b * 31.0f + 0.5f)) * (1.0f / 31.0f); Color[i].b = static_cast<float>(static_cast<int32_t>(Clr.b * 31.0f + 0.5f)) * (1.0f / 31.0f);
#ifdef COLOR_WEIGHTS #ifdef COLOR_WEIGHTS
Color[i].a = pColor[i].a; Color[i].a = pColor[i].a;
#else #else
Color[i].a = 1.0f; Color[i].a = 1.0f;
#endif // COLOR_WEIGHTS #endif // COLOR_WEIGHTS
if (flags & BC_FLAGS_DITHER_RGB) if (flags & BC_FLAGS_DITHER_RGB)
{ {
@ -688,7 +688,7 @@ namespace
#ifdef COLOR_WEIGHTS #ifdef COLOR_WEIGHTS
void EncodeSolidBC1(_Out_ D3DX_BC1 *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pColor) void EncodeSolidBC1(_Out_ D3DX_BC1 *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pColor)
{ {
#ifdef COLOR_AVG_0WEIGHTS #ifdef COLOR_AVG_0WEIGHTS
// Compute avg color // Compute avg color
HDRColorA Color; HDRColorA Color;
Color.r = pColor[0].r; Color.r = pColor[0].r;
@ -707,9 +707,9 @@ namespace
Color.b *= 1.0f / 16.0f; Color.b *= 1.0f / 16.0f;
const uint16_t wColor = Encode565(&Color); const uint16_t wColor = Encode565(&Color);
#else #else
const uint16_t wColor = 0x0000; const uint16_t wColor = 0x0000;
#endif // COLOR_AVG_0WEIGHTS #endif // COLOR_AVG_0WEIGHTS
// Encode solid block // Encode solid block
pBC->rgb[0] = wColor; pBC->rgb[0] = wColor;
@ -814,7 +814,7 @@ void DirectX::D3DXDecodeBC2(XMVECTOR *pColor, const uint8_t *pBC) noexcept
for (size_t i = 0; i < 8; ++i, dw >>= 4) for (size_t i = 0; i < 8; ++i, dw >>= 4)
{ {
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
pColor[i] = XMVectorSetW(pColor[i], static_cast<float>(dw & 0xf) * (1.0f / 15.0f)); pColor[i] = XMVectorSetW(pColor[i], static_cast<float>(dw & 0xf) * (1.0f / 15.0f));
} }

122
DirectXTex/BC.h
View File

@ -27,27 +27,37 @@ namespace DirectX
// Constants // Constants
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
enum BC_FLAGS : uint32_t enum BC_FLAGS : uint32_t
{ {
BC_FLAGS_NONE = 0x0, BC_FLAGS_NONE = 0x0,
BC_FLAGS_DITHER_RGB = 0x10000, // Enables dithering for RGB colors for BC1-3
BC_FLAGS_DITHER_A = 0x20000, // Enables dithering for Alpha channel for BC1-3
BC_FLAGS_UNIFORM = 0x40000, // By default, uses perceptual weighting for BC1-3; this flag makes it a uniform weighting
BC_FLAGS_USE_3SUBSETS = 0x80000, // By default, BC7 skips mode 0 & 2; this flag adds those modes back
BC_FLAGS_FORCE_BC7_MODE6 = 0x100000, // BC7 should only use mode 6; skip other modes
};
//------------------------------------------------------------------------------------- BC_FLAGS_DITHER_RGB = 0x10000,
// Structures // Enables dithering for RGB colors for BC1-3
//-------------------------------------------------------------------------------------
class LDRColorA;
class HDRColorA BC_FLAGS_DITHER_A = 0x20000,
{ // Enables dithering for Alpha channel for BC1-3
public:
BC_FLAGS_UNIFORM = 0x40000,
// By default, uses perceptual weighting for BC1-3; this flag makes it a uniform weighting
BC_FLAGS_USE_3SUBSETS = 0x80000,
// By default, BC7 skips mode 0 & 2; this flag adds those modes back
BC_FLAGS_FORCE_BC7_MODE6 = 0x100000,
// BC7 should only use mode 6; skip other modes
};
//-------------------------------------------------------------------------------------
// Structures
//-------------------------------------------------------------------------------------
class LDRColorA;
class HDRColorA
{
public:
float r, g, b, a; float r, g, b, a;
public: public:
HDRColorA() = default; HDRColorA() = default;
HDRColorA(float _r, float _g, float _b, float _a) noexcept : r(_r), g(_g), b(_b), a(_a) {} HDRColorA(float _r, float _g, float _b, float _a) noexcept : r(_r), g(_g), b(_b), a(_a) {}
HDRColorA(const HDRColorA& c) noexcept : r(c.r), g(c.g), b(c.b), a(c.a) {} HDRColorA(const HDRColorA& c) noexcept : r(c.r), g(c.g), b(c.b), a(c.a) {}
@ -129,39 +139,39 @@ public:
HDRColorA(const LDRColorA& c) noexcept; HDRColorA(const LDRColorA& c) noexcept;
HDRColorA& operator = (const LDRColorA& c) noexcept; HDRColorA& operator = (const LDRColorA& c) noexcept;
LDRColorA ToLDRColorA() const noexcept; LDRColorA ToLDRColorA() const noexcept;
}; };
inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRColorA *pC1, _In_ const HDRColorA *pC2, _In_ float s) noexcept inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRColorA *pC1, _In_ const HDRColorA *pC2, _In_ float s) noexcept
{ {
pOut->r = pC1->r + s * (pC2->r - pC1->r); pOut->r = pC1->r + s * (pC2->r - pC1->r);
pOut->g = pC1->g + s * (pC2->g - pC1->g); pOut->g = pC1->g + s * (pC2->g - pC1->g);
pOut->b = pC1->b + s * (pC2->b - pC1->b); pOut->b = pC1->b + s * (pC2->b - pC1->b);
pOut->a = pC1->a + s * (pC2->a - pC1->a); pOut->a = pC1->a + s * (pC2->a - pC1->a);
return pOut; return pOut;
} }
#pragma pack(push,1) #pragma pack(push,1)
// BC1/DXT1 compression (4 bits per texel) // BC1/DXT1 compression (4 bits per texel)
struct D3DX_BC1 struct D3DX_BC1
{ {
uint16_t rgb[2]; // 565 colors uint16_t rgb[2]; // 565 colors
uint32_t bitmap; // 2bpp rgb bitmap uint32_t bitmap; // 2bpp rgb bitmap
}; };
// BC2/DXT2/3 compression (8 bits per texel) // BC2/DXT2/3 compression (8 bits per texel)
struct D3DX_BC2 struct D3DX_BC2
{ {
uint32_t bitmap[2]; // 4bpp alpha bitmap uint32_t bitmap[2]; // 4bpp alpha bitmap
D3DX_BC1 bc1; // BC1 rgb data D3DX_BC1 bc1; // BC1 rgb data
}; };
// BC3/DXT4/5 compression (8 bits per texel) // BC3/DXT4/5 compression (8 bits per texel)
struct D3DX_BC3 struct D3DX_BC3
{ {
uint8_t alpha[2]; // alpha values uint8_t alpha[2]; // alpha values
uint8_t bitmap[6]; // 3bpp alpha bitmap uint8_t bitmap[6]; // 3bpp alpha bitmap
D3DX_BC1 bc1; // BC1 rgb data D3DX_BC1 bc1; // BC1 rgb data
}; };
#pragma pack(pop) #pragma pack(pop)
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@ -169,8 +179,8 @@ struct D3DX_BC3
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4127) #pragma warning(disable : 4127)
template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPoints, uint32_t cSteps) noexcept template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPoints, uint32_t cSteps) noexcept
{ {
static const float pC6[] = { 5.0f / 5.0f, 4.0f / 5.0f, 3.0f / 5.0f, 2.0f / 5.0f, 1.0f / 5.0f, 0.0f / 5.0f }; static const float pC6[] = { 5.0f / 5.0f, 4.0f / 5.0f, 3.0f / 5.0f, 2.0f / 5.0f, 1.0f / 5.0f, 0.0f / 5.0f };
static const float pD6[] = { 0.0f / 5.0f, 1.0f / 5.0f, 2.0f / 5.0f, 3.0f / 5.0f, 4.0f / 5.0f, 5.0f / 5.0f }; static const float pD6[] = { 0.0f / 5.0f, 1.0f / 5.0f, 2.0f / 5.0f, 3.0f / 5.0f, 4.0f / 5.0f, 5.0f / 5.0f };
static const float pC8[] = { 7.0f / 7.0f, 6.0f / 7.0f, 5.0f / 7.0f, 4.0f / 7.0f, 3.0f / 7.0f, 2.0f / 7.0f, 1.0f / 7.0f, 0.0f / 7.0f }; static const float pC8[] = { 7.0f / 7.0f, 6.0f / 7.0f, 5.0f / 7.0f, 4.0f / 7.0f, 3.0f / 7.0f, 2.0f / 7.0f, 1.0f / 7.0f, 0.0f / 7.0f };
@ -293,38 +303,38 @@ template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPo
*pX = (fX < MIN_VALUE) ? MIN_VALUE : (fX > MAX_VALUE) ? MAX_VALUE : fX; *pX = (fX < MIN_VALUE) ? MIN_VALUE : (fX > MAX_VALUE) ? MAX_VALUE : fX;
*pY = (fY < MIN_VALUE) ? MIN_VALUE : (fY > MAX_VALUE) ? MAX_VALUE : fY; *pY = (fY < MIN_VALUE) ? MIN_VALUE : (fY > MAX_VALUE) ? MAX_VALUE : fY;
} }
#pragma warning(pop) #pragma warning(pop)
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
// Functions // Functions
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
typedef void (*BC_DECODE)(XMVECTOR *pColor, const uint8_t *pBC); typedef void (*BC_DECODE)(XMVECTOR *pColor, const uint8_t *pBC);
typedef void (*BC_ENCODE)(uint8_t *pDXT, const XMVECTOR *pColor, uint32_t flags); typedef void (*BC_ENCODE)(uint8_t *pDXT, const XMVECTOR *pColor, uint32_t flags);
void D3DXDecodeBC1(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept; void D3DXDecodeBC1(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
void D3DXDecodeBC2(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC2(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC3(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC3(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC4U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept; void D3DXDecodeBC4U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
void D3DXDecodeBC4S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept; void D3DXDecodeBC4S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
void D3DXDecodeBC5U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC5U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC5S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC5S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC6HU(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC6HU(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC6HS(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC6HS(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXDecodeBC7(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept; void D3DXDecodeBC7(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
void D3DXEncodeBC1(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ float threshold, _In_ uint32_t flags) noexcept; void D3DXEncodeBC1(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ float threshold, _In_ uint32_t flags) noexcept;
// BC1 requires one additional parameter, so it doesn't match signature of BC_ENCODE above // BC1 requires one additional parameter, so it doesn't match signature of BC_ENCODE above
void D3DXEncodeBC2(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC2(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC3(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC3(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC4U(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC4U(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC4S(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC4S(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC5U(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC5U(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC5S(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC5S(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC6HU(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC6HU(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC6HS(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC6HS(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
void D3DXEncodeBC7(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept; void D3DXEncodeBC7(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
} // namespace } // namespace

8
DirectXTex/BC4BC5.cpp
View File

@ -395,7 +395,7 @@ void DirectX::D3DXDecodeBC4U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f); pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
} }
} }
@ -410,7 +410,7 @@ void DirectX::D3DXDecodeBC4S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f); pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
} }
} }
@ -472,7 +472,7 @@ void DirectX::D3DXDecodeBC5U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f); pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
} }
} }
@ -488,7 +488,7 @@ void DirectX::D3DXDecodeBC5S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f); pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
} }
} }

104
DirectXTex/BC6HBC7.cpp
View File

@ -660,8 +660,8 @@ namespace
void Encode(_In_ bool bSigned, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pIn) noexcept; void Encode(_In_ bool bSigned, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pIn) noexcept;
private: private:
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4480) #pragma warning(disable : 4480)
enum EField : uint8_t enum EField : uint8_t
{ {
NA, // N/A NA, // N/A
@ -680,7 +680,7 @@ namespace
BY, BY,
BZ, BZ,
}; };
#pragma warning(pop) #pragma warning(pop)
struct ModeDescriptor struct ModeDescriptor
{ {
@ -697,8 +697,8 @@ namespace
LDRColorA RGBAPrec[BC6H_MAX_REGIONS][2]; LDRColorA RGBAPrec[BC6H_MAX_REGIONS][2];
}; };
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4512) #pragma warning(disable : 4512)
struct EncodeParams struct EncodeParams
{ {
float fBestErr; float fBestErr;
@ -718,7 +718,7 @@ namespace
} }
} }
}; };
#pragma warning(pop) #pragma warning(pop)
static int Quantize(_In_ int iValue, _In_ int prec, _In_ bool bSigned) noexcept; static int Quantize(_In_ int iValue, _In_ int prec, _In_ bool bSigned) noexcept;
static int Unquantize(_In_ int comp, _In_ uint8_t uBitsPerComp, _In_ bool bSigned) noexcept; static int Unquantize(_In_ int comp, _In_ uint8_t uBitsPerComp, _In_ bool bSigned) noexcept;
@ -777,8 +777,8 @@ namespace
LDRColorA RGBAPrecWithP; LDRColorA RGBAPrecWithP;
}; };
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4512) #pragma warning(disable : 4512)
struct EncodeParams struct EncodeParams
{ {
uint8_t uMode; uint8_t uMode;
@ -788,7 +788,7 @@ namespace
EncodeParams(const HDRColorA* const aOriginal) noexcept : uMode(0), aEndPts{}, aLDRPixels{}, aHDRPixels(aOriginal) {} EncodeParams(const HDRColorA* const aOriginal) noexcept : uMode(0), aEndPts{}, aLDRPixels{}, aHDRPixels(aOriginal) {}
}; };
#pragma warning(pop) #pragma warning(pop)
static uint8_t Quantize(_In_ uint8_t comp, _In_ uint8_t uPrec) noexcept static uint8_t Quantize(_In_ uint8_t comp, _In_ uint8_t uPrec) noexcept
{ {
@ -1035,20 +1035,20 @@ const D3DX_BC6H::ModeDescriptor D3DX_BC6H::ms_aDesc[14][82] =
// Mode, Partitions, Transformed, IndexPrec, RGBAPrec // Mode, Partitions, Transformed, IndexPrec, RGBAPrec
const D3DX_BC6H::ModeInfo D3DX_BC6H::ms_aInfo[] = const D3DX_BC6H::ModeInfo D3DX_BC6H::ms_aInfo[] =
{ {
{0x00, 1, true, 3, { { LDRColorA(10,10,10,0), LDRColorA( 5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 1 {0x00, 1, true, 3, { { LDRColorA(10,10,10,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 1
{0x01, 1, true, 3, { { LDRColorA( 7, 7, 7,0), LDRColorA( 6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 2 {0x01, 1, true, 3, { { LDRColorA(7, 7, 7,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 2
{0x02, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 5, 4, 4,0) }, { LDRColorA(5,4,4,0), LDRColorA(5,4,4,0) } } }, // Mode 3 {0x02, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(5, 4, 4,0) }, { LDRColorA(5,4,4,0), LDRColorA(5,4,4,0) } } }, // Mode 3
{0x06, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 4, 5, 4,0) }, { LDRColorA(4,5,4,0), LDRColorA(4,5,4,0) } } }, // Mode 4 {0x06, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(4, 5, 4,0) }, { LDRColorA(4,5,4,0), LDRColorA(4,5,4,0) } } }, // Mode 4
{0x0a, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 4, 4, 5,0) }, { LDRColorA(4,4,5,0), LDRColorA(4,4,5,0) } } }, // Mode 5 {0x0a, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(4, 4, 5,0) }, { LDRColorA(4,4,5,0), LDRColorA(4,4,5,0) } } }, // Mode 5
{0x0e, 1, true, 3, { { LDRColorA( 9, 9, 9,0), LDRColorA( 5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 6 {0x0e, 1, true, 3, { { LDRColorA(9, 9, 9,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 6
{0x12, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 6, 5, 5,0) }, { LDRColorA(6,5,5,0), LDRColorA(6,5,5,0) } } }, // Mode 7 {0x12, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(6, 5, 5,0) }, { LDRColorA(6,5,5,0), LDRColorA(6,5,5,0) } } }, // Mode 7
{0x16, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 5, 6, 5,0) }, { LDRColorA(5,6,5,0), LDRColorA(5,6,5,0) } } }, // Mode 8 {0x16, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 6, 5,0) }, { LDRColorA(5,6,5,0), LDRColorA(5,6,5,0) } } }, // Mode 8
{0x1a, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 5, 5, 6,0) }, { LDRColorA(5,5,6,0), LDRColorA(5,5,6,0) } } }, // Mode 9 {0x1a, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 5, 6,0) }, { LDRColorA(5,5,6,0), LDRColorA(5,5,6,0) } } }, // Mode 9
{0x1e, 1, false, 3, { { LDRColorA( 6, 6, 6,0), LDRColorA( 6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 10 {0x1e, 1, false, 3, { { LDRColorA(6, 6, 6,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 10
{0x03, 0, false, 4, { { LDRColorA(10,10,10,0), LDRColorA(10,10,10,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 11 {0x03, 0, false, 4, { { LDRColorA(10,10,10,0), LDRColorA(10,10,10,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 11
{0x07, 0, true, 4, { { LDRColorA(11,11,11,0), LDRColorA( 9, 9, 9,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 12 {0x07, 0, true, 4, { { LDRColorA(11,11,11,0), LDRColorA(9, 9, 9,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 12
{0x0b, 0, true, 4, { { LDRColorA(12,12,12,0), LDRColorA( 8, 8, 8,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 13 {0x0b, 0, true, 4, { { LDRColorA(12,12,12,0), LDRColorA(8, 8, 8,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 13
{0x0f, 0, true, 4, { { LDRColorA(16,16,16,0), LDRColorA( 4, 4, 4,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 14 {0x0f, 0, true, 4, { { LDRColorA(16,16,16,0), LDRColorA(4, 4, 4,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 14
}; };
const int D3DX_BC6H::ms_aModeToInfo[] = const int D3DX_BC6H::ms_aModeToInfo[] =
@ -1628,13 +1628,13 @@ namespace
{ {
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
#ifdef _DEBUG #ifdef _DEBUG
// Use Magenta in debug as a highly-visible error color // Use Magenta in debug as a highly-visible error color
pOut[i] = HDRColorA(1.0f, 0.0f, 1.0f, 1.0f); pOut[i] = HDRColorA(1.0f, 0.0f, 1.0f, 1.0f);
#else #else
// In production use, default to black // In production use, default to black
pOut[i] = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f); pOut[i] = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f);
#endif #endif
} }
} }
} }
@ -1695,9 +1695,9 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
case BZ: aEndPts[1].B.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break; case BZ: aEndPts[1].B.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
default: default:
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC6H: Invalid header bits encountered during decoding\n"); OutputDebugStringA("BC6H: Invalid header bits encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -1739,9 +1739,9 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
const size_t uNumBits = IsFixUpOffset(info.uPartitions, uShape, i) ? info.uIndexPrec - 1u : info.uIndexPrec; const size_t uNumBits = IsFixUpOffset(info.uPartitions, uShape, i) ? info.uIndexPrec - 1u : info.uIndexPrec;
if (uStartBit + uNumBits > 128) if (uStartBit + uNumBits > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC6H: Invalid block encountered during decoding\n"); OutputDebugStringA("BC6H: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -1749,9 +1749,9 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
if (uIndex >= ((info.uPartitions > 0) ? 8 : 16)) if (uIndex >= ((info.uPartitions > 0) ? 8 : 16))
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC6H: Invalid index encountered during decoding\n"); OutputDebugStringA("BC6H: Invalid index encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -1784,7 +1784,7 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
} }
else else
{ {
#ifdef _DEBUG #ifdef _DEBUG
const char* warnstr = "BC6H: Invalid mode encountered during decoding\n"; const char* warnstr = "BC6H: Invalid mode encountered during decoding\n";
switch (uMode) switch (uMode)
{ {
@ -1794,7 +1794,7 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
case 0x1F: warnstr = "BC6H: Reserved mode 11111 encountered during decoding\n"; break; case 0x1F: warnstr = "BC6H: Reserved mode 11111 encountered during decoding\n"; break;
} }
OutputDebugStringA(warnstr); OutputDebugStringA(warnstr);
#endif #endif
// Per the BC6H format spec, we must return opaque black // Per the BC6H format spec, we must return opaque black
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i) for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
{ {
@ -2003,7 +2003,7 @@ void D3DX_BC6H::GeneratePaletteQuantized(const EncodeParams* pEP, const INTEndPn
assert(false); assert(false);
for (size_t i = 0; i < uNumIndices; ++i) for (size_t i = 0; i < uNumIndices; ++i)
{ {
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
aPalette[i] = INTColor(0, 0, 0); aPalette[i] = INTColor(0, 0, 0);
} }
return; return;
@ -2409,7 +2409,7 @@ void D3DX_BC6H::GeneratePaletteUnquantized(const EncodeParams* pEP, size_t uRegi
assert(false); assert(false);
for (size_t i = 0; i < uNumIndices; ++i) for (size_t i = 0; i < uNumIndices; ++i)
{ {
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool") #pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
aPalette[i] = INTColor(0, 0, 0); aPalette[i] = INTColor(0, 0, 0);
} }
return; return;
@ -2558,9 +2558,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
{ {
if (uStartBit + RGBAPrec.r > 128) if (uStartBit + RGBAPrec.r > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2573,9 +2573,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
{ {
if (uStartBit + RGBAPrec.g > 128) if (uStartBit + RGBAPrec.g > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2588,9 +2588,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
{ {
if (uStartBit + RGBAPrec.b > 128) if (uStartBit + RGBAPrec.b > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2603,9 +2603,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
{ {
if (uStartBit + RGBAPrec.a > 128) if (uStartBit + RGBAPrec.a > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2620,9 +2620,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
{ {
if (uStartBit > 127) if (uStartBit > 127)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2658,9 +2658,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
const size_t uNumBits = IsFixUpOffset(ms_aInfo[uMode].uPartitions, uShape, i) ? uIndexPrec - 1u : uIndexPrec; const size_t uNumBits = IsFixUpOffset(ms_aInfo[uMode].uPartitions, uShape, i) ? uIndexPrec - 1u : uIndexPrec;
if (uStartBit + uNumBits > 128) if (uStartBit + uNumBits > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2675,9 +2675,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
const size_t uNumBits = i ? uIndexPrec2 : uIndexPrec2 - 1u; const size_t uNumBits = i ? uIndexPrec2 : uIndexPrec2 - 1u;
if (uStartBit + uNumBits > 128) if (uStartBit + uNumBits > 128)
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Invalid block encountered during decoding\n"); OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
#endif #endif
FillWithErrorColors(pOut); FillWithErrorColors(pOut);
return; return;
} }
@ -2717,9 +2717,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
} }
else else
{ {
#ifdef _DEBUG #ifdef _DEBUG
OutputDebugStringA("BC7: Reserved mode 8 encountered during decoding\n"); OutputDebugStringA("BC7: Reserved mode 8 encountered during decoding\n");
#endif #endif
// Per the BC7 format spec, we must return transparent black // Per the BC7 format spec, we must return transparent black
memset(pOut, 0, sizeof(HDRColorA) * NUM_PIXELS_PER_BLOCK); memset(pOut, 0, sizeof(HDRColorA) * NUM_PIXELS_PER_BLOCK);
} }
@ -3201,7 +3201,7 @@ void D3DX_BC7::EmitBlock(const EncodeParams* pEP, size_t uShape, size_t uRotatio
for (i = 0; i < uPBits; i++) for (i = 0; i < uPBits; i++)
{ {
SetBits(uStartBit, 1, aPVote[i] > (aCount[i] >> 1) ? 1u : 0u); SetBits(uStartBit, 1, (aPVote[i] >(aCount[i] >> 1)) ? 1u : 0u);
} }
} }
else else

14
DirectXTex/BCDirectCompute.cpp
View File

@ -20,13 +20,13 @@ using Microsoft::WRL::ComPtr;
namespace namespace
{ {
#include "BC7Encode_EncodeBlockCS.inc" #include "BC7Encode_EncodeBlockCS.inc"
#include "BC7Encode_TryMode02CS.inc" #include "BC7Encode_TryMode02CS.inc"
#include "BC7Encode_TryMode137CS.inc" #include "BC7Encode_TryMode137CS.inc"
#include "BC7Encode_TryMode456CS.inc" #include "BC7Encode_TryMode456CS.inc"
#include "BC6HEncode_EncodeBlockCS.inc" #include "BC6HEncode_EncodeBlockCS.inc"
#include "BC6HEncode_TryModeG10CS.inc" #include "BC6HEncode_TryModeG10CS.inc"
#include "BC6HEncode_TryModeLE10CS.inc" #include "BC6HEncode_TryModeLE10CS.inc"
struct BufferBC6HBC7 struct BufferBC6HBC7
{ {

144
DirectXTex/DDS.h
View File

@ -25,10 +25,10 @@ namespace DirectX
#pragma pack(push,1) #pragma pack(push,1)
constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS " constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
struct DDS_PIXELFORMAT struct DDS_PIXELFORMAT
{ {
uint32_t size; uint32_t size;
uint32_t flags; uint32_t flags;
uint32_t fourCC; uint32_t fourCC;
@ -37,7 +37,7 @@ struct DDS_PIXELFORMAT
uint32_t GBitMask; uint32_t GBitMask;
uint32_t BBitMask; uint32_t BBitMask;
uint32_t ABitMask; uint32_t ABitMask;
}; };
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC #define DDS_FOURCC 0x00000004 // DDPF_FOURCC
#define DDS_RGB 0x00000040 // DDPF_RGB #define DDS_RGB 0x00000040 // DDPF_RGB
@ -52,7 +52,7 @@ struct DDS_PIXELFORMAT
// DDS_BUMPLUMINANCE 0x00040000 // DDS_BUMPLUMINANCE 0x00040000
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
(static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \ (static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
| (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \ | (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
| (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \ | (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
@ -60,131 +60,131 @@ struct DDS_PIXELFORMAT
#endif /* MAKEFOURCC */ #endif /* MAKEFOURCC */
#ifndef DDSGLOBALCONST #ifndef DDSGLOBALCONST
#if defined(__GNUC__) && !defined(__MINGW32__) #if defined(__GNUC__) && !defined(__MINGW32__)
#define DDSGLOBALCONST extern const __attribute__((weak)) #define DDSGLOBALCONST extern const __attribute__((weak))
#else #else
#define DDSGLOBALCONST extern const __declspec(selectany) #define DDSGLOBALCONST extern const __declspec(selectany)
#endif #endif
#endif /* DDSGLOBALCONST */ #endif /* DDSGLOBALCONST */
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','3'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','3'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','4'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','4'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','5'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','5'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R','G','B','G'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R','G','B','G'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G','R','G','B'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G','R','G','B'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x7c00, 0x03e0, 0x001f, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x7c00, 0x03e0, 0x001f, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0f00, 0x00f0, 0x000f, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0f00, 0x00f0, 0x000f, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 =
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x0f, 0, 0, 0xf0 }; { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x0f, 0, 0, 0xf0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 =
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 =
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 =
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0, 0, 0xff00 }; { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0, 0, 0xff00 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT =
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x00ff, 0, 0, 0xff00 }; { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x00ff, 0, 0, 0xff00 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xff, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xff, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xffff, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xffff, 0, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00ff, 0, 0, 0xff00 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00ff, 0, 0, 0xff00 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 =
{ sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0, 0, 0, 0xff }; { sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0, 0, 0, 0xff };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 =
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 =
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 }; { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 =
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
// D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue // D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000 };
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 }; { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
// We do not support the following legacy Direct3D 9 formats: // We do not support the following legacy Direct3D 9 formats:
@ -193,7 +193,7 @@ DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
// DDSPF_X8L8V8U8 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 }; // DDSPF_X8L8V8U8 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat) // This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 = DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','1','0'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','1','0'), 0, 0, 0, 0, 0 };
#define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT #define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
@ -225,38 +225,38 @@ DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
#define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME #define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME
// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION // Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
enum DDS_RESOURCE_DIMENSION : uint32_t enum DDS_RESOURCE_DIMENSION : uint32_t
{ {
DDS_DIMENSION_TEXTURE1D = 2, DDS_DIMENSION_TEXTURE1D = 2,
DDS_DIMENSION_TEXTURE2D = 3, DDS_DIMENSION_TEXTURE2D = 3,
DDS_DIMENSION_TEXTURE3D = 4, DDS_DIMENSION_TEXTURE3D = 4,
}; };
// Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
enum DDS_RESOURCE_MISC_FLAG : uint32_t enum DDS_RESOURCE_MISC_FLAG : uint32_t
{ {
DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L, DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
}; };
enum DDS_MISC_FLAGS2 : uint32_t enum DDS_MISC_FLAGS2 : uint32_t
{ {
DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L, DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
}; };
#ifndef DDS_ALPHA_MODE_DEFINED #ifndef DDS_ALPHA_MODE_DEFINED
#define DDS_ALPHA_MODE_DEFINED #define DDS_ALPHA_MODE_DEFINED
enum DDS_ALPHA_MODE : uint32_t enum DDS_ALPHA_MODE : uint32_t
{ {
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,
}; };
#endif #endif
struct DDS_HEADER struct DDS_HEADER
{ {
uint32_t size; uint32_t size;
uint32_t flags; uint32_t flags;
uint32_t height; uint32_t height;
@ -271,20 +271,20 @@ struct DDS_HEADER
uint32_t caps3; uint32_t caps3;
uint32_t caps4; uint32_t caps4;
uint32_t reserved2; 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 D3D11_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)
static_assert( sizeof(DDS_HEADER) == 124, "DDS Header size mismatch" ); static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch");
static_assert( sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch"); static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
} // namespace } // namespace

39
DirectXTex/DirectXTex.h
View File

@ -85,16 +85,35 @@ namespace DirectX
enum CP_FLAGS : unsigned long enum CP_FLAGS : unsigned long
{ {
CP_FLAGS_NONE = 0x0, // Normal operation CP_FLAGS_NONE = 0x0,
CP_FLAGS_LEGACY_DWORD = 0x1, // Assume pitch is DWORD aligned instead of BYTE aligned // Normal operation
CP_FLAGS_PARAGRAPH = 0x2, // Assume pitch is 16-byte aligned instead of BYTE aligned
CP_FLAGS_YMM = 0x4, // Assume pitch is 32-byte aligned instead of BYTE aligned CP_FLAGS_LEGACY_DWORD = 0x1,
CP_FLAGS_ZMM = 0x8, // Assume pitch is 64-byte aligned instead of BYTE aligned // Assume pitch is DWORD aligned instead of BYTE aligned
CP_FLAGS_PAGE4K = 0x200, // Assume pitch is 4096-byte aligned instead of BYTE aligned
CP_FLAGS_BAD_DXTN_TAILS = 0x1000, // BC formats with malformed mipchain blocks smaller than 4x4 CP_FLAGS_PARAGRAPH = 0x2,
CP_FLAGS_24BPP = 0x10000, // Override with a legacy 24 bits-per-pixel format size // Assume pitch is 16-byte aligned instead of BYTE aligned
CP_FLAGS_16BPP = 0x20000, // Override with a legacy 16 bits-per-pixel format size
CP_FLAGS_8BPP = 0x40000, // Override with a legacy 8 bits-per-pixel format size CP_FLAGS_YMM = 0x4,
// Assume pitch is 32-byte aligned instead of BYTE aligned
CP_FLAGS_ZMM = 0x8,
// Assume pitch is 64-byte aligned instead of BYTE aligned
CP_FLAGS_PAGE4K = 0x200,
// Assume pitch is 4096-byte aligned instead of BYTE aligned
CP_FLAGS_BAD_DXTN_TAILS = 0x1000,
// BC formats with malformed mipchain blocks smaller than 4x4
CP_FLAGS_24BPP = 0x10000,
// Override with a legacy 24 bits-per-pixel format size
CP_FLAGS_16BPP = 0x20000,
// Override with a legacy 16 bits-per-pixel format size
CP_FLAGS_8BPP = 0x40000,
// Override with a legacy 8 bits-per-pixel format size
}; };
HRESULT __cdecl ComputePitch( HRESULT __cdecl ComputePitch(

18
DirectXTex/DirectXTexCompress.cpp
View File

@ -158,7 +158,7 @@ namespace
{ {
for (size_t s = pw; s < 4; ++s) for (size_t s = pw; s < 4; ++s)
{ {
#pragma prefast(suppress: 26000, "PREFAST false positive") #pragma prefast(suppress: 26000, "PREFAST false positive")
temp[(t << 2) | s] = temp[(t << 2) | uSrc[s]]; temp[(t << 2) | s] = temp[(t << 2) | uSrc[s]];
} }
} }
@ -170,7 +170,7 @@ namespace
{ {
for (size_t s = 0; s < 4; ++s) for (size_t s = 0; s < 4; ++s)
{ {
#pragma prefast(suppress: 26000, "PREFAST false positive") #pragma prefast(suppress: 26000, "PREFAST false positive")
temp[(t << 2) | s] = temp[(uSrc[t] << 2) | s]; temp[(t << 2) | s] = temp[(uSrc[t] << 2) | s];
} }
} }
@ -239,7 +239,7 @@ namespace
bool fail = false; bool fail = false;
#pragma omp parallel for #pragma omp parallel for
for (int nb = 0; nb < static_cast<int>(nBlocks); ++nb) for (int nb = 0; nb < static_cast<int>(nBlocks); ++nb)
{ {
const int nbWidth = std::max<int>(1, int((image.width + 3) / 4)); const int nbWidth = std::max<int>(1, int((image.width + 3) / 4));
@ -615,11 +615,11 @@ HRESULT DirectX::Compress(
// Compress single image // Compress single image
if (compress & TEX_COMPRESS_PARALLEL) if (compress & TEX_COMPRESS_PARALLEL)
{ {
#ifndef _OPENMP #ifndef _OPENMP
return E_NOTIMPL; return E_NOTIMPL;
#else #else
hr = CompressBC_Parallel(srcImage, *img, GetBCFlags(compress), GetSRGBFlags(compress), threshold); hr = CompressBC_Parallel(srcImage, *img, GetBCFlags(compress), GetSRGBFlags(compress), threshold);
#endif // _OPENMP #endif // _OPENMP
} }
else else
{ {
@ -687,9 +687,9 @@ HRESULT DirectX::Compress(
if ((compress & TEX_COMPRESS_PARALLEL)) if ((compress & TEX_COMPRESS_PARALLEL))
{ {
#ifndef _OPENMP #ifndef _OPENMP
return E_NOTIMPL; return E_NOTIMPL;
#else #else
if (compress & TEX_COMPRESS_PARALLEL) if (compress & TEX_COMPRESS_PARALLEL)
{ {
hr = CompressBC_Parallel(src, dest[index], GetBCFlags(compress), GetSRGBFlags(compress), threshold); hr = CompressBC_Parallel(src, dest[index], GetBCFlags(compress), GetSRGBFlags(compress), threshold);
@ -699,7 +699,7 @@ HRESULT DirectX::Compress(
return hr; return hr;
} }
} }
#endif // _OPENMP #endif // _OPENMP
} }
else else
{ {

62
DirectXTex/DirectXTexConvert.cpp
View File

@ -69,7 +69,8 @@ namespace
{ {
Exponent--; Exponent--;
Mantissa <<= 1; Mantissa <<= 1;
} while ((Mantissa & 0x80) == 0); }
while ((Mantissa & 0x80) == 0);
Mantissa &= 0x7F; Mantissa &= 0x7F;
} }
@ -135,7 +136,8 @@ namespace
{ {
Exponent--; Exponent--;
Mantissa <<= 1; Mantissa <<= 1;
} while ((Mantissa & 0x40) == 0); }
while ((Mantissa & 0x40) == 0);
Mantissa &= 0x3F; Mantissa &= 0x3F;
} }
@ -3263,13 +3265,13 @@ void DirectX::Internal::ConvertScanline(
break; break;
} }
#if (__cplusplus >= 201703L) #if (__cplusplus >= 201703L)
[[fallthrough]]; [[fallthrough]];
#elif defined(__clang__) #elif defined(__clang__)
[[clang::fallthrough]]; [[clang::fallthrough]];
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
__fallthrough; __fallthrough;
#endif #endif
case TEX_FILTER_RGB_COPY_RED: case TEX_FILTER_RGB_COPY_RED:
{ {
@ -3553,13 +3555,13 @@ void DirectX::Internal::ConvertScanline(
break; break;
} }
#if (__cplusplus >= 201703L) #if (__cplusplus >= 201703L)
[[fallthrough]]; [[fallthrough]];
#elif defined(__clang__) #elif defined(__clang__)
[[clang::fallthrough]]; [[clang::fallthrough]];
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
__fallthrough; __fallthrough;
#endif #endif
case TEX_FILTER_RGB_COPY_RED: case TEX_FILTER_RGB_COPY_RED:
{ {
@ -3652,13 +3654,13 @@ void DirectX::Internal::ConvertScanline(
break; break;
} }
#if (__cplusplus >= 201703L) #if (__cplusplus >= 201703L)
[[fallthrough]]; [[fallthrough]];
#elif defined(__clang__) #elif defined(__clang__)
[[clang::fallthrough]]; [[clang::fallthrough]];
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
__fallthrough; __fallthrough;
#endif #endif
case TEX_FILTER_RGB_COPY_RED: case TEX_FILTER_RGB_COPY_RED:
// Leave data unchanged and the store will handle this... // Leave data unchanged and the store will handle this...
@ -3670,7 +3672,7 @@ void DirectX::Internal::ConvertScanline(
// RGB format -> RG format // RGB format -> RG format
switch (static_cast<int>(flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))) switch (static_cast<int>(flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE)))
{ {
case static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE): case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
{ {
XMVECTOR* ptr = pBuffer; XMVECTOR* ptr = pBuffer;
for (size_t i = 0; i < count; ++i) for (size_t i = 0; i < count; ++i)
@ -3682,7 +3684,7 @@ void DirectX::Internal::ConvertScanline(
} }
break; break;
case static_cast<int>(TEX_FILTER_RGB_COPY_GREEN) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE): case (static_cast<int>(TEX_FILTER_RGB_COPY_GREEN) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
{ {
XMVECTOR* ptr = pBuffer; XMVECTOR* ptr = pBuffer;
for (size_t i = 0; i < count; ++i) for (size_t i = 0; i < count; ++i)
@ -3694,7 +3696,7 @@ void DirectX::Internal::ConvertScanline(
} }
break; break;
case static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_GREEN): case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_GREEN)):
default: default:
// Leave data unchanged and the store will handle this... // Leave data unchanged and the store will handle this...
break; break;
@ -4392,14 +4394,14 @@ namespace
_Out_ WICPixelFormatGUID& pfGUID, _Out_ WICPixelFormatGUID& pfGUID,
_Out_ WICPixelFormatGUID& targetGUID) noexcept _Out_ WICPixelFormatGUID& targetGUID) noexcept
{ {
#ifndef WIN32 #ifndef WIN32
UNREFERENCED_PARAMETER(filter); UNREFERENCED_PARAMETER(filter);
UNREFERENCED_PARAMETER(sformat); UNREFERENCED_PARAMETER(sformat);
UNREFERENCED_PARAMETER(tformat); UNREFERENCED_PARAMETER(tformat);
UNREFERENCED_PARAMETER(pfGUID); UNREFERENCED_PARAMETER(pfGUID);
UNREFERENCED_PARAMETER(targetGUID); UNREFERENCED_PARAMETER(targetGUID);
return false; return false;
#else #else
memset(&pfGUID, 0, sizeof(GUID)); memset(&pfGUID, 0, sizeof(GUID));
memset(&targetGUID, 0, sizeof(GUID)); memset(&targetGUID, 0, sizeof(GUID));
@ -4434,7 +4436,7 @@ namespace
} }
// Check for special cases // Check for special cases
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX) #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
if (sformat == DXGI_FORMAT_R16G16B16A16_FLOAT if (sformat == DXGI_FORMAT_R16G16B16A16_FLOAT
|| sformat == DXGI_FORMAT_R16_FLOAT || sformat == DXGI_FORMAT_R16_FLOAT
|| tformat == DXGI_FORMAT_R16G16B16A16_FLOAT || tformat == DXGI_FORMAT_R16G16B16A16_FLOAT
@ -4443,7 +4445,7 @@ namespace
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
return false; return false;
} }
#endif #endif
switch (sformat) switch (sformat)
{ {
@ -4541,7 +4543,7 @@ namespace
} }
return true; return true;
#endif // WIN32 #endif // WIN32
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@ -4555,7 +4557,7 @@ namespace
_In_ float threshold, _In_ float threshold,
_In_ const Image& destImage) _In_ const Image& destImage)
{ {
#ifndef WIN32 #ifndef WIN32
UNREFERENCED_PARAMETER(srcImage); UNREFERENCED_PARAMETER(srcImage);
UNREFERENCED_PARAMETER(pfGUID); UNREFERENCED_PARAMETER(pfGUID);
UNREFERENCED_PARAMETER(targetGUID); UNREFERENCED_PARAMETER(targetGUID);
@ -4563,7 +4565,7 @@ namespace
UNREFERENCED_PARAMETER(threshold); UNREFERENCED_PARAMETER(threshold);
UNREFERENCED_PARAMETER(destImage); UNREFERENCED_PARAMETER(destImage);
return E_NOTIMPL; return E_NOTIMPL;
#else #else
assert(srcImage.width == destImage.width); assert(srcImage.width == destImage.width);
assert(srcImage.height == destImage.height); assert(srcImage.height == destImage.height);
@ -4609,7 +4611,7 @@ namespace
return hr; return hr;
return S_OK; return S_OK;
#endif // WIN32 #endif // WIN32
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@ -4773,6 +4775,10 @@ namespace
}\ }\
} }
#ifdef __clang__
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
#endif
HRESULT ConvertToSinglePlane_(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept HRESULT ConvertToSinglePlane_(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept
{ {
assert(srcImage.width == destImage.width); assert(srcImage.width == destImage.width);
@ -4787,17 +4793,17 @@ namespace
{ {
case DXGI_FORMAT_NV12: case DXGI_FORMAT_NV12:
assert(destImage.format == DXGI_FORMAT_YUY2); assert(destImage.format == DXGI_FORMAT_YUY2);
CONVERT_420_TO_422(uint8_t, XMUBYTEN4) CONVERT_420_TO_422(uint8_t, XMUBYTEN4);
return S_OK; return S_OK;
case DXGI_FORMAT_P010: case DXGI_FORMAT_P010:
assert(destImage.format == DXGI_FORMAT_Y210); assert(destImage.format == DXGI_FORMAT_Y210);
CONVERT_420_TO_422(uint16_t, XMUSHORTN4) CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
return S_OK; return S_OK;
case DXGI_FORMAT_P016: case DXGI_FORMAT_P016:
assert(destImage.format == DXGI_FORMAT_Y216); assert(destImage.format == DXGI_FORMAT_Y216);
CONVERT_420_TO_422(uint16_t, XMUSHORTN4) CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
return S_OK; return S_OK;
case DXGI_FORMAT_NV11: case DXGI_FORMAT_NV11:

4
DirectXTex/DirectXTexD3D11.cpp
View File

@ -39,7 +39,7 @@ namespace
if (!pContext || !pSource || !result.GetPixels()) if (!pContext || !pSource || !result.GetPixels())
return E_POINTER; return E_POINTER;
#if defined(_XBOX_ONE) && defined(_TITLE) #if defined(_XBOX_ONE) && defined(_TITLE)
ComPtr<ID3D11Device> d3dDevice; ComPtr<ID3D11Device> d3dDevice;
pContext->GetDevice(d3dDevice.GetAddressOf()); pContext->GetDevice(d3dDevice.GetAddressOf());
@ -64,7 +64,7 @@ namespace
} }
} }
#endif #endif
if (metadata.IsVolumemap()) if (metadata.IsVolumemap())
{ {

6
DirectXTex/DirectXTexD3D12.cpp
View File

@ -304,11 +304,11 @@ namespace
// Block until the copy is complete // Block until the copy is complete
while (fence->GetCompletedValue() < 1) while (fence->GetCompletedValue() < 1)
{ {
#ifdef WIN32 #ifdef WIN32
SwitchToThread(); SwitchToThread();
#else #else
std::this_thread::yield(); std::this_thread::yield();
#endif #endif
} }
return S_OK; return S_OK;

48
DirectXTex/DirectXTexDDS.cpp
View File

@ -1824,18 +1824,18 @@ HRESULT DirectX::LoadFromDDSFile(
if (!(convFlags & CONV_FLAGS_DX10)) if (!(convFlags & CONV_FLAGS_DX10))
{ {
#ifdef WIN32 #ifdef WIN32
// Must reset file position since we read more than the standard header above // Must reset file position since we read more than the standard header above
const LARGE_INTEGER filePos = { { sizeof(uint32_t) + sizeof(DDS_HEADER), 0 } }; const LARGE_INTEGER filePos = { { sizeof(uint32_t) + sizeof(DDS_HEADER), 0 } };
if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN)) if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
} }
#else #else
inFile.seekg(sizeof(uint32_t) + sizeof(DDS_HEADER), std::ios::beg); inFile.seekg(sizeof(uint32_t) + sizeof(DDS_HEADER), std::ios::beg);
if (!inFile) if (!inFile)
return E_FAIL; return E_FAIL;
#endif #endif
offset = sizeof(uint32_t) + sizeof(DDS_HEADER); offset = sizeof(uint32_t) + sizeof(DDS_HEADER);
} }
@ -1849,7 +1849,7 @@ HRESULT DirectX::LoadFromDDSFile(
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
#ifdef WIN32 #ifdef WIN32
if (!ReadFile(hFile.get(), pal8.get(), 256 * sizeof(uint32_t), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), pal8.get(), 256 * sizeof(uint32_t), &bytesRead, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -1859,11 +1859,11 @@ HRESULT DirectX::LoadFromDDSFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
inFile.read(reinterpret_cast<char*>(pal8.get()), 256 * sizeof(uint32_t)); inFile.read(reinterpret_cast<char*>(pal8.get()), 256 * sizeof(uint32_t));
if (!inFile) if (!inFile)
return E_FAIL; return E_FAIL;
#endif #endif
offset += (256 * sizeof(uint32_t)); offset += (256 * sizeof(uint32_t));
} }
@ -1885,7 +1885,7 @@ HRESULT DirectX::LoadFromDDSFile(
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
#ifdef WIN32 #ifdef WIN32
if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr))
{ {
image.Release(); image.Release();
@ -1897,14 +1897,14 @@ HRESULT DirectX::LoadFromDDSFile(
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#else #else
inFile.read(reinterpret_cast<char*>(temp.get()), remaining); inFile.read(reinterpret_cast<char*>(temp.get()), remaining);
if (!inFile) if (!inFile)
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#endif #endif
CP_FLAGS cflags = CP_FLAGS_NONE; CP_FLAGS cflags = CP_FLAGS_NONE;
if (flags & DDS_FLAGS_LEGACY_DWORD) if (flags & DDS_FLAGS_LEGACY_DWORD)
@ -1943,20 +1943,20 @@ HRESULT DirectX::LoadFromDDSFile(
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
} }
#ifdef WIN32 #ifdef WIN32
if (!ReadFile(hFile.get(), image.GetPixels(), static_cast<DWORD>(image.GetPixelsSize()), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), image.GetPixels(), static_cast<DWORD>(image.GetPixelsSize()), &bytesRead, nullptr))
{ {
image.Release(); image.Release();
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
} }
#else #else
inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize()); inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize());
if (!inFile) if (!inFile)
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#endif #endif
if (convFlags & (CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA)) if (convFlags & (CONV_FLAGS_SWIZZLE | CONV_FLAGS_NOALPHA))
{ {
@ -2285,7 +2285,7 @@ HRESULT DirectX::SaveToDDSFile(
if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX)) if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX))
{ {
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2295,11 +2295,11 @@ HRESULT DirectX::SaveToDDSFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch)); outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
else else
{ {
@ -2318,7 +2318,7 @@ HRESULT DirectX::SaveToDDSFile(
const size_t lines = ComputeScanlines(metadata.format, images[index].height); const size_t lines = ComputeScanlines(metadata.format, images[index].height);
for (size_t j = 0; j < lines; ++j) for (size_t j = 0; j < lines; ++j)
{ {
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2328,11 +2328,11 @@ HRESULT DirectX::SaveToDDSFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch)); outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
sPtr += rowPitch; sPtr += rowPitch;
} }
@ -2370,7 +2370,7 @@ HRESULT DirectX::SaveToDDSFile(
if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX)) if ((images[index].slicePitch == ddsSlicePitch) && (ddsSlicePitch <= UINT32_MAX))
{ {
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), images[index].pixels, static_cast<DWORD>(ddsSlicePitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2380,11 +2380,11 @@ HRESULT DirectX::SaveToDDSFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch)); outFile.write(reinterpret_cast<char*>(images[index].pixels), static_cast<std::streamsize>(ddsSlicePitch));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
else else
{ {
@ -2403,7 +2403,7 @@ HRESULT DirectX::SaveToDDSFile(
const size_t lines = ComputeScanlines(metadata.format, images[index].height); const size_t lines = ComputeScanlines(metadata.format, images[index].height);
for (size_t j = 0; j < lines; ++j) for (size_t j = 0; j < lines; ++j)
{ {
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), sPtr, static_cast<DWORD>(ddsRowPitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2413,11 +2413,11 @@ HRESULT DirectX::SaveToDDSFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch)); outFile.write(reinterpret_cast<const char*>(sPtr), static_cast<std::streamsize>(ddsRowPitch));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
sPtr += rowPitch; sPtr += rowPitch;
} }
} }

40
DirectXTex/DirectXTexHDR.cpp
View File

@ -79,7 +79,7 @@ namespace
#ifndef WIN32 #ifndef WIN32
template<size_t sizeOfBuffer> template<size_t sizeOfBuffer>
inline int sprintf_s(char (&buffer)[sizeOfBuffer], const char* format, ...) inline int sprintf_s(char(&buffer)[sizeOfBuffer], const char* format, ...)
{ {
// This is adapter code. It is not a full implementation of sprintf_s! // This is adapter code. It is not a full implementation of sprintf_s!
va_list ap; va_list ap;
@ -400,7 +400,7 @@ namespace
return 0; return 0;
} }
#ifdef WRITE_OLD_COLORS #ifdef WRITE_OLD_COLORS
size_t encSize = 0; size_t encSize = 0;
const uint8_t* scanPtr = rgbe; const uint8_t* scanPtr = rgbe;
@ -502,7 +502,7 @@ namespace
} }
return encSize; return encSize;
#else #else
enc[0] = 2; enc[0] = 2;
enc[1] = 2; enc[1] = 2;
enc[2] = uint8_t(width >> 8); enc[2] = uint8_t(width >> 8);
@ -569,7 +569,7 @@ namespace
} }
return encSize; return encSize;
#endif #endif
} }
} }
@ -748,7 +748,7 @@ HRESULT DirectX::LoadFromHDRMemory(const void* pSource, size_t size, TexMetadata
for (int channel = 0; channel < 4; ++channel) for (int channel = 0; channel < 4; ++channel)
{ {
auto pixelLoc = scanLine + channel; auto pixelLoc = scanLine + channel;
for(size_t pixelCount = 0; pixelCount < mdata.width;) for (size_t pixelCount = 0; pixelCount < mdata.width;)
{ {
if (pixelLen < 2) if (pixelLen < 2)
{ {
@ -1163,7 +1163,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
return hr; return hr;
// Write blob // Write blob
#ifdef WIN32 #ifdef WIN32
auto const bytesToWrite = static_cast<const DWORD>(blob.GetBufferSize()); auto const bytesToWrite = static_cast<const DWORD>(blob.GetBufferSize());
DWORD bytesWritten; DWORD bytesWritten;
if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr))
@ -1175,13 +1175,13 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()), outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()),
static_cast<std::streamsize>(blob.GetBufferSize())); static_cast<std::streamsize>(blob.GetBufferSize()));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
else else
{ {
@ -1196,7 +1196,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
char header[256] = {}; char header[256] = {};
sprintf_s(header, g_Header, image.height, image.width); sprintf_s(header, g_Header, image.height, image.width);
#ifdef WIN32 #ifdef WIN32
auto const headerLen = static_cast<DWORD>(strlen(header)); auto const headerLen = static_cast<DWORD>(strlen(header));
DWORD bytesWritten; DWORD bytesWritten;
@ -1207,13 +1207,13 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
if (bytesWritten != headerLen) if (bytesWritten != headerLen)
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(header), static_cast<std::streamsize>(strlen(header))); outFile.write(reinterpret_cast<char*>(header), static_cast<std::streamsize>(strlen(header)));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
#ifdef DISABLE_COMPRESS #ifdef DISABLE_COMPRESS
// Uncompressed write // Uncompressed write
auto sPtr = reinterpret_cast<const uint8_t*>(image.pixels); auto sPtr = reinterpret_cast<const uint8_t*>(image.pixels);
for (size_t scan = 0; scan < image.height; ++scan) for (size_t scan = 0; scan < image.height; ++scan)
@ -1236,7 +1236,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
#endif #endif
} }
#else #else
auto enc = temp.get() + rowPitch; auto enc = temp.get() + rowPitch;
const uint8_t* sPtr = image.pixels; const uint8_t* sPtr = image.pixels;
@ -1258,7 +1258,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
if (encSize > UINT32_MAX) if (encSize > UINT32_MAX)
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), enc, static_cast<DWORD>(encSize), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), enc, static_cast<DWORD>(encSize), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -1266,15 +1266,15 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
if (bytesWritten != encSize) if (bytesWritten != encSize)
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(enc), static_cast<std::streamsize>(encSize)); outFile.write(reinterpret_cast<char*>(enc), static_cast<std::streamsize>(encSize));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
else else
{ {
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -1282,14 +1282,14 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
if (bytesWritten != rowPitch) if (bytesWritten != rowPitch)
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch)); outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
} }
#endif #endif
} }
#ifdef WIN32 #ifdef WIN32

4
DirectXTex/DirectXTexImage.cpp
View File

@ -23,7 +23,7 @@ namespace
return std::aligned_alloc(alignment, size); return std::aligned_alloc(alignment, size);
} }
#define _aligned_free free #define _aligned_free free
} }
#endif #endif
@ -801,7 +801,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
for (size_t index = 0; index < m_nimages; ++index) for (size_t index = 0; index < m_nimages; ++index)
{ {
#pragma warning( suppress : 6011 ) #pragma warning( suppress : 6011 )
const Image& img = m_image[index]; const Image& img = m_image[index];
const uint8_t *pPixels = img.pixels; const uint8_t *pPixels = img.pixels;

84
DirectXTex/DirectXTexMipmaps.cpp
View File

@ -454,16 +454,16 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
} }
else else
{ {
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
if (iswic2) if (iswic2)
{ {
colorBytesInPixel = colorBytesPerPixel = 12; colorBytesInPixel = colorBytesPerPixel = 12;
colorPixelFormat = GUID_WICPixelFormat96bppRGBFloat; colorPixelFormat = GUID_WICPixelFormat96bppRGBFloat;
} }
else else
#else #else
UNREFERENCED_PARAMETER(iswic2); UNREFERENCED_PARAMETER(iswic2);
#endif #endif
{ {
colorBytesInPixel = 12; colorBytesInPixel = 12;
colorBytesPerPixel = 16; colorBytesPerPixel = 16;
@ -593,7 +593,7 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
} }
else else
{ {
#pragma warning( suppress : 26014 6386 ) // No overflow possible here #pragma warning( suppress : 26014 6386 ) // No overflow possible here
memcpy_s(colorWithAlphaData + colorWithAlphaIndex, colorWithAlphaBytesPerPixel, colorData + colorIndex, colorBytesInPixel); memcpy_s(colorWithAlphaData + colorWithAlphaIndex, colorWithAlphaBytesPerPixel, colorData + colorIndex, colorBytesInPixel);
} }
} }
@ -642,14 +642,14 @@ namespace
return false; return false;
} }
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX) #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
if (format == DXGI_FORMAT_R16G16B16A16_FLOAT if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
|| format == DXGI_FORMAT_R16_FLOAT) || format == DXGI_FORMAT_R16_FLOAT)
{ {
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
return false; return false;
} }
#endif #endif
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK"); static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
@ -921,9 +921,9 @@ namespace
// Resize base image to each target mip level // Resize base image to each target mip level
for (size_t level = 1; level < levels; ++level) for (size_t level = 1; level < levels; ++level)
{ {
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*width); memset(row, 0xCD, sizeof(XMVECTOR)*width);
#endif #endif
// 2D point filter // 2D point filter
const Image* src = mipChain.GetImage(level - 1, item, 0); const Image* src = mipChain.GetImage(level - 1, item, 0);
@ -1129,10 +1129,10 @@ namespace
const size_t nheight = (height > 1) ? (height >> 1) : 1; const size_t nheight = (height > 1) ? (height >> 1) : 1;
CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY); CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*width); memset(row0, 0xCD, sizeof(XMVECTOR)*width);
memset(row1, 0xDD, sizeof(XMVECTOR)*width); memset(row1, 0xDD, sizeof(XMVECTOR)*width);
#endif #endif
size_t u0 = size_t(-1); size_t u0 = size_t(-1);
size_t u1 = size_t(-1); size_t u1 = size_t(-1);
@ -1190,6 +1190,10 @@ namespace
} }
//--- 2D Cubic Filter --- //--- 2D Cubic Filter ---
#ifdef __clang__
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
#endif
HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
{ {
using namespace DirectX::Filters; using namespace DirectX::Filters;
@ -1244,12 +1248,12 @@ namespace
const size_t nheight = (height > 1) ? (height >> 1) : 1; const size_t nheight = (height > 1) ? (height >> 1) : 1;
CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY); CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*width); memset(row0, 0xCD, sizeof(XMVECTOR)*width);
memset(row1, 0xDD, sizeof(XMVECTOR)*width); memset(row1, 0xDD, sizeof(XMVECTOR)*width);
memset(row2, 0xED, sizeof(XMVECTOR)*width); memset(row2, 0xED, sizeof(XMVECTOR)*width);
memset(row3, 0xFD, sizeof(XMVECTOR)*width); memset(row3, 0xFD, sizeof(XMVECTOR)*width);
#endif #endif
size_t u0 = size_t(-1); size_t u0 = size_t(-1);
size_t u1 = size_t(-1); size_t u1 = size_t(-1);
@ -1353,12 +1357,12 @@ namespace
XMVECTOR C0, C1, C2, C3; XMVECTOR C0, C1, C2, C3;
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]) CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]) CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]) CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]) CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3) CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
} }
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
@ -1433,9 +1437,9 @@ namespace
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*width); memset(row, 0xCD, sizeof(XMVECTOR)*width);
#endif #endif
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes); auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes); auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
@ -1673,9 +1677,9 @@ namespace
// Resize base image to each target mip level // Resize base image to each target mip level
for (size_t level = 1; level < levels; ++level) for (size_t level = 1; level < levels; ++level)
{ {
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*width); memset(row, 0xCD, sizeof(XMVECTOR)*width);
#endif #endif
if (depth > 1) if (depth > 1)
{ {
@ -2012,12 +2016,12 @@ namespace
const size_t nheight = (height > 1) ? (height >> 1) : 1; const size_t nheight = (height > 1) ? (height >> 1) : 1;
CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY); CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(urow0, 0xCD, sizeof(XMVECTOR)*width); memset(urow0, 0xCD, sizeof(XMVECTOR)*width);
memset(urow1, 0xDD, sizeof(XMVECTOR)*width); memset(urow1, 0xDD, sizeof(XMVECTOR)*width);
memset(vrow0, 0xED, sizeof(XMVECTOR)*width); memset(vrow0, 0xED, sizeof(XMVECTOR)*width);
memset(vrow1, 0xFD, sizeof(XMVECTOR)*width); memset(vrow1, 0xFD, sizeof(XMVECTOR)*width);
#endif #endif
if (depth > 1) if (depth > 1)
{ {
@ -2216,7 +2220,7 @@ namespace
const size_t nheight = (height > 1) ? (height >> 1) : 1; const size_t nheight = (height > 1) ? (height >> 1) : 1;
CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY); CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
#ifdef _DEBUG #ifdef _DEBUG
for (size_t j = 0; j < 4; ++j) for (size_t j = 0; j < 4; ++j)
{ {
memset(urow[j], 0xCD, sizeof(XMVECTOR)*width); memset(urow[j], 0xCD, sizeof(XMVECTOR)*width);
@ -2224,7 +2228,7 @@ namespace
memset(srow[j], 0xED, sizeof(XMVECTOR)*width); memset(srow[j], 0xED, sizeof(XMVECTOR)*width);
memset(trow[j], 0xFD, sizeof(XMVECTOR)*width); memset(trow[j], 0xFD, sizeof(XMVECTOR)*width);
} }
#endif #endif
if (depth > 1) if (depth > 1)
{ {
@ -2384,15 +2388,15 @@ namespace
for (size_t j = 0; j < 4; ++j) for (size_t j = 0; j < 4; ++j)
{ {
XMVECTOR C0, C1, C2, C3; XMVECTOR C0, C1, C2, C3;
CUBIC_INTERPOLATE(C0, toX.x, urow[j][toX.u0], urow[j][toX.u1], urow[j][toX.u2], urow[j][toX.u3]) CUBIC_INTERPOLATE(C0, toX.x, urow[j][toX.u0], urow[j][toX.u1], urow[j][toX.u2], urow[j][toX.u3]);
CUBIC_INTERPOLATE(C1, toX.x, vrow[j][toX.u0], vrow[j][toX.u1], vrow[j][toX.u2], vrow[j][toX.u3]) CUBIC_INTERPOLATE(C1, toX.x, vrow[j][toX.u0], vrow[j][toX.u1], vrow[j][toX.u2], vrow[j][toX.u3]);
CUBIC_INTERPOLATE(C2, toX.x, srow[j][toX.u0], srow[j][toX.u1], srow[j][toX.u2], srow[j][toX.u3]) CUBIC_INTERPOLATE(C2, toX.x, srow[j][toX.u0], srow[j][toX.u1], srow[j][toX.u2], srow[j][toX.u3]);
CUBIC_INTERPOLATE(C3, toX.x, trow[j][toX.u0], trow[j][toX.u1], trow[j][toX.u2], trow[j][toX.u3]) CUBIC_INTERPOLATE(C3, toX.x, trow[j][toX.u0], trow[j][toX.u1], trow[j][toX.u2], trow[j][toX.u3]);
CUBIC_INTERPOLATE(D[j], toY.x, C0, C1, C2, C3) CUBIC_INTERPOLATE(D[j], toY.x, C0, C1, C2, C3);
} }
CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3]) CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3]);
} }
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
@ -2516,12 +2520,12 @@ namespace
auto const& toX = cfX[x]; auto const& toX = cfX[x];
XMVECTOR C0, C1, C2, C3; XMVECTOR C0, C1, C2, C3;
CUBIC_INTERPOLATE(C0, toX.x, urow[0][toX.u0], urow[0][toX.u1], urow[0][toX.u2], urow[0][toX.u3]) CUBIC_INTERPOLATE(C0, toX.x, urow[0][toX.u0], urow[0][toX.u1], urow[0][toX.u2], urow[0][toX.u3]);
CUBIC_INTERPOLATE(C1, toX.x, vrow[0][toX.u0], vrow[0][toX.u1], vrow[0][toX.u2], vrow[0][toX.u3]) CUBIC_INTERPOLATE(C1, toX.x, vrow[0][toX.u0], vrow[0][toX.u1], vrow[0][toX.u2], vrow[0][toX.u3]);
CUBIC_INTERPOLATE(C2, toX.x, srow[0][toX.u0], srow[0][toX.u1], srow[0][toX.u2], srow[0][toX.u3]) CUBIC_INTERPOLATE(C2, toX.x, srow[0][toX.u0], srow[0][toX.u1], srow[0][toX.u2], srow[0][toX.u3]);
CUBIC_INTERPOLATE(C3, toX.x, trow[0][toX.u0], trow[0][toX.u1], trow[0][toX.u2], trow[0][toX.u3]) CUBIC_INTERPOLATE(C3, toX.x, trow[0][toX.u0], trow[0][toX.u1], trow[0][toX.u2], trow[0][toX.u3]);
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3) CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
} }
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
@ -2592,9 +2596,9 @@ namespace
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*width); memset(row, 0xCD, sizeof(XMVECTOR)*width);
#endif #endif
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes); auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes); auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
@ -2903,7 +2907,7 @@ HRESULT DirectX::GenerateMipMaps(
} }
} }
else else
#endif // WIN32 #endif // WIN32
{ {
//--- Use custom filters to generate mipmaps ---------------------------------- //--- Use custom filters to generate mipmaps ----------------------------------
TexMetadata mdata = {}; TexMetadata mdata = {};
@ -3131,7 +3135,7 @@ HRESULT DirectX::GenerateMipMaps(
} }
} }
else else
#endif // WIN32 #endif // WIN32
{ {
//--- Use custom filters to generate mipmaps ---------------------------------- //--- Use custom filters to generate mipmaps ----------------------------------
TexMetadata mdata2 = metadata; TexMetadata mdata2 = metadata;

4
DirectXTex/DirectXTexMisc.cpp
View File

@ -246,9 +246,9 @@ namespace
if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format)) if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
return E_FAIL; return E_FAIL;
#ifdef _DEBUG #ifdef _DEBUG
memset(dScanline, 0xCD, sizeof(XMVECTOR)*width); memset(dScanline, 0xCD, sizeof(XMVECTOR)*width);
#endif #endif
pixelFunc(dScanline, sScanline, width, h); pixelFunc(dScanline, sScanline, width, h);

16
DirectXTex/DirectXTexP.h
View File

@ -210,7 +210,7 @@ namespace DirectX
{ {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// WIC helper functions // WIC helper functions
#ifdef WIN32 #ifdef WIN32
DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept; DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept;
bool __cdecl DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept; bool __cdecl DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept;
@ -295,7 +295,7 @@ namespace DirectX
return WICBitmapInterpolationModeFant; return WICBitmapInterpolationModeFant;
} }
} }
#endif // WIN32 #endif // WIN32
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Image helper functions // Image helper functions
@ -314,8 +314,12 @@ namespace DirectX
enum TEXP_SCANLINE_FLAGS : uint32_t enum TEXP_SCANLINE_FLAGS : uint32_t
{ {
TEXP_SCANLINE_NONE = 0, TEXP_SCANLINE_NONE = 0,
TEXP_SCANLINE_SETALPHA = 0x1, // Set alpha channel to known opaque value
TEXP_SCANLINE_LEGACY = 0x2, // Enables specific legacy format conversion cases TEXP_SCANLINE_SETALPHA = 0x1,
// Set alpha channel to known opaque value
TEXP_SCANLINE_LEGACY = 0x2,
// Enables specific legacy format conversion cases
}; };
enum CONVERT_FLAGS : uint32_t enum CONVERT_FLAGS : uint32_t
@ -413,13 +417,13 @@ namespace DirectX
bool __cdecl CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, bool __cdecl CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth,
_Inout_ size_t& mipLevels) noexcept; _Inout_ size_t& mipLevels) noexcept;
#ifdef WIN32 #ifdef WIN32
HRESULT __cdecl ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC, HRESULT __cdecl ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC,
_In_ bool iswic2, _In_ bool iswic2,
_In_ IWICBitmap* original, _In_ IWICBitmap* original,
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter, _In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter,
_Inout_ const Image* img) noexcept; _Inout_ const Image* img) noexcept;
#endif #endif
} // namespace Internal } // namespace Internal
} // namespace DirectX } // namespace DirectX

48
DirectXTex/DirectXTexResize.cpp
View File

@ -189,14 +189,14 @@ namespace
return false; return false;
} }
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX) #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
if (format == DXGI_FORMAT_R16G16B16A16_FLOAT if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
|| format == DXGI_FORMAT_R16_FLOAT) || format == DXGI_FORMAT_R16_FLOAT)
{ {
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC // Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
return false; return false;
} }
#endif #endif
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK"); static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
@ -258,9 +258,9 @@ namespace
XMVECTOR* row = target + destImage.width; XMVECTOR* row = target + destImage.width;
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width); memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
#endif #endif
const uint8_t* pSrc = srcImage.pixels; const uint8_t* pSrc = srcImage.pixels;
uint8_t* pDest = destImage.pixels; uint8_t* pDest = destImage.pixels;
@ -321,10 +321,10 @@ namespace
XMVECTOR* urow0 = target + destImage.width; XMVECTOR* urow0 = target + destImage.width;
XMVECTOR* urow1 = urow0 + srcImage.width; XMVECTOR* urow1 = urow0 + srcImage.width;
#ifdef _DEBUG #ifdef _DEBUG
memset(urow0, 0xCD, sizeof(XMVECTOR)*srcImage.width); memset(urow0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
memset(urow1, 0xDD, sizeof(XMVECTOR)*srcImage.width); memset(urow1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
#endif #endif
const XMVECTOR* urow2 = urow0 + 1; const XMVECTOR* urow2 = urow0 + 1;
const XMVECTOR* urow3 = urow1 + 1; const XMVECTOR* urow3 = urow1 + 1;
@ -391,10 +391,10 @@ namespace
XMVECTOR* row0 = target + destImage.width; XMVECTOR* row0 = target + destImage.width;
XMVECTOR* row1 = row0 + srcImage.width; XMVECTOR* row1 = row0 + srcImage.width;
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width); memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width); memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
#endif #endif
const uint8_t* pSrc = srcImage.pixels; const uint8_t* pSrc = srcImage.pixels;
uint8_t* pDest = destImage.pixels; uint8_t* pDest = destImage.pixels;
@ -451,6 +451,10 @@ namespace
//--- Cubic Filter --- //--- Cubic Filter ---
#ifdef __clang__
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
#endif
HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
{ {
using namespace DirectX::Filters; using namespace DirectX::Filters;
@ -480,12 +484,12 @@ namespace
XMVECTOR* row2 = row0 + srcImage.width * 2; XMVECTOR* row2 = row0 + srcImage.width * 2;
XMVECTOR* row3 = row0 + srcImage.width * 3; XMVECTOR* row3 = row0 + srcImage.width * 3;
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width); memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width); memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
memset(row2, 0xED, sizeof(XMVECTOR)*srcImage.width); memset(row2, 0xED, sizeof(XMVECTOR)*srcImage.width);
memset(row3, 0xFD, sizeof(XMVECTOR)*srcImage.width); memset(row3, 0xFD, sizeof(XMVECTOR)*srcImage.width);
#endif #endif
const uint8_t* pSrc = srcImage.pixels; const uint8_t* pSrc = srcImage.pixels;
uint8_t* pDest = destImage.pixels; uint8_t* pDest = destImage.pixels;
@ -594,12 +598,12 @@ namespace
XMVECTOR C0, C1, C2, C3; XMVECTOR C0, C1, C2, C3;
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]) CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]) CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]) CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]) CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3) CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
} }
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
@ -642,9 +646,9 @@ namespace
XMVECTOR* row = scanline.get(); XMVECTOR* row = scanline.get();
#ifdef _DEBUG #ifdef _DEBUG
memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width); memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
#endif #endif
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes); auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes); auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
@ -908,7 +912,7 @@ HRESULT DirectX::Resize(
} }
} }
else else
#endif #endif
{ {
// Case 3: not using WIC resizing // Case 3: not using WIC resizing
hr = PerformResizeUsingCustomFilters(srcImage, filter, *rimage); hr = PerformResizeUsingCustomFilters(srcImage, filter, *rimage);
@ -1007,7 +1011,7 @@ HRESULT DirectX::Resize(
return E_FAIL; return E_FAIL;
} }
#ifdef WIN32 #ifdef WIN32
if (usewic) if (usewic)
{ {
if (wicpf) if (wicpf)
@ -1022,7 +1026,7 @@ HRESULT DirectX::Resize(
} }
} }
else else
#endif #endif
{ {
// Case 3: not using WIC resizing // Case 3: not using WIC resizing
hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg); hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);
@ -1068,7 +1072,7 @@ HRESULT DirectX::Resize(
return E_FAIL; return E_FAIL;
} }
#ifdef WIN32 #ifdef WIN32
if (usewic) if (usewic)
{ {
if (wicpf) if (wicpf)
@ -1083,7 +1087,7 @@ HRESULT DirectX::Resize(
} }
} }
else else
#endif #endif
{ {
// Case 3: not using WIC resizing // Case 3: not using WIC resizing
hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg); hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);

78
DirectXTex/DirectXTexTGA.cpp
View File

@ -1224,14 +1224,14 @@ namespace
time_t now = {}; time_t now = {};
time(&now); time(&now);
#ifdef WIN32 #ifdef WIN32
tm info; tm info;
auto pinfo = &info; auto pinfo = &info;
if (!gmtime_s(pinfo, &now)) if (!gmtime_s(pinfo, &now))
#else #else
const tm* pinfo = gmtime(&now); const tm* pinfo = gmtime(&now);
if (pinfo) if (pinfo)
#endif #endif
{ {
ext->wStampMonth = static_cast<uint16_t>(pinfo->tm_mon + 1); ext->wStampMonth = static_cast<uint16_t>(pinfo->tm_mon + 1);
ext->wStampDay = static_cast<uint16_t>(pinfo->tm_mday); ext->wStampDay = static_cast<uint16_t>(pinfo->tm_mday);
@ -1424,7 +1424,7 @@ HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags,
{ {
TGA_FOOTER footer = {}; TGA_FOOTER footer = {};
#ifdef WIN32 #ifdef WIN32
if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER) if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER)
{ {
if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr))
@ -1437,7 +1437,7 @@ HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags,
return E_FAIL; return E_FAIL;
} }
} }
#else #else
inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end); inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end);
if (inFile) if (inFile)
{ {
@ -1445,14 +1445,14 @@ HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags,
if (!inFile) if (!inFile)
return E_FAIL; return E_FAIL;
} }
#endif #endif
if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0) if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0)
{ {
if (footer.dwExtensionOffset != 0 if (footer.dwExtensionOffset != 0
&& ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len)) && ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len))
{ {
#ifdef WIN32 #ifdef WIN32
const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } }; const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } };
if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN)) if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
{ {
@ -1463,7 +1463,7 @@ HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags,
metadata.SetAlphaMode(GetAlphaModeFromExtension(ext)); metadata.SetAlphaMode(GetAlphaModeFromExtension(ext));
} }
} }
#else // !WIN32 #else // !WIN32
inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg); inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg);
if (inFile) if (inFile)
{ {
@ -1474,7 +1474,7 @@ HRESULT DirectX::GetMetadataFromTGAFile(const wchar_t* szFile, TGA_FLAGS flags,
metadata.SetAlphaMode(GetAlphaModeFromExtension(ext)); metadata.SetAlphaMode(GetAlphaModeFromExtension(ext));
} }
} }
#endif #endif
} }
} }
} }
@ -1676,18 +1676,18 @@ HRESULT DirectX::LoadFromTGAFile(
if (offset > sizeof(TGA_HEADER)) if (offset > sizeof(TGA_HEADER))
{ {
#ifdef WIN32 #ifdef WIN32
// Skip past the id string // Skip past the id string
const LARGE_INTEGER filePos = { { static_cast<DWORD>(offset), 0 } }; const LARGE_INTEGER filePos = { { static_cast<DWORD>(offset), 0 } };
if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN)) if (!SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
} }
#else #else
inFile.seekg(offset, std::ios::beg); inFile.seekg(offset, std::ios::beg);
if (!inFile) if (!inFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
hr = image.Initialize2D(mdata.format, mdata.width, mdata.height, 1, 1); hr = image.Initialize2D(mdata.format, mdata.width, mdata.height, 1, 1);
@ -1713,7 +1713,7 @@ HRESULT DirectX::LoadFromTGAFile(
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
} }
#ifdef WIN32 #ifdef WIN32
if (!ReadFile(hFile.get(), image.GetPixels(), static_cast<DWORD>(image.GetPixelsSize()), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), image.GetPixels(), static_cast<DWORD>(image.GetPixelsSize()), &bytesRead, nullptr))
{ {
image.Release(); image.Release();
@ -1725,14 +1725,14 @@ HRESULT DirectX::LoadFromTGAFile(
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#else #else
inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize()); inFile.read(reinterpret_cast<char*>(image.GetPixels()), image.GetPixelsSize());
if (!inFile) if (!inFile)
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#endif #endif
switch (mdata.format) switch (mdata.format)
{ {
@ -1932,7 +1932,7 @@ HRESULT DirectX::LoadFromTGAFile(
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
#ifdef WIN32 #ifdef WIN32
if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), temp.get(), static_cast<DWORD>(remaining), &bytesRead, nullptr))
{ {
image.Release(); image.Release();
@ -1944,14 +1944,14 @@ HRESULT DirectX::LoadFromTGAFile(
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#else #else
inFile.read(reinterpret_cast<char*>(temp.get()), remaining); inFile.read(reinterpret_cast<char*>(temp.get()), remaining);
if (!inFile) if (!inFile)
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
#endif #endif
if (convFlags & CONV_FLAGS_RLE) if (convFlags & CONV_FLAGS_RLE)
{ {
@ -1978,7 +1978,7 @@ HRESULT DirectX::LoadFromTGAFile(
{ {
TGA_FOOTER footer = {}; TGA_FOOTER footer = {};
#ifdef WIN32 #ifdef WIN32
if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER) if (SetFilePointer(hFile.get(), -static_cast<int>(sizeof(TGA_FOOTER)), nullptr, FILE_END) != INVALID_SET_FILE_POINTER)
{ {
if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr)) if (!ReadFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesRead, nullptr))
@ -1993,7 +1993,7 @@ HRESULT DirectX::LoadFromTGAFile(
return E_FAIL; return E_FAIL;
} }
} }
#else // !WIN32 #else // !WIN32
inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end); inFile.seekg(-static_cast<int>(sizeof(TGA_FOOTER)), std::ios::end);
if (inFile) if (inFile)
{ {
@ -2004,14 +2004,14 @@ HRESULT DirectX::LoadFromTGAFile(
return E_FAIL; return E_FAIL;
} }
} }
#endif #endif
if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0) if (memcmp(footer.Signature, g_Signature, sizeof(g_Signature)) == 0)
{ {
if (footer.dwExtensionOffset != 0 if (footer.dwExtensionOffset != 0
&& ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len)) && ((footer.dwExtensionOffset + sizeof(TGA_EXTENSION)) <= len))
{ {
#ifdef WIN32 #ifdef WIN32
const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } }; const LARGE_INTEGER filePos = { { static_cast<DWORD>(footer.dwExtensionOffset), 0 } };
if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN)) if (SetFilePointerEx(hFile.get(), filePos, nullptr, FILE_BEGIN))
{ {
@ -2021,7 +2021,7 @@ HRESULT DirectX::LoadFromTGAFile(
ext = &extData; ext = &extData;
} }
} }
#else // !WIN32 #else // !WIN32
inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg); inFile.seekg(static_cast<std::streampos>(footer.dwExtensionOffset), std::ios::beg);
if (inFile) if (inFile)
{ {
@ -2031,7 +2031,7 @@ HRESULT DirectX::LoadFromTGAFile(
ext = &extData; ext = &extData;
} }
} }
#endif #endif
} }
} }
} }
@ -2211,7 +2211,7 @@ HRESULT DirectX::SaveToTGAFile(
return hr; return hr;
// Write blob // Write blob
#ifdef WIN32 #ifdef WIN32
const DWORD bytesToWrite = static_cast<DWORD>(blob.GetBufferSize()); const DWORD bytesToWrite = static_cast<DWORD>(blob.GetBufferSize());
DWORD bytesWritten; DWORD bytesWritten;
if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr))
@ -2223,13 +2223,13 @@ HRESULT DirectX::SaveToTGAFile(
{ {
return E_FAIL; return E_FAIL;
} }
#else #else
outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()), outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()),
static_cast<std::streamsize>(blob.GetBufferSize())); static_cast<std::streamsize>(blob.GetBufferSize()));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
else else
{ {
@ -2239,7 +2239,7 @@ HRESULT DirectX::SaveToTGAFile(
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
// Write header // Write header
#ifdef WIN32 #ifdef WIN32
DWORD bytesWritten; DWORD bytesWritten;
if (!WriteFile(hFile.get(), &tga_header, sizeof(TGA_HEADER), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), &tga_header, sizeof(TGA_HEADER), &bytesWritten, nullptr))
{ {
@ -2248,11 +2248,11 @@ HRESULT DirectX::SaveToTGAFile(
if (bytesWritten != sizeof(TGA_HEADER)) if (bytesWritten != sizeof(TGA_HEADER))
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(&tga_header), sizeof(TGA_HEADER)); outFile.write(reinterpret_cast<char*>(&tga_header), sizeof(TGA_HEADER));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
if (rowPitch > UINT32_MAX) if (rowPitch > UINT32_MAX)
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
@ -2278,7 +2278,7 @@ HRESULT DirectX::SaveToTGAFile(
pPixels += image.rowPitch; pPixels += image.rowPitch;
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), temp.get(), static_cast<DWORD>(rowPitch), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), temp.get(), static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2286,11 +2286,11 @@ HRESULT DirectX::SaveToTGAFile(
if (bytesWritten != rowPitch) if (bytesWritten != rowPitch)
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(temp.get()), rowPitch); outFile.write(reinterpret_cast<char*>(temp.get()), rowPitch);
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
uint32_t extOffset = 0; uint32_t extOffset = 0;
@ -2300,7 +2300,7 @@ HRESULT DirectX::SaveToTGAFile(
TGA_EXTENSION ext = {}; TGA_EXTENSION ext = {};
SetExtension(&ext, flags, *metadata); SetExtension(&ext, flags, *metadata);
#ifdef WIN32 #ifdef WIN32
extOffset = SetFilePointer(hFile.get(), 0, nullptr, FILE_CURRENT); extOffset = SetFilePointer(hFile.get(), 0, nullptr, FILE_CURRENT);
if (extOffset == INVALID_SET_FILE_POINTER) if (extOffset == INVALID_SET_FILE_POINTER)
{ {
@ -2314,7 +2314,7 @@ HRESULT DirectX::SaveToTGAFile(
if (bytesWritten != sizeof(TGA_EXTENSION)) if (bytesWritten != sizeof(TGA_EXTENSION))
return E_FAIL; return E_FAIL;
#else #else
extOffset = static_cast<uint32_t>(outFile.tellp()); extOffset = static_cast<uint32_t>(outFile.tellp());
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
@ -2322,7 +2322,7 @@ HRESULT DirectX::SaveToTGAFile(
outFile.write(reinterpret_cast<char*>(&ext), sizeof(TGA_EXTENSION)); outFile.write(reinterpret_cast<char*>(&ext), sizeof(TGA_EXTENSION));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
// Write TGA 2.0 footer // Write TGA 2.0 footer
@ -2330,7 +2330,7 @@ HRESULT DirectX::SaveToTGAFile(
footer.dwExtensionOffset = extOffset; footer.dwExtensionOffset = extOffset;
memcpy(footer.Signature, g_Signature, sizeof(g_Signature)); memcpy(footer.Signature, g_Signature, sizeof(g_Signature));
#ifdef WIN32 #ifdef WIN32
if (!WriteFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesWritten, nullptr)) if (!WriteFile(hFile.get(), &footer, sizeof(TGA_FOOTER), &bytesWritten, nullptr))
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());
@ -2338,11 +2338,11 @@ HRESULT DirectX::SaveToTGAFile(
if (bytesWritten != sizeof(footer)) if (bytesWritten != sizeof(footer))
return E_FAIL; return E_FAIL;
#else #else
outFile.write(reinterpret_cast<char*>(&footer), sizeof(TGA_FOOTER)); outFile.write(reinterpret_cast<char*>(&footer), sizeof(TGA_FOOTER));
if (!outFile) if (!outFile)
return E_FAIL; return E_FAIL;
#endif #endif
} }
#ifdef WIN32 #ifdef WIN32

6
DirectXTex/DirectXTexUtil.cpp
View File

@ -122,7 +122,7 @@ namespace
return std::aligned_alloc(alignment, size); return std::aligned_alloc(alignment, size);
} }
#define _aligned_free free #define _aligned_free free
#endif #endif
} }
@ -317,14 +317,14 @@ void DirectX::SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept
bool iswic2 = false; bool iswic2 = false;
if (pWIC) if (pWIC)
{ {
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
ComPtr<IWICImagingFactory2> wic2; ComPtr<IWICImagingFactory2> wic2;
HRESULT hr = pWIC->QueryInterface(IID_PPV_ARGS(wic2.GetAddressOf())); HRESULT hr = pWIC->QueryInterface(IID_PPV_ARGS(wic2.GetAddressOf()));
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
iswic2 = true; iswic2 = true;
} }
#endif #endif
pWIC->AddRef(); pWIC->AddRef();
} }

18
DirectXTex/DirectXTexWIC.cpp
View File

@ -106,7 +106,7 @@ namespace
{ {
if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0) if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
if (iswic2) if (iswic2)
{ {
if (pConvert) if (pConvert)
@ -114,9 +114,9 @@ namespace
format = DXGI_FORMAT_R32G32B32_FLOAT; format = DXGI_FORMAT_R32G32B32_FLOAT;
} }
else else
#else #else
UNREFERENCED_PARAMETER(iswic2); UNREFERENCED_PARAMETER(iswic2);
#endif #endif
{ {
if (pConvert) if (pConvert)
memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID)); memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID));
@ -600,7 +600,7 @@ namespace
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0; sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
} }
} }
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX) #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0) else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
{ {
if (SUCCEEDED(metareader->GetMetadataByName(L"/app1/ifd/exif/{ushort=40961}", &value)) && value.vt == VT_UI2) if (SUCCEEDED(metareader->GetMetadataByName(L"/app1/ifd/exif/{ushort=40961}", &value)) && value.vt == VT_UI2)
@ -623,7 +623,7 @@ namespace
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0; sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
} }
} }
#else #else
else if (SUCCEEDED(metareader->GetMetadataByName(L"System.Image.ColorSpace", &value)) && value.vt == VT_UI2) else if (SUCCEEDED(metareader->GetMetadataByName(L"System.Image.ColorSpace", &value)) && value.vt == VT_UI2)
{ {
sRGB = (value.uiVal == 1); sRGB = (value.uiVal == 1);
@ -632,7 +632,7 @@ namespace
{ {
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0; sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
} }
#endif #endif
std::ignore = PropVariantClear(&value); std::ignore = PropVariantClear(&value);
@ -913,7 +913,7 @@ namespace
std::ignore = metawriter->RemoveMetadataByName(L"/sRGB/RenderingIntent"); std::ignore = metawriter->RemoveMetadataByName(L"/sRGB/RenderingIntent");
} }
} }
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX) #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0) else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
{ {
// Set Software name // Set Software name
@ -940,7 +940,7 @@ namespace
std::ignore = metawriter->SetMetadataByName(L"/ifd/exif/{ushort=40961}", &value); std::ignore = metawriter->SetMetadataByName(L"/ifd/exif/{ushort=40961}", &value);
} }
} }
#else #else
else else
{ {
// Set Software name // Set Software name
@ -954,7 +954,7 @@ namespace
std::ignore = metawriter->SetMetadataByName(L"System.Image.ColorSpace", &value); std::ignore = metawriter->SetMetadataByName(L"System.Image.ColorSpace", &value);
} }
} }
#endif #endif
} }
else if (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION) else if (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION)
{ {

396
DirectXTex/Shaders/BC6HEncode.hlsl
View File

@ -18,7 +18,7 @@
#define MAX_INT asint(0x7FFFFFFF) #define MAX_INT asint(0x7FFFFFFF)
#define MIN_INT asint(0x80000000) #define MIN_INT asint(0x80000000)
cbuffer cbCS : register( b0 ) cbuffer cbCS : register(b0)
{ {
uint g_tex_width; uint g_tex_width;
uint g_num_block_x; uint g_num_block_x;
@ -73,14 +73,14 @@ static const uint candidateFixUpIndex1D[32] =
}; };
//0, 9, 18, 27, 37, 46, 55, 64 //0, 9, 18, 27, 37, 46, 55, 64
static const uint aStep1[64] = {0,0,0,0,0,1,1,1, static const uint aStep1[64] = { 0,0,0,0,0,1,1,1,
1,1,1,1,1,1,2,2, 1,1,1,1,1,1,2,2,
2,2,2,2,2,2,2,3, 2,2,2,2,2,2,2,3,
3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3,
3,4,4,4,4,4,4,4, 3,4,4,4,4,4,4,4,
4,4,5,5,5,5,5,5, 4,4,5,5,5,5,5,5,
5,5,5,6,6,6,6,6, 5,5,5,6,6,6,6,6,
6,6,6,6,7,7,7,7}; 6,6,6,6,7,7,7,7 };
//0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 //0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64
static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2, static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2,
@ -90,7 +90,7 @@ static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2,
7, 8, 8, 8, 8, 9, 9, 9, 7, 8, 8, 8, 8, 9, 9, 9,
9,10,10,10,10,10,11,11, 9,10,10,10,10,10,11,11,
11,11,12,12,12,12,13,13, 11,11,12,12,12,12,13,13,
13,13,14,14,14,14,15,15}; 13,13,14,14,14,14,15,15 };
static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f); static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f);
@ -101,23 +101,23 @@ static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f);
//Forward declaration //Forward declaration
uint3 float2half( float3 pixel_f ); uint3 float2half(float3 pixel_f);
int3 start_quantize( uint3 pixel_h ); int3 start_quantize(uint3 pixel_h);
void quantize( inout int2x3 endPoint, uint prec ); void quantize(inout int2x3 endPoint, uint prec);
void finish_quantize_0( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ); void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
void finish_quantize_1( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ); void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
void finish_quantize( out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ); void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
void start_unquantize( inout int2x3 endPoint[2], uint4 prec, bool transformed ); void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed);
void start_unquantize( inout int2x3 endPoint, uint4 prec, bool transformed ); void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed);
void unquantize( inout int2x3 color, uint prec ); void unquantize(inout int2x3 color, uint prec);
uint3 finish_unquantize( int3 color ); uint3 finish_unquantize(int3 color);
void generate_palette_unquantized8( out uint3 palette, int3 low, int3 high, int i ); void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i);
void generate_palette_unquantized16( out uint3 palette, int3 low, int3 high, int i ); void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i);
float3 half2float(uint3 color_h ); float3 half2float(uint3 color_h);
void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index ); void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index);
void block_package( inout uint4 block, int2x3 endPoint, uint mode_type ); void block_package(inout uint4 block, int2x3 endPoint, uint mode_type);
void swap(inout int3 lhs, inout int3 rhs) void swap(inout int3 lhs, inout int3 rhs)
{ {
@ -126,10 +126,10 @@ void swap(inout int3 lhs, inout int3 rhs)
rhs = tmp; rhs = tmp;
} }
Texture2D<float4> g_Input : register( t0 ); Texture2D<float4> g_Input : register(t0);
StructuredBuffer<uint4> g_InBuff : register( t1 ); StructuredBuffer<uint4> g_InBuff : register(t1);
RWStructuredBuffer<uint4> g_OutBuff : register( u0 ); RWStructuredBuffer<uint4> g_OutBuff : register(u0);
struct SharedData struct SharedData
{ {
@ -148,8 +148,8 @@ struct SharedData
groupshared SharedData shared_temp[THREAD_GROUP_SIZE]; groupshared SharedData shared_temp[THREAD_GROUP_SIZE];
[numthreads( THREAD_GROUP_SIZE, 1, 1 )] [numthreads(THREAD_GROUP_SIZE, 1, 1)]
void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID ) void TryModeG10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
{ {
const uint MAX_USED_THREAD = 16; const uint MAX_USED_THREAD = 16;
uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD; uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
@ -172,11 +172,11 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
if (threadInBlock < 16) if (threadInBlock < 16)
{ {
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb; shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
uint3 pixel_h = float2half( shared_temp[GI].pixel ); uint3 pixel_h = float2half(shared_temp[GI].pixel);
shared_temp[GI].pixel_hr = half2float(pixel_h); shared_temp[GI].pixel_hr = half2float(pixel_h);
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM); shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
shared_temp[GI].pixel_ph = start_quantize( pixel_h ); shared_temp[GI].pixel_ph = start_quantize(pixel_h);
shared_temp[GI].endPoint_low = shared_temp[GI].pixel_ph; shared_temp[GI].endPoint_low = shared_temp[GI].pixel_ph;
shared_temp[GI].endPoint_high = shared_temp[GI].pixel_ph; shared_temp[GI].endPoint_high = shared_temp[GI].pixel_ph;
@ -253,7 +253,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
//ergod mode_type 11:14 //ergod mode_type 11:14
if ( threadInBlock == 0 ) if (threadInBlock == 0)
{ {
int2x3 endPoint; int2x3 endPoint;
// find_axis // find_axis
@ -262,9 +262,9 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
//compute_index //compute_index
float3 span = endPoint[1] - endPoint[0];// fixed a bug in v0.2 float3 span = endPoint[1] - endPoint[0];// fixed a bug in v0.2
float span_norm_sqr = dot( span, span );// fixed a bug in v0.2 float span_norm_sqr = dot(span, span);// fixed a bug in v0.2
float dotProduct = dot( span, shared_temp[threadBase + 0].pixel_ph - endPoint[0] );// fixed a bug in v0.2 float dotProduct = dot(span, shared_temp[threadBase + 0].pixel_ph - endPoint[0]);// fixed a bug in v0.2
if ( span_norm_sqr > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr ) > 32 ) if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
{ {
swap(endPoint[0], endPoint[1]); swap(endPoint[0], endPoint[1]);
@ -283,11 +283,11 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
endPoint[1] = shared_temp[threadBase + 0].endPoint_high; endPoint[1] = shared_temp[threadBase + 0].endPoint_high;
float3 span = endPoint[1] - endPoint[0]; float3 span = endPoint[1] - endPoint[0];
float span_norm_sqr = dot( span, span ); float span_norm_sqr = dot(span, span);
uint4 prec = candidateModePrec[threadInBlock + 10]; uint4 prec = candidateModePrec[threadInBlock + 10];
int2x3 endPoint_q = endPoint; int2x3 endPoint_q = endPoint;
quantize( endPoint_q, prec.x ); quantize(endPoint_q, prec.x);
bool transformed = candidateModeTransformed[threadInBlock + 10]; bool transformed = candidateModeTransformed[threadInBlock + 10];
if (transformed) if (transformed)
@ -296,26 +296,26 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
} }
bool bBadQuantize; bool bBadQuantize;
finish_quantize( bBadQuantize, endPoint_q, prec, transformed ); finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
start_unquantize( endPoint_q, prec, transformed ); start_unquantize(endPoint_q, prec, transformed);
unquantize( endPoint_q, prec.x ); unquantize(endPoint_q, prec.x);
float error = 0; float error = 0;
[loop]for ( uint j = 0; j < 16; j ++ ) [loop] for (uint j = 0; j < 16; j++)
{ {
float dotProduct = dot( span, shared_temp[threadBase + j].pixel_ph - endPoint[0] );// fixed a bug in v0.2 float dotProduct = dot(span, shared_temp[threadBase + j].pixel_ph - endPoint[0]);// fixed a bug in v0.2
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0 uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
: ( ( dotProduct < span_norm_sqr ) ? aStep2[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep2[63] ); : ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
uint3 pixel_rh; uint3 pixel_rh;
generate_palette_unquantized16( pixel_rh, endPoint_q[0], endPoint_q[1], index ); generate_palette_unquantized16(pixel_rh, endPoint_q[0], endPoint_q[1], index);
float3 pixel_r = half2float( pixel_rh ); float3 pixel_r = half2float(pixel_rh);
pixel_r -= shared_temp[threadBase + j].pixel_hr; pixel_r -= shared_temp[threadBase + j].pixel_hr;
error += dot(pixel_r, pixel_r); error += dot(pixel_r, pixel_r);
} }
if ( bBadQuantize ) if (bBadQuantize)
error = 1e20f; error = 1e20f;
shared_temp[GI].error = error; shared_temp[GI].error = error;
@ -327,7 +327,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
if (threadInBlock < 2) if (threadInBlock < 2)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 2].error ) if (shared_temp[GI].error > shared_temp[GI + 2].error)
{ {
shared_temp[GI].error = shared_temp[GI + 2].error; shared_temp[GI].error = shared_temp[GI + 2].error;
shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
@ -338,7 +338,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
if (threadInBlock < 1) if (threadInBlock < 1)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 1].error ) if (shared_temp[GI].error > shared_temp[GI + 1].error)
{ {
shared_temp[GI].error = shared_temp[GI + 1].error; shared_temp[GI].error = shared_temp[GI + 1].error;
shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
@ -348,8 +348,8 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
} }
} }
[numthreads( THREAD_GROUP_SIZE, 1, 1 )] [numthreads(THREAD_GROUP_SIZE, 1, 1)]
void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID ) void TryModeLE10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
{ {
const uint MAX_USED_THREAD = 32; const uint MAX_USED_THREAD = 32;
uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD; uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
@ -378,11 +378,11 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
if (threadInBlock < 16) if (threadInBlock < 16)
{ {
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb; shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
uint3 pixel_h = float2half( shared_temp[GI].pixel ); uint3 pixel_h = float2half(shared_temp[GI].pixel);
shared_temp[GI].pixel_hr = half2float(pixel_h); shared_temp[GI].pixel_hr = half2float(pixel_h);
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM); shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
shared_temp[GI].pixel_ph = start_quantize( pixel_h ); shared_temp[GI].pixel_ph = start_quantize(pixel_h);
} }
#ifdef REF_DEVICE #ifdef REF_DEVICE
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
@ -405,11 +405,11 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
endPoint_lum[1][1] = MIN_FLOAT; endPoint_lum[1][1] = MIN_FLOAT;
uint bit = candidateSectionBit[threadInBlock]; uint bit = candidateSectionBit[threadInBlock];
for ( uint i = 0; i < 16; i ++ ) for (uint i = 0; i < 16; i++)
{ {
int3 pixel_ph = shared_temp[threadBase + i].pixel_ph; int3 pixel_ph = shared_temp[threadBase + i].pixel_ph;
float pixel_lum = shared_temp[threadBase + i].pixel_lum; float pixel_lum = shared_temp[threadBase + i].pixel_lum;
if ( (bit >> i) & 1 ) //It gets error when using "candidateSection" as "endPoint_ph" index if ((bit >> i) & 1) //It gets error when using "candidateSection" as "endPoint_ph" index
{ {
if (endPoint_lum[1][0] > pixel_lum) if (endPoint_lum[1][0] > pixel_lum)
{ {
@ -441,13 +441,13 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
float3 span[2];// fixed a bug in v0.2 float3 span[2];// fixed a bug in v0.2
float span_norm_sqr[2];// fixed a bug in v0.2 float span_norm_sqr[2];// fixed a bug in v0.2
[unroll] [unroll]
for (uint p = 0; p < 2; ++ p) for (uint p = 0; p < 2; ++p)
{ {
span[p] = endPoint[p][1] - endPoint[p][0]; span[p] = endPoint[p][1] - endPoint[p][0];
span_norm_sqr[p] = dot( span[p], span[p] ); span_norm_sqr[p] = dot(span[p], span[p]);
float dotProduct = dot( span[p], shared_temp[threadBase + (0 == p ? 0 : candidateFixUpIndex1D[threadInBlock])].pixel_ph - endPoint[p][0] );// fixed a bug in v0.2 float dotProduct = dot(span[p], shared_temp[threadBase + (0 == p ? 0 : candidateFixUpIndex1D[threadInBlock])].pixel_ph - endPoint[p][0]);// fixed a bug in v0.2
if ( span_norm_sqr[p] > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr[p] ) > 32 ) if (span_norm_sqr[p] > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr[p]) > 32)
{ {
span[p] = -span[p]; span[p] = -span[p];
swap(endPoint[p][0], endPoint[p][1]); swap(endPoint[p][0], endPoint[p][1]);
@ -456,8 +456,8 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
uint4 prec = candidateModePrec[g_mode_id]; uint4 prec = candidateModePrec[g_mode_id];
int2x3 endPoint_q[2] = endPoint; int2x3 endPoint_q[2] = endPoint;
quantize( endPoint_q[0], prec.x ); quantize(endPoint_q[0], prec.x);
quantize( endPoint_q[1], prec.x ); quantize(endPoint_q[1], prec.x);
bool transformed = candidateModeTransformed[g_mode_id]; bool transformed = candidateModeTransformed[g_mode_id];
if (transformed) if (transformed)
@ -468,38 +468,38 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
} }
int bBadQuantize = 0; int bBadQuantize = 0;
finish_quantize_0( bBadQuantize, endPoint_q[0], prec, transformed ); finish_quantize_0(bBadQuantize, endPoint_q[0], prec, transformed);
finish_quantize_1( bBadQuantize, endPoint_q[1], prec, transformed ); finish_quantize_1(bBadQuantize, endPoint_q[1], prec, transformed);
start_unquantize( endPoint_q, prec, transformed ); start_unquantize(endPoint_q, prec, transformed);
unquantize( endPoint_q[0], prec.x ); unquantize(endPoint_q[0], prec.x);
unquantize( endPoint_q[1], prec.x ); unquantize(endPoint_q[1], prec.x);
float error = 0; float error = 0;
for ( uint j = 0; j < 16; j ++ ) for (uint j = 0; j < 16; j++)
{ {
uint3 pixel_rh; uint3 pixel_rh;
if ((bit >> j) & 1) if ((bit >> j) & 1)
{ {
float dotProduct = dot( span[1], shared_temp[threadBase + j].pixel_ph - endPoint[1][0] );// fixed a bug in v0.2 float dotProduct = dot(span[1], shared_temp[threadBase + j].pixel_ph - endPoint[1][0]);// fixed a bug in v0.2
uint index = ( span_norm_sqr[1] <= 0 || dotProduct <= 0 ) ? 0 uint index = (span_norm_sqr[1] <= 0 || dotProduct <= 0) ? 0
: ( ( dotProduct < span_norm_sqr[1] ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr[1] ) ] : aStep1[63] ); : ((dotProduct < span_norm_sqr[1]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[1])] : aStep1[63]);
generate_palette_unquantized8( pixel_rh, endPoint_q[1][0], endPoint_q[1][1], index ); generate_palette_unquantized8(pixel_rh, endPoint_q[1][0], endPoint_q[1][1], index);
} }
else else
{ {
float dotProduct = dot( span[0], shared_temp[threadBase + j].pixel_ph - endPoint[0][0] );// fixed a bug in v0.2 float dotProduct = dot(span[0], shared_temp[threadBase + j].pixel_ph - endPoint[0][0]);// fixed a bug in v0.2
uint index = ( span_norm_sqr[0] <= 0 || dotProduct <= 0 ) ? 0 uint index = (span_norm_sqr[0] <= 0 || dotProduct <= 0) ? 0
: ( ( dotProduct < span_norm_sqr[0] ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr[0] ) ] : aStep1[63] ); : ((dotProduct < span_norm_sqr[0]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[0])] : aStep1[63]);
generate_palette_unquantized8( pixel_rh, endPoint_q[0][0], endPoint_q[0][1], index ); generate_palette_unquantized8(pixel_rh, endPoint_q[0][0], endPoint_q[0][1], index);
} }
float3 pixel_r = half2float( pixel_rh ); float3 pixel_r = half2float(pixel_rh);
pixel_r -= shared_temp[threadBase + j].pixel_hr; pixel_r -= shared_temp[threadBase + j].pixel_hr;
error += dot(pixel_r, pixel_r); error += dot(pixel_r, pixel_r);
} }
if ( bBadQuantize ) if (bBadQuantize)
error = 1e20f; error = 1e20f;
shared_temp[GI].error = error; shared_temp[GI].error = error;
@ -512,7 +512,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
if (threadInBlock < 16) if (threadInBlock < 16)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 16].error ) if (shared_temp[GI].error > shared_temp[GI + 16].error)
{ {
shared_temp[GI].error = shared_temp[GI + 16].error; shared_temp[GI].error = shared_temp[GI + 16].error;
shared_temp[GI].best_mode = shared_temp[GI + 16].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 16].best_mode;
@ -524,7 +524,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
if (threadInBlock < 8) if (threadInBlock < 8)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 8].error ) if (shared_temp[GI].error > shared_temp[GI + 8].error)
{ {
shared_temp[GI].error = shared_temp[GI + 8].error; shared_temp[GI].error = shared_temp[GI + 8].error;
shared_temp[GI].best_mode = shared_temp[GI + 8].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 8].best_mode;
@ -536,7 +536,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
if (threadInBlock < 4) if (threadInBlock < 4)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 4].error ) if (shared_temp[GI].error > shared_temp[GI + 4].error)
{ {
shared_temp[GI].error = shared_temp[GI + 4].error; shared_temp[GI].error = shared_temp[GI + 4].error;
shared_temp[GI].best_mode = shared_temp[GI + 4].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 4].best_mode;
@ -548,7 +548,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
if (threadInBlock < 2) if (threadInBlock < 2)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 2].error ) if (shared_temp[GI].error > shared_temp[GI + 2].error)
{ {
shared_temp[GI].error = shared_temp[GI + 2].error; shared_temp[GI].error = shared_temp[GI + 2].error;
shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
@ -560,7 +560,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
#endif #endif
if (threadInBlock < 1) if (threadInBlock < 1)
{ {
if ( shared_temp[GI].error > shared_temp[GI + 1].error ) if (shared_temp[GI].error > shared_temp[GI + 1].error)
{ {
shared_temp[GI].error = shared_temp[GI + 1].error; shared_temp[GI].error = shared_temp[GI + 1].error;
shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode; shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
@ -578,7 +578,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
} }
} }
[numthreads( THREAD_GROUP_SIZE, 1, 1 )] [numthreads(THREAD_GROUP_SIZE, 1, 1)]
void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID) void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
{ {
const uint MAX_USED_THREAD = 32; const uint MAX_USED_THREAD = 32;
@ -602,10 +602,10 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
if (threadInBlock < 16) if (threadInBlock < 16)
{ {
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb; shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel, RGB2LUM); shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel, RGB2LUM);
uint3 pixel_h = float2half( shared_temp[GI].pixel ); uint3 pixel_h = float2half(shared_temp[GI].pixel);
shared_temp[GI].pixel_ph = start_quantize( pixel_h ); shared_temp[GI].pixel_ph = start_quantize(pixel_h);
} }
#ifdef REF_DEVICE #ifdef REF_DEVICE
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
@ -750,9 +750,9 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
} }
float3 span = endPoint[1] - endPoint[0]; float3 span = endPoint[1] - endPoint[0];
float span_norm_sqr = dot( span, span ); float span_norm_sqr = dot(span, span);
float dotProduct = dot( span, shared_temp[threadBase + fixup].pixel_ph - endPoint[0] ); float dotProduct = dot(span, shared_temp[threadBase + fixup].pixel_ph - endPoint[0]);
if ( span_norm_sqr > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr ) > 32 ) if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
{ {
swap(endPoint[0], endPoint[1]); swap(endPoint[0], endPoint[1]);
} }
@ -781,19 +781,19 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
if ((bits >> threadInBlock) & 1) if ((bits >> threadInBlock) & 1)
{ {
span = shared_temp[threadBase + 1].endPoint_high - shared_temp[threadBase + 1].endPoint_low; span = shared_temp[threadBase + 1].endPoint_high - shared_temp[threadBase + 1].endPoint_low;
dotProduct = dot( span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 1].endPoint_low ); dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 1].endPoint_low);
} }
else else
{ {
span = shared_temp[threadBase + 0].endPoint_high - shared_temp[threadBase + 0].endPoint_low; span = shared_temp[threadBase + 0].endPoint_high - shared_temp[threadBase + 0].endPoint_low;
dotProduct = dot( span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 0].endPoint_low ); dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 0].endPoint_low);
} }
float span_norm_sqr = dot( span, span ); float span_norm_sqr = dot(span, span);
if (best_mode > 10) if (best_mode > 10)
{ {
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0 uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
: ( ( dotProduct < span_norm_sqr ) ? aStep2[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep2[63] ); : ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
if (threadInBlock == 0) if (threadInBlock == 0)
{ {
block.z |= index << 1; block.z |= index << 1;
@ -809,8 +809,8 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
} }
else else
{ {
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0 uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
: ( ( dotProduct < span_norm_sqr ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep1[63] ); : ((dotProduct < span_norm_sqr) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep1[63]);
uint fixup = candidateFixUpIndex1D[best_partition]; uint fixup = candidateFixUpIndex1D[best_partition];
int2 offset = int2((fixup != 2), (fixup == 15)); int2 offset = int2((fixup != 2), (fixup == 15));
@ -889,7 +889,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
endPoint_q[0] = shared_temp[threadBase + 0].endPoint_low; endPoint_q[0] = shared_temp[threadBase + 0].endPoint_low;
endPoint_q[1] = shared_temp[threadBase + 0].endPoint_high; endPoint_q[1] = shared_temp[threadBase + 0].endPoint_high;
quantize( endPoint_q, prec.x ); quantize(endPoint_q, prec.x);
if (transformed) if (transformed)
{ {
endPoint_q[1] -= endPoint_q[0]; endPoint_q[1] -= endPoint_q[0];
@ -910,7 +910,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
if (best_mode <= 10) if (best_mode <= 10)
{ {
quantize( endPoint_q, prec.x ); quantize(endPoint_q, prec.x);
if (transformed) if (transformed)
{ {
endPoint_q[0] -= ep0; endPoint_q[0] -= ep0;
@ -936,18 +936,18 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
{ {
if (best_mode > 10) if (best_mode > 10)
{ {
finish_quantize( bBadQuantize, endPoint_q, prec, transformed ); finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
} }
else else
{ {
finish_quantize_0( bBadQuantize, endPoint_q, prec, transformed ); finish_quantize_0(bBadQuantize, endPoint_q, prec, transformed);
} }
} }
else // if (threadInBlock == 1) else // if (threadInBlock == 1)
{ {
if (best_mode <= 10) if (best_mode <= 10)
{ {
finish_quantize_1( bBadQuantize, endPoint_q, prec, transformed ); finish_quantize_1(bBadQuantize, endPoint_q, prec, transformed);
} }
} }
@ -958,7 +958,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
#endif #endif
if ( threadInBlock == 0 ) if (threadInBlock == 0)
{ {
int2x3 endPoint_q[2]; int2x3 endPoint_q[2];
endPoint_q[0][0] = shared_temp[threadBase + 0].endPoint_low; endPoint_q[0][0] = shared_temp[threadBase + 0].endPoint_low;
@ -966,20 +966,20 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
endPoint_q[1][0] = shared_temp[threadBase + 1].endPoint_low; endPoint_q[1][0] = shared_temp[threadBase + 1].endPoint_low;
endPoint_q[1][1] = shared_temp[threadBase + 1].endPoint_high; endPoint_q[1][1] = shared_temp[threadBase + 1].endPoint_high;
if ( best_mode > 10 ) if (best_mode > 10)
{ {
block_package( block, endPoint_q[0], best_mode ); block_package(block, endPoint_q[0], best_mode);
} }
else else
{ {
block_package( block, endPoint_q, best_mode, best_partition ); block_package(block, endPoint_q, best_mode, best_partition);
} }
g_OutBuff[blockID] = block; g_OutBuff[blockID] = block;
} }
} }
uint float2half1( float f ) uint float2half1(float f)
{ {
uint Result; uint Result;
@ -1012,7 +1012,7 @@ uint float2half1( float f )
return (Result|Sign); return (Result|Sign);
} }
uint3 float2half( float3 endPoint_f ) uint3 float2half(float3 endPoint_f)
{ {
//uint3 sign = asuint(endPoint_f) & 0x80000000; //uint3 sign = asuint(endPoint_f) & 0x80000000;
//uint3 expo = asuint(endPoint_f) & 0x7F800000; //uint3 expo = asuint(endPoint_f) & 0x7F800000;
@ -1027,140 +1027,140 @@ uint3 float2half( float3 endPoint_f )
// : ( ( sign >> 16 ) | ( ( ( expo - 0x38000000 ) | base ) >> 13 ) ) ) ); // : ( ( sign >> 16 ) | ( ( ( expo - 0x38000000 ) | base ) >> 13 ) ) ) );
return uint3( float2half1( endPoint_f.x ), float2half1( endPoint_f.y ), float2half1( endPoint_f.z ) ); return uint3(float2half1(endPoint_f.x), float2half1(endPoint_f.y), float2half1(endPoint_f.z));
} }
int3 start_quantize( uint3 pixel_h ) int3 start_quantize(uint3 pixel_h)
{ {
if ( g_format == UNSIGNED_F16 ) if (g_format == UNSIGNED_F16)
{ {
return asint( ( pixel_h << 6 ) / 31 ); return asint((pixel_h << 6) / 31);
} }
else else
{ {
return ( pixel_h < 0x8000 ) ? ( ( pixel_h == 0x7bff ) ? 0x7fff : asint( ( pixel_h << 5 ) / 31 ) )// fixed a bug in v0.2 return (pixel_h < 0x8000) ? ((pixel_h == 0x7bff) ? 0x7fff : asint((pixel_h << 5) / 31))// fixed a bug in v0.2
: ( ( pixel_h == 0x7bff ) ? 0xffff8001 : -asint( ( ( 0x00007fff & pixel_h ) << 5 ) / 31 ) );// fixed a bug in v0.2 : ((pixel_h == 0x7bff) ? 0xffff8001 : -asint(((0x00007fff & pixel_h) << 5) / 31));// fixed a bug in v0.2
} }
} }
void quantize( inout int2x3 endPoint, uint prec ) void quantize(inout int2x3 endPoint, uint prec)
{ {
int iprec = asint( prec ); int iprec = asint(prec);
if ( g_format == UNSIGNED_F16 ) if (g_format == UNSIGNED_F16)
{ {
endPoint = ( ( iprec >= 15 ) | ( endPoint == 0 ) ) ? endPoint endPoint = ((iprec >= 15) | (endPoint == 0)) ? endPoint
: ( ( endPoint == asint(0xFFFF) ) ? ( ( 1 << iprec ) - 1 ) : ((endPoint == asint(0xFFFF)) ? ((1 << iprec) - 1)
: ( ( ( endPoint << iprec ) + asint(0x0000) ) >> 16 ) ); : (((endPoint << iprec) + asint(0x0000)) >> 16));
} }
else else
{ {
endPoint = ( ( iprec >= 16 ) | ( endPoint == 0 ) ) ? endPoint endPoint = ((iprec >= 16) | (endPoint == 0)) ? endPoint
: ( ( endPoint >= 0 ) ? ( ( endPoint == asint(0x7FFF) ) ? ( ( 1 << ( iprec - 1 ) ) - 1 ) : ( ( ( endPoint << ( iprec - 1 ) ) + asint(0x0000) ) >> 15 ) ) : ((endPoint >= 0) ? ((endPoint == asint(0x7FFF)) ? ((1 << (iprec - 1)) - 1) : (((endPoint << (iprec - 1)) + asint(0x0000)) >> 15))
: ( ( -endPoint == asint(0x7FFF) ) ? -( ( 1 << ( iprec - 1 ) ) - 1 ) : -( ( ( -endPoint << ( iprec - 1 ) ) + asint(0x0000) ) >> 15 ) ) ); : ((-endPoint == asint(0x7FFF)) ? -((1 << (iprec - 1)) - 1) : -(((-endPoint << (iprec - 1)) + asint(0x0000)) >> 15)));
} }
} }
void finish_quantize_0( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ) void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
{ {
if ( transformed ) if (transformed)
{ {
bool3 bBadComponent = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) bool3 bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ); : (-endPoint[1] > (1 << (prec.yzw - 1)));
bBadQuantize |= any(bBadComponent); bBadQuantize |= any(bBadComponent);
endPoint[0] = endPoint[0] & ( ( 1 << prec.x ) - 1 ); endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] ) endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) ); : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
} }
else else
{ {
endPoint &= ( ( 1 << prec.x ) - 1 ); endPoint &= ((1 << prec.x) - 1);
} }
} }
void finish_quantize_1( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ) void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
{ {
if ( transformed ) if (transformed)
{ {
bool2x3 bBadComponent; bool2x3 bBadComponent;
bBadComponent[0] = ( endPoint[0] >= 0 ) ? ( endPoint[0] >= ( 1 << ( prec.yzw - 1 ) ) ) bBadComponent[0] = (endPoint[0] >= 0) ? (endPoint[0] >= (1 << (prec.yzw - 1)))
: ( -endPoint[0] > ( 1 << ( prec.yzw - 1 ) ) ); : (-endPoint[0] > (1 << (prec.yzw - 1)));
bBadComponent[1] = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) bBadComponent[1] = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ); : (-endPoint[1] > (1 << (prec.yzw - 1)));
bBadQuantize |= any(bBadComponent); bBadQuantize |= any(bBadComponent);
endPoint[0] = ( endPoint[0] >= 0 ) ? ( ( endPoint[0] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[0] ) endPoint[0] = (endPoint[0] >= 0) ? ((endPoint[0] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[0])
: ( ( -endPoint[0] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[0] & ( ( 1 << prec.yzw ) - 1 ) ) ); : ((-endPoint[0] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[0] & ((1 << prec.yzw) - 1)));
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] ) endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) ); : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
} }
else else
{ {
endPoint &= ( ( 1 << prec.x ) - 1 ); endPoint &= ((1 << prec.x) - 1);
} }
} }
void finish_quantize( out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed ) void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
{ {
if ( transformed ) if (transformed)
{ {
bool3 bBadComponent; bool3 bBadComponent;
bBadComponent = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ); : (-endPoint[1] > (1 << (prec.yzw - 1)));
bBadQuantize = any( bBadComponent ); bBadQuantize = any(bBadComponent);
endPoint[0] = endPoint[0] & ( ( 1 << prec.x ) - 1 ); endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] ) endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) ); : ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
} }
else else
{ {
endPoint &= ( ( 1 << prec.x ) - 1 ); endPoint &= ((1 << prec.x) - 1);
bBadQuantize = 0; bBadQuantize = 0;
} }
} }
void SIGN_EXTEND( uint3 prec, inout int3 color ) void SIGN_EXTEND(uint3 prec, inout int3 color)
{ {
uint3 p = 1 << (prec - 1); uint3 p = 1 << (prec - 1);
color = (color & p) ? (color & (p - 1)) - p : color; color = (color & p) ? (color & (p - 1)) - p : color;
} }
void sign_extend( bool transformed, uint4 prec, inout int2x3 endPoint ) void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint)
{ {
if ( g_format == SIGNED_F16 ) if (g_format == SIGNED_F16)
SIGN_EXTEND( prec.x, endPoint[0] ); SIGN_EXTEND(prec.x, endPoint[0]);
if ( g_format == SIGNED_F16 || transformed ) if (g_format == SIGNED_F16 || transformed)
SIGN_EXTEND( prec.yzw, endPoint[1] ); SIGN_EXTEND(prec.yzw, endPoint[1]);
} }
void sign_extend( bool transformed, uint4 prec, inout int2x3 endPoint[2] ) void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint[2])
{ {
if ( g_format == SIGNED_F16 ) if (g_format == SIGNED_F16)
SIGN_EXTEND( prec.x, endPoint[0][0] ); SIGN_EXTEND(prec.x, endPoint[0][0]);
if ( g_format == SIGNED_F16 || transformed ) if (g_format == SIGNED_F16 || transformed)
{ {
SIGN_EXTEND( prec.yzw, endPoint[0][1] ); SIGN_EXTEND(prec.yzw, endPoint[0][1]);
SIGN_EXTEND( prec.yzw, endPoint[1][0] ); SIGN_EXTEND(prec.yzw, endPoint[1][0]);
SIGN_EXTEND( prec.yzw, endPoint[1][1] ); SIGN_EXTEND(prec.yzw, endPoint[1][1]);
} }
} }
void start_unquantize( inout int2x3 endPoint[2], uint4 prec, bool transformed ) void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed)
{ {
sign_extend( transformed, prec, endPoint ); sign_extend(transformed, prec, endPoint);
if ( transformed ) if (transformed)
{ {
endPoint[0][1] += endPoint[0][0]; endPoint[0][1] += endPoint[0][0];
endPoint[1][0] += endPoint[0][0]; endPoint[1][0] += endPoint[0][0];
endPoint[1][1] += endPoint[0][0]; endPoint[1][1] += endPoint[0][0];
} }
} }
void start_unquantize( inout int2x3 endPoint, uint4 prec, bool transformed ) void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed)
{ {
sign_extend( transformed, prec, endPoint ); sign_extend(transformed, prec, endPoint);
if ( transformed ) if (transformed)
endPoint[1] += endPoint[0]; endPoint[1] += endPoint[0];
} }
void unquantize( inout int2x3 color, uint prec ) void unquantize(inout int2x3 color, uint prec)
{ {
int iprec = asint( prec ); int iprec = asint(prec);
if (g_format == UNSIGNED_F16 ) if (g_format == UNSIGNED_F16)
{ {
if (prec < 15) if (prec < 15)
{ {
@ -1178,33 +1178,33 @@ void unquantize( inout int2x3 color, uint prec )
} }
} }
} }
uint3 finish_unquantize( int3 color ) uint3 finish_unquantize(int3 color)
{ {
if ( g_format == UNSIGNED_F16 ) if (g_format == UNSIGNED_F16)
color = ( color * 31 ) >> 6; color = (color * 31) >> 6;
else else
{ {
color = ( color < 0 ) ? -( ( -color * 31 ) >> 5 ) : ( color * 31 ) >> 5; color = (color < 0) ? -((-color * 31) >> 5) : (color * 31) >> 5;
color = ( color < 0 ) ? ( ( -color ) | 0x8000 ) : color; color = (color < 0) ? ((-color) | 0x8000) : color;
} }
return asuint(color); return asuint(color);
} }
void generate_palette_unquantized8( out uint3 palette, int3 low, int3 high, int i ) void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i)
{ {
static const int aWeight3[] = {0, 9, 18, 27, 37, 46, 55, 64}; static const int aWeight3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
int3 tmp = ( low * ( 64 - aWeight3[i] ) + high * aWeight3[i] + 32 ) >> 6; int3 tmp = (low * (64 - aWeight3[i]) + high * aWeight3[i] + 32) >> 6;
palette = finish_unquantize( tmp ); palette = finish_unquantize(tmp);
} }
void generate_palette_unquantized16( out uint3 palette, int3 low, int3 high, int i ) void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i)
{ {
static const int aWeight4[] = {0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64}; static const int aWeight4[] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
int3 tmp = ( low * ( 64 - aWeight4[i] ) + high * aWeight4[i] + 32 ) >> 6; int3 tmp = (low * (64 - aWeight4[i]) + high * aWeight4[i] + 32) >> 6;
palette = finish_unquantize( tmp ); palette = finish_unquantize(tmp);
} }
float half2float1( uint Value ) float half2float1(uint Value)
{ {
uint Mantissa = (uint)(Value & 0x03FF); uint Mantissa = (uint)(Value & 0x03FF);
@ -1238,7 +1238,7 @@ float half2float1( uint Value )
return asfloat(Result); return asfloat(Result);
} }
float3 half2float(uint3 color_h ) float3 half2float(uint3 color_h)
{ {
//uint3 sign = color_h & 0x8000; //uint3 sign = color_h & 0x8000;
//uint3 expo = color_h & 0x7C00; //uint3 expo = color_h & 0x7C00;
@ -1246,17 +1246,17 @@ float3 half2float(uint3 color_h )
//return ( expo == 0 ) ? asfloat( ( sign << 16 ) | asuint( float3(base) / 16777216 ) ) //16777216 = 2^24 //return ( expo == 0 ) ? asfloat( ( sign << 16 ) | asuint( float3(base) / 16777216 ) ) //16777216 = 2^24
// : asfloat( ( sign << 16 ) | ( ( ( expo + 0x1C000 ) | base ) << 13 ) ); //0x1C000 = 0x1FC00 - 0x3C00 // : asfloat( ( sign << 16 ) | ( ( ( expo + 0x1C000 ) | base ) << 13 ) ); //0x1C000 = 0x1FC00 - 0x3C00
return float3( half2float1( color_h.x ), half2float1( color_h.y ), half2float1( color_h.z ) ); return float3(half2float1(color_h.x), half2float1(color_h.y), half2float1(color_h.z));
} }
void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index ) // for mode 1 - 10 void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index) // for mode 1 - 10
{ {
block.xy = 0; block.xy = 0;
block.z &= 0xFFFC0000; block.z &= 0xFFFC0000;
//block.z |= (partition_index & 0x1f) << 13; //block.z |= (partition_index & 0x1f) << 13;
if ( mode_type == candidateModeFlag[0]) if (mode_type == candidateModeFlag[0])
{ {
/*block.x = candidateModeMemory[0]; /*block.x = candidateModeMemory[0];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1355,7 +1355,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[1]) else if (mode_type == candidateModeFlag[1])
{ {
/*block.x = candidateModeMemory[1]; /*block.x = candidateModeMemory[1];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00000FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x003F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00000FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x003F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1453,7 +1453,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[2]) else if (mode_type == candidateModeFlag[2])
{ {
/*block.x = candidateModeMemory[2]; /*block.x = candidateModeMemory[2];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1550,7 +1550,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[3]) else if (mode_type == candidateModeFlag[3])
{ {
/*block.x = candidateModeMemory[3]; /*block.x = candidateModeMemory[3];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1651,7 +1651,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[4]) else if (mode_type == candidateModeFlag[4])
{ {
/*block.x = candidateModeMemory[4]; /*block.x = candidateModeMemory[4];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1750,7 +1750,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[5]) else if (mode_type == candidateModeFlag[5])
{ {
/*block.x = candidateModeMemory[5]; /*block.x = candidateModeMemory[5];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00003FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x00FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00003FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x00FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000);
@ -1849,7 +1849,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[6]) else if (mode_type == candidateModeFlag[6])
{ {
/*block.x = candidateModeMemory[6]; /*block.x = candidateModeMemory[6];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -1947,7 +1947,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[7]) else if (mode_type == candidateModeFlag[7])
{ {
/*block.x = candidateModeMemory[7]; /*block.x = candidateModeMemory[7];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -2047,7 +2047,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[8]) else if (mode_type == candidateModeFlag[8])
{ {
/*block.x = candidateModeMemory[8]; /*block.x = candidateModeMemory[8];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
@ -2147,7 +2147,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 3) & 1) << 16; block.z |= ((partition_index >> 3) & 1) << 16;
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
else if ( mode_type == candidateModeFlag[9]) else if (mode_type == candidateModeFlag[9])
{ {
/*block.x = candidateModeMemory[9]; /*block.x = candidateModeMemory[9];
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x000007E0 ) | ( ( endPoint[0][0].g << 15 ) & 0x001F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0x7E000000 ); block.x |= ( ( endPoint[0][0].r << 5 ) & 0x000007E0 ) | ( ( endPoint[0][0].g << 15 ) & 0x001F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0x7E000000 );
@ -2246,7 +2246,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
block.z |= ((partition_index >> 4) & 1) << 17; block.z |= ((partition_index >> 4) & 1) << 17;
} }
} }
void block_package( inout uint4 block, int2x3 endPoint, uint mode_type ) // for mode 11 - 14 void block_package(inout uint4 block, int2x3 endPoint, uint mode_type) // for mode 11 - 14
{ {
/*block.x = ( ( endPoint[0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0].b << 25 ) & 0xFE000000 ); /*block.x = ( ( endPoint[0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0].b << 25 ) & 0xFE000000 );
block.y |= ( endPoint[0].b >> 7 ) & 0x00000007;*/ block.y |= ( endPoint[0].b >> 7 ) & 0x00000007;*/
@ -2255,7 +2255,7 @@ void block_package( inout uint4 block, int2x3 endPoint, uint mode_type ) // for
block.z &= 0xFFFFFFFE; block.z &= 0xFFFFFFFE;
if ( mode_type == candidateModeFlag[10]) if (mode_type == candidateModeFlag[10])
{ {
/* block.x |= candidateModeMemory[10]; /* block.x |= candidateModeMemory[10];
block.y |= ( ( endPoint[1].r << 3 ) & 0x00001FF8 ) | ( ( endPoint[1].g << 13 ) & 0x007FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 ); block.y |= ( ( endPoint[1].r << 3 ) & 0x00001FF8 ) | ( ( endPoint[1].g << 13 ) & 0x007FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 );

700
DirectXTex/Shaders/BC7Encode.hlsl
View File

File diff suppressed because it is too large Load Diff

10
DirectXTex/filters.h
View File

@ -28,7 +28,7 @@ namespace DirectX
XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } }; XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } };
XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } }; XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } };
#define AVERAGE4( res, p0, p1, p2, p3 ) \ #define AVERAGE4( res, p0, p1, p2, p3 ) \
{ \ { \
XMVECTOR v = XMVectorAdd((p0), (p1)); \ XMVECTOR v = XMVectorAdd((p0), (p1)); \
v = XMVectorAdd(v, (p2)); \ v = XMVectorAdd(v, (p2)); \
@ -36,7 +36,7 @@ namespace DirectX
res = XMVectorMultiply(v, g_boxScale); \ res = XMVectorMultiply(v, g_boxScale); \
} }
#define AVERAGE8( res, p0, p1, p2, p3, p4, p5, p6, p7) \ #define AVERAGE8( res, p0, p1, p2, p3, p4, p5, p6, p7) \
{ \ { \
XMVECTOR v = XMVectorAdd((p0), (p1)); \ XMVECTOR v = XMVectorAdd((p0), (p1)); \
v = XMVectorAdd(v, (p2)); \ v = XMVectorAdd(v, (p2)); \
@ -99,11 +99,11 @@ namespace DirectX
} }
} }
#define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \ #define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \
res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \ res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \
XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) ); XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) );
#define TRILINEAR_INTERPOLATE( res, x, y, z, r0, r1, r2, r3 ) \ #define TRILINEAR_INTERPOLATE( res, x, y, z, r0, r1, r2, r3 ) \
{\ {\
const XMVECTOR a0 = XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0 ), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0); \ const XMVECTOR a0 = XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0 ), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0); \
const XMVECTOR a1 = XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0 ), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1); \ const XMVECTOR a1 = XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0 ), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1); \
@ -189,7 +189,7 @@ namespace DirectX
} }
} }
#define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \ #define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \
{ \ { \
const XMVECTOR a0 = (p1); \ const XMVECTOR a0 = (p1); \
const XMVECTOR d0 = XMVectorSubtract(p0, a0); \ const XMVECTOR d0 = XMVectorSubtract(p0, a0); \

2
DirectXTex/scoped.h
View File

@ -29,7 +29,7 @@ inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
if (size > static_cast<uint64_t>(UINT32_MAX)) if (size > static_cast<uint64_t>(UINT32_MAX))
return nullptr; return nullptr;
auto ptr = aligned_alloc(16, static_cast<size_t>(size) ); auto ptr = aligned_alloc(16, static_cast<size_t>(size));
return ScopedAlignedArrayFloat(static_cast<float*>(ptr)); return ScopedAlignedArrayFloat(static_cast<float*>(ptr));
} }

48
ScreenGrab/ScreenGrab11.cpp
View File

@ -57,7 +57,7 @@ using Microsoft::WRL::ComPtr;
// Macros // Macros
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */ #endif /* defined(MAKEFOURCC) */
@ -69,9 +69,9 @@ using Microsoft::WRL::ComPtr;
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
namespace namespace
{ {
#pragma pack(push,1) #pragma pack(push,1)
#define DDS_MAGIC 0x20534444 // "DDS " #define DDS_MAGIC 0x20534444 // "DDS "
struct DDS_PIXELFORMAT struct DDS_PIXELFORMAT
{ {
@ -85,20 +85,20 @@ namespace
uint32_t ABitMask; uint32_t ABitMask;
}; };
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC #define DDS_FOURCC 0x00000004 // DDPF_FOURCC
#define DDS_RGB 0x00000040 // DDPF_RGB #define DDS_RGB 0x00000040 // DDPF_RGB
#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_ALPHA 0x00000002 // DDPF_ALPHA #define DDS_ALPHA 0x00000002 // DDPF_ALPHA
#define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV #define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV
#define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT #define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT #define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT
#define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH #define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH
#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE #define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE
#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE #define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE
struct DDS_HEADER struct DDS_HEADER
{ {
@ -127,7 +127,7 @@ namespace
uint32_t reserved; uint32_t reserved;
}; };
#pragma pack(pop) #pragma pack(pop)
const DDS_PIXELFORMAT DDSPF_DXT1 = const DDS_PIXELFORMAT DDSPF_DXT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
@ -574,13 +574,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -732,7 +732,7 @@ namespace
BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
HRESULT hr = CoCreateInstance( HRESULT hr = CoCreateInstance(
CLSID_WICImagingFactory2, CLSID_WICImagingFactory2,
nullptr, nullptr,
@ -758,14 +758,14 @@ namespace
); );
return SUCCEEDED(hr) ? TRUE : FALSE; return SUCCEEDED(hr) ? TRUE : FALSE;
} }
#else #else
return SUCCEEDED(CoCreateInstance( return SUCCEEDED(CoCreateInstance(
CLSID_WICImagingFactory, CLSID_WICImagingFactory,
nullptr, nullptr,
CLSCTX_INPROC_SERVER, CLSCTX_INPROC_SERVER,
__uuidof(IWICImagingFactory), __uuidof(IWICImagingFactory),
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
#endif #endif
} }
IWICImagingFactory* GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept
@ -1092,7 +1092,7 @@ HRESULT DirectX::SaveWICTextureToFile(
// Screenshots don't typically include the alpha channel of the render target // Screenshots don't typically include the alpha channel of the render target
switch (desc.Format) switch (desc.Format)
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
case DXGI_FORMAT_R32G32B32A32_FLOAT: case DXGI_FORMAT_R32G32B32A32_FLOAT:
case DXGI_FORMAT_R16G16B16A16_FLOAT: case DXGI_FORMAT_R16G16B16A16_FLOAT:
if (g_WIC2) if (g_WIC2)
@ -1104,7 +1104,7 @@ HRESULT DirectX::SaveWICTextureToFile(
targetGuid = GUID_WICPixelFormat24bppBGR; targetGuid = GUID_WICPixelFormat24bppBGR;
} }
break; break;
#endif #endif
case DXGI_FORMAT_R16G16B16A16_UNORM: targetGuid = GUID_WICPixelFormat48bppBGR; break; case DXGI_FORMAT_R16G16B16A16_UNORM: targetGuid = GUID_WICPixelFormat48bppBGR; break;
case DXGI_FORMAT_B5G5R5A1_UNORM: targetGuid = GUID_WICPixelFormat16bppBGR555; break; case DXGI_FORMAT_B5G5R5A1_UNORM: targetGuid = GUID_WICPixelFormat16bppBGR555; break;

42
ScreenGrab/ScreenGrab12.cpp
View File

@ -91,9 +91,9 @@ using Microsoft::WRL::ComPtr;
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
namespace namespace
{ {
#pragma pack(push,1) #pragma pack(push,1)
#define DDS_MAGIC 0x20534444 // "DDS " #define DDS_MAGIC 0x20534444 // "DDS "
struct DDS_PIXELFORMAT struct DDS_PIXELFORMAT
{ {
@ -107,20 +107,20 @@ namespace
uint32_t ABitMask; uint32_t ABitMask;
}; };
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC #define DDS_FOURCC 0x00000004 // DDPF_FOURCC
#define DDS_RGB 0x00000040 // DDPF_RGB #define DDS_RGB 0x00000040 // DDPF_RGB
#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_ALPHA 0x00000002 // DDPF_ALPHA #define DDS_ALPHA 0x00000002 // DDPF_ALPHA
#define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV #define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV
#define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT #define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT #define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT
#define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH #define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH
#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE #define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE
#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE #define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE
struct DDS_HEADER struct DDS_HEADER
{ {
@ -149,7 +149,7 @@ namespace
uint32_t reserved; uint32_t reserved;
}; };
#pragma pack(pop) #pragma pack(pop)
const DDS_PIXELFORMAT DDSPF_DXT1 = const DDS_PIXELFORMAT DDSPF_DXT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
@ -602,13 +602,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -842,11 +842,11 @@ namespace
// Block until the copy is complete // Block until the copy is complete
while (fence->GetCompletedValue() < 1) while (fence->GetCompletedValue() < 1)
{ {
#ifdef WIN32 #ifdef WIN32
SwitchToThread(); SwitchToThread();
#else #else
std::this_thread::yield(); std::this_thread::yield();
#endif #endif
} }
return S_OK; return S_OK;

66
ScreenGrab/ScreenGrab9.cpp
View File

@ -51,7 +51,7 @@ using Microsoft::WRL::ComPtr;
// Macros // Macros
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */ #endif /* defined(MAKEFOURCC) */
@ -63,9 +63,9 @@ using Microsoft::WRL::ComPtr;
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
namespace namespace
{ {
#pragma pack(push,1) #pragma pack(push,1)
#define DDS_MAGIC 0x20534444 // "DDS " #define DDS_MAGIC 0x20534444 // "DDS "
struct DDS_PIXELFORMAT struct DDS_PIXELFORMAT
{ {
@ -79,21 +79,21 @@ namespace
uint32_t ABitMask; uint32_t ABitMask;
}; };
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC #define DDS_FOURCC 0x00000004 // DDPF_FOURCC
#define DDS_RGB 0x00000040 // DDPF_RGB #define DDS_RGB 0x00000040 // DDPF_RGB
#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_ALPHA 0x00000002 // DDPF_ALPHA #define DDS_ALPHA 0x00000002 // DDPF_ALPHA
#define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV #define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV
#define DDS_BUMPLUMINANCE 0x00040000 // DDPF_BUMPLUMINANCE #define DDS_BUMPLUMINANCE 0x00040000 // DDPF_BUMPLUMINANCE
#define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT #define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT #define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT
#define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH #define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH
#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE #define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE
#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE #define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE
struct DDS_HEADER struct DDS_HEADER
{ {
@ -113,7 +113,7 @@ namespace
uint32_t reserved2; uint32_t reserved2;
}; };
#pragma pack(pop) #pragma pack(pop)
const DDS_PIXELFORMAT DDSPF_DXT1 = const DDS_PIXELFORMAT DDSPF_DXT1 =
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 }; { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
@ -316,9 +316,9 @@ namespace
case D3DFMT_INDEX32: case D3DFMT_INDEX32:
case D3DFMT_G16R16F: case D3DFMT_G16R16F:
case D3DFMT_R32F: case D3DFMT_R32F:
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_D32_LOCKABLE: case D3DFMT_D32_LOCKABLE:
#endif #endif
return 32; return 32;
case D3DFMT_R8G8B8: case D3DFMT_R8G8B8:
@ -354,9 +354,9 @@ namespace
case D3DFMT_P8: case D3DFMT_P8:
case D3DFMT_L8: case D3DFMT_L8:
case D3DFMT_A4L4: case D3DFMT_A4L4:
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_S8_LOCKABLE: case D3DFMT_S8_LOCKABLE:
#endif #endif
return 8; return 8;
case D3DFMT_DXT1: case D3DFMT_DXT1:
@ -374,10 +374,10 @@ namespace
case MAKEFOURCC('Y', 'V', '1', '2'): case MAKEFOURCC('Y', 'V', '1', '2'):
return 12; return 12;
#if !defined(D3D_DISABLE_9EX) #if !defined(D3D_DISABLE_9EX)
case D3DFMT_A1: case D3DFMT_A1:
return 1; return 1;
#endif #endif
default: default:
return 0; return 0;
@ -483,13 +483,13 @@ namespace
numBytes = rowBytes * height; numBytes = rowBytes * height;
} }
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!"); static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX) if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
#else #else
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!"); static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
#endif #endif
if (outNumBytes) if (outNumBytes)
{ {
@ -513,7 +513,7 @@ namespace
BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
HRESULT hr = CoCreateInstance( HRESULT hr = CoCreateInstance(
CLSID_WICImagingFactory2, CLSID_WICImagingFactory2,
nullptr, nullptr,
@ -539,14 +539,14 @@ namespace
); );
return SUCCEEDED(hr) ? TRUE : FALSE; return SUCCEEDED(hr) ? TRUE : FALSE;
} }
#else #else
return SUCCEEDED(CoCreateInstance( return SUCCEEDED(CoCreateInstance(
CLSID_WICImagingFactory, CLSID_WICImagingFactory,
nullptr, nullptr,
CLSCTX_INPROC_SERVER, CLSCTX_INPROC_SERVER,
__uuidof(IWICImagingFactory), __uuidof(IWICImagingFactory),
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
#endif #endif
} }
IWICImagingFactory* GetWIC() IWICImagingFactory* GetWIC()
@ -795,14 +795,14 @@ HRESULT DirectX::SaveWICTextureToFile(
case D3DFMT_R32F: pfGuid = GUID_WICPixelFormat32bppGrayFloat; break; case D3DFMT_R32F: pfGuid = GUID_WICPixelFormat32bppGrayFloat; break;
case D3DFMT_A32B32G32R32F: pfGuid = GUID_WICPixelFormat128bppRGBAFloat; break; case D3DFMT_A32B32G32R32F: pfGuid = GUID_WICPixelFormat128bppRGBAFloat; break;
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
case D3DFMT_X8B8G8R8: case D3DFMT_X8B8G8R8:
if (g_WIC2) if (g_WIC2)
pfGuid = GUID_WICPixelFormat32bppRGB; pfGuid = GUID_WICPixelFormat32bppRGB;
else else
HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
break; break;
#endif #endif
default: default:
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
@ -874,7 +874,7 @@ HRESULT DirectX::SaveWICTextureToFile(
// Screenshots don't typically include the alpha channel of the render target // Screenshots don't typically include the alpha channel of the render target
switch (desc.Format) switch (desc.Format)
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
case D3DFMT_A32B32G32R32F: case D3DFMT_A32B32G32R32F:
case D3DFMT_A16B16G16R16F: case D3DFMT_A16B16G16R16F:
if (g_WIC2) if (g_WIC2)
@ -886,7 +886,7 @@ HRESULT DirectX::SaveWICTextureToFile(
targetGuid = GUID_WICPixelFormat24bppBGR; targetGuid = GUID_WICPixelFormat24bppBGR;
} }
break; break;
#endif #endif
case D3DFMT_A16B16G16R16: targetGuid = GUID_WICPixelFormat48bppBGR; break; case D3DFMT_A16B16G16R16: targetGuid = GUID_WICPixelFormat48bppBGR; break;
case D3DFMT_R5G6B5: targetGuid = GUID_WICPixelFormat16bppBGR565; break; case D3DFMT_R5G6B5: targetGuid = GUID_WICPixelFormat16bppBGR565; break;

16
Texassemble/texassemble.cpp
View File

@ -686,9 +686,9 @@ namespace
wprintf(L"Microsoft (R) DirectX Texture Assembler [DirectXTex] Version %ls\n", version); wprintf(L"Microsoft (R) DirectX Texture Assembler [DirectXTex] Version %ls\n", version);
wprintf(L"Copyright (C) Microsoft Corp.\n"); wprintf(L"Copyright (C) Microsoft Corp.\n");
#ifdef _DEBUG #ifdef _DEBUG
wprintf(L"*** Debug build ***\n"); wprintf(L"*** Debug build ***\n");
#endif #endif
wprintf(L"\n"); wprintf(L"\n");
} }
@ -785,10 +785,10 @@ namespace
case CODEC_HDR: case CODEC_HDR:
return SaveToHDRFile(img, szOutputFile); return SaveToHDRFile(img, szOutputFile);
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
case CODEC_EXR: case CODEC_EXR:
return SaveToEXRFile(img, szOutputFile); return SaveToEXRFile(img, szOutputFile);
#endif #endif
default: default:
{ {
@ -1458,7 +1458,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
} }
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
else if (_wcsicmp(ext, L".exr") == 0) else if (_wcsicmp(ext, L".exr") == 0)
{ {
hr = LoadFromEXRFile(pConv->szSrc, &info, *image); hr = LoadFromEXRFile(pConv->szSrc, &info, *image);
@ -1468,7 +1468,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
} }
#endif #endif
else else
{ {
// WIC shares the same filter values for mode and dither // WIC shares the same filter values for mode and dither
@ -1779,9 +1779,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);

6
Texconv/ExtendedBMP.cpp
View File

@ -45,12 +45,12 @@ namespace
{ {
blob.reset(); blob.reset();
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr))); ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
#else #else
ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
FILE_FLAG_SEQUENTIAL_SCAN, nullptr))); FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
#endif #endif
if (!hFile) if (!hFile)
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());

6
Texconv/PortablePixMap.cpp
View File

@ -82,12 +82,12 @@ namespace
{ {
blob.reset(); blob.reset();
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr))); ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
#else #else
ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
FILE_FLAG_SEQUENTIAL_SCAN, nullptr))); FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
#endif #endif
if (!hFile) if (!hFile)
{ {
return HRESULT_FROM_WIN32(GetLastError()); return HRESULT_FROM_WIN32(GetLastError());

56
Texconv/texconv.cpp
View File

@ -839,9 +839,9 @@ namespace
wprintf(L"Microsoft (R) DirectX Texture Converter [DirectXTex] Version %ls\n", version); wprintf(L"Microsoft (R) DirectX Texture Converter [DirectXTex] Version %ls\n", version);
wprintf(L"Copyright (C) Microsoft Corp.\n"); wprintf(L"Copyright (C) Microsoft Corp.\n");
#ifdef _DEBUG #ifdef _DEBUG
wprintf(L"*** Debug build ***\n"); wprintf(L"*** Debug build ***\n");
#endif #endif
wprintf(L"\n"); wprintf(L"\n");
} }
@ -928,9 +928,9 @@ namespace
wprintf(L" -wicmulti When writing images with WIC encode multiframe images\n"); wprintf(L" -wicmulti When writing images with WIC encode multiframe images\n");
wprintf(L"\n -nologo suppress copyright message\n"); wprintf(L"\n -nologo suppress copyright message\n");
wprintf(L" -timing Display elapsed processing time\n\n"); wprintf(L" -timing Display elapsed processing time\n\n");
#ifdef _OPENMP #ifdef _OPENMP
wprintf(L" -singleproc Do not use multi-threaded compression\n"); wprintf(L" -singleproc Do not use multi-threaded compression\n");
#endif #endif
wprintf(L" -gpu <adapter> Select GPU for DirectCompute-based codecs (0 is default)\n"); wprintf(L" -gpu <adapter> Select GPU for DirectCompute-based codecs (0 is default)\n");
wprintf(L" -nogpu Do not use DirectCompute-based codecs\n"); wprintf(L" -nogpu Do not use DirectCompute-based codecs\n");
wprintf( wprintf(
@ -1043,9 +1043,9 @@ namespace
}; };
UINT createDeviceFlags = 0; UINT createDeviceFlags = 0;
#ifdef _DEBUG #ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif #endif
ComPtr<IDXGIAdapter> pAdapter; ComPtr<IDXGIAdapter> pAdapter;
if (adapter >= 0) if (adapter >= 0)
@ -2088,7 +2088,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
continue; continue;
} }
} }
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
else if (_wcsicmp(ext, L".exr") == 0) else if (_wcsicmp(ext, L".exr") == 0)
{ {
hr = LoadFromEXRFile(pConv->szSrc, &info, *image); hr = LoadFromEXRFile(pConv->szSrc, &info, *image);
@ -2099,7 +2099,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
continue; continue;
} }
} }
#endif #endif
else else
{ {
// WIC shares the same filter values for mode and dither // WIC shares the same filter values for mode and dither
@ -2489,9 +2489,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -2526,9 +2526,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(tinfo.format == DXGI_FORMAT_R16G16B16A16_FLOAT); assert(tinfo.format == DXGI_FORMAT_R16G16B16A16_FLOAT);
info.format = DXGI_FORMAT_R16G16B16A16_FLOAT; info.format = DXGI_FORMAT_R16G16B16A16_FLOAT;
@ -2759,9 +2759,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -2839,9 +2839,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -2986,9 +2986,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -3035,9 +3035,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -3096,9 +3096,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
return 1; return 1;
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -3298,9 +3298,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
} }
} }
#ifndef NDEBUG #ifndef NDEBUG
auto& tinfo = timage->GetMetadata(); auto& tinfo = timage->GetMetadata();
#endif #endif
assert(info.width == tinfo.width); assert(info.width == tinfo.width);
assert(info.height == tinfo.height); assert(info.height == tinfo.height);
@ -3435,12 +3435,12 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
} }
TEX_COMPRESS_FLAGS cflags = dwCompress; TEX_COMPRESS_FLAGS cflags = dwCompress;
#ifdef _OPENMP #ifdef _OPENMP
if (!(dwOptions & (uint64_t(1) << OPT_FORCE_SINGLEPROC))) if (!(dwOptions & (uint64_t(1) << OPT_FORCE_SINGLEPROC)))
{ {
cflags |= TEX_COMPRESS_PARALLEL; cflags |= TEX_COMPRESS_PARALLEL;
} }
#endif #endif
if ((img->width % 4) != 0 || (img->height % 4) != 0) if ((img->width % 4) != 0 || (img->height % 4) != 0)
{ {
@ -3623,11 +3623,11 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
hr = SaveToPortablePixMapHDR(img[0], szDest); hr = SaveToPortablePixMapHDR(img[0], szDest);
break; break;
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
case CODEC_EXR: case CODEC_EXR:
hr = SaveToEXRFile(img[0], szDest); hr = SaveToEXRFile(img[0], szDest);
break; break;
#endif #endif
default: default:
{ {

14
Texdiag/texdiag.cpp
View File

@ -644,9 +644,9 @@ namespace
wprintf(L"Microsoft (R) DirectX Texture Diagnostic Tool [DirectXTex] Version %ls\n", version); wprintf(L"Microsoft (R) DirectX Texture Diagnostic Tool [DirectXTex] Version %ls\n", version);
wprintf(L"Copyright (C) Microsoft Corp.\n"); wprintf(L"Copyright (C) Microsoft Corp.\n");
#ifdef _DEBUG #ifdef _DEBUG
wprintf(L"*** Debug build ***\n"); wprintf(L"*** Debug build ***\n");
#endif #endif
wprintf(L"\n"); wprintf(L"\n");
} }
@ -782,12 +782,12 @@ namespace
{ {
return LoadFromHDRFile(fileName, &info, *image); return LoadFromHDRFile(fileName, &info, *image);
} }
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
else if (_wcsicmp(ext, L".exr") == 0) else if (_wcsicmp(ext, L".exr") == 0)
{ {
return LoadFromEXRFile(fileName, &info, *image); return LoadFromEXRFile(fileName, &info, *image);
} }
#endif #endif
else else
{ {
// WIC shares the same filter values for mode and dither // WIC shares the same filter values for mode and dither
@ -827,10 +827,10 @@ namespace
case CODEC_HDR: case CODEC_HDR:
return SaveToHDRFile(*image, fileName); return SaveToHDRFile(*image, fileName);
#ifdef USE_OPENEXR #ifdef USE_OPENEXR
case CODEC_EXR: case CODEC_EXR:
return SaveToEXRFile(*image, fileName); return SaveToEXRFile(*image, fileName);
#endif #endif
default: default:
return SaveToWICFile(*image, WIC_FLAGS_NONE, GetWICCodec(static_cast<WICCodecs>(codec)), fileName); return SaveToWICFile(*image, WIC_FLAGS_NONE, GetWICCodec(static_cast<WICCodecs>(codec)), fileName);
@ -1492,6 +1492,7 @@ namespace
return Convert(diffImage.GetImages(), diffImage.GetImageCount(), diffImage.GetMetadata(), format, dwFilter, TEX_THRESHOLD_DEFAULT, result); return Convert(diffImage.GetImages(), diffImage.GetImageCount(), diffImage.GetMetadata(), format, dwFilter, TEX_THRESHOLD_DEFAULT, result);
} }
#pragma region DumpBC
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// Partition, Shape, Fixup // Partition, Shape, Fixup
const uint8_t g_aFixUp[3][64][3] = const uint8_t g_aFixUp[3][64][3] =
@ -3209,6 +3210,7 @@ namespace
return S_OK; return S_OK;
} }
#pragma endregion
} }

32
WICTextureLoader/WICTextureLoader11.cpp
View File

@ -65,12 +65,12 @@ namespace
template<UINT TNameLength> template<UINT TNameLength>
inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_ const char(&name)[TNameLength]) noexcept inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_ const char(&name)[TNameLength]) noexcept
{ {
#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name); resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name);
#else #else
UNREFERENCED_PARAMETER(resource); UNREFERENCED_PARAMETER(resource);
UNREFERENCED_PARAMETER(name); UNREFERENCED_PARAMETER(name);
#endif #endif
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@ -116,7 +116,7 @@ namespace
const GUID& target; const GUID& target;
}; };
constexpr WICConvert g_WICConvert [] = constexpr WICConvert g_WICConvert[] =
{ {
// Note target GUID in this conversion table must be one of those directly supported formats (above). // Note target GUID in this conversion table must be one of those directly supported formats (above).
@ -180,7 +180,7 @@ namespace
BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID *ifactory) noexcept BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID *ifactory) noexcept
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
HRESULT hr = CoCreateInstance( HRESULT hr = CoCreateInstance(
CLSID_WICImagingFactory2, CLSID_WICImagingFactory2,
nullptr, nullptr,
@ -206,14 +206,14 @@ namespace
); );
return SUCCEEDED(hr) ? TRUE : FALSE; return SUCCEEDED(hr) ? TRUE : FALSE;
} }
#else #else
return SUCCEEDED(CoCreateInstance( return SUCCEEDED(CoCreateInstance(
CLSID_WICImagingFactory, CLSID_WICImagingFactory,
nullptr, nullptr,
CLSCTX_INPROC_SERVER, CLSCTX_INPROC_SERVER,
__uuidof(IWICImagingFactory), __uuidof(IWICImagingFactory),
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
#endif #endif
} }
IWICImagingFactory* GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept
@ -242,13 +242,13 @@ namespace
return g_WICFormats[i].format; return g_WICFormats[i].format;
} }
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
if (g_WIC2) if (g_WIC2)
{ {
if (memcmp(&GUID_WICPixelFormat96bppRGBFloat, &guid, sizeof(GUID)) == 0) if (memcmp(&GUID_WICPixelFormat96bppRGBFloat, &guid, sizeof(GUID)) == 0)
return DXGI_FORMAT_R32G32B32_FLOAT; return DXGI_FORMAT_R32G32B32_FLOAT;
} }
#endif #endif
return DXGI_FORMAT_UNKNOWN; return DXGI_FORMAT_UNKNOWN;
} }
@ -454,7 +454,7 @@ namespace
{ {
if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0) if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
if (g_WIC2) if (g_WIC2)
{ {
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID));
@ -462,7 +462,7 @@ namespace
bpp = 96; bpp = 96;
} }
else else
#endif #endif
{ {
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID));
format = DXGI_FORMAT_R32G32B32A32_FLOAT; format = DXGI_FORMAT_R32G32B32A32_FLOAT;
@ -493,7 +493,7 @@ namespace
bpp = WICBitsPerPixel(pixelFormat); bpp = WICBitsPerPixel(pixelFormat);
} }
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
if ((format == DXGI_FORMAT_R32G32B32_FLOAT) && d3dContext && textureView) if ((format == DXGI_FORMAT_R32G32B32_FLOAT) && d3dContext && textureView)
{ {
// Special case test for optional device support for autogen mipchains for R32G32B32_FLOAT // Special case test for optional device support for autogen mipchains for R32G32B32_FLOAT
@ -507,7 +507,7 @@ namespace
bpp = 128; bpp = 128;
} }
} }
#endif #endif
if (loadFlags & WIC_LOADER_FORCE_RGBA32) if (loadFlags & WIC_LOADER_FORCE_RGBA32)
{ {
@ -773,7 +773,7 @@ namespace
_In_opt_ ID3D11Resource** texture, _In_opt_ ID3D11Resource** texture,
_In_opt_ ID3D11ShaderResourceView** textureView) noexcept _In_opt_ ID3D11ShaderResourceView** textureView) noexcept
{ {
#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
if (texture || textureView) if (texture || textureView)
{ {
CHAR strFileA[MAX_PATH]; CHAR strFileA[MAX_PATH];
@ -815,11 +815,11 @@ namespace
} }
} }
} }
#else #else
UNREFERENCED_PARAMETER(fileName); UNREFERENCED_PARAMETER(fileName);
UNREFERENCED_PARAMETER(texture); UNREFERENCED_PARAMETER(texture);
UNREFERENCED_PARAMETER(textureView); UNREFERENCED_PARAMETER(textureView);
#endif #endif
} }
} // anonymous namespace } // anonymous namespace

8
WICTextureLoader/WICTextureLoader12.cpp
View File

@ -107,7 +107,7 @@ namespace
const GUID& target; const GUID& target;
}; };
constexpr WICConvert g_WICConvert [] = constexpr WICConvert g_WICConvert[] =
{ {
// Note target GUID in this conversion table must be one of those directly supported formats (above). // Note target GUID in this conversion table must be one of those directly supported formats (above).
@ -634,7 +634,7 @@ namespace
_In_z_ const wchar_t* fileName, _In_z_ const wchar_t* fileName,
_In_ ID3D12Resource** texture) noexcept _In_ ID3D12Resource** texture) noexcept
{ {
#if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) #if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
if (texture && *texture) if (texture && *texture)
{ {
const wchar_t* pstrName = wcsrchr(fileName, '\\'); const wchar_t* pstrName = wcsrchr(fileName, '\\');
@ -649,10 +649,10 @@ namespace
(*texture)->SetName(pstrName); (*texture)->SetName(pstrName);
} }
#else #else
UNREFERENCED_PARAMETER(fileName); UNREFERENCED_PARAMETER(fileName);
UNREFERENCED_PARAMETER(texture); UNREFERENCED_PARAMETER(texture);
#endif #endif
} }
} // anonymous namespace } // anonymous namespace

8
WICTextureLoader/WICTextureLoader9.cpp
View File

@ -95,7 +95,7 @@ namespace
const GUID& target; const GUID& target;
}; };
constexpr WICConvert g_WICConvert [] = constexpr WICConvert g_WICConvert[] =
{ {
// Note target GUID in this conversion table must be one of those directly supported formats (above). // Note target GUID in this conversion table must be one of those directly supported formats (above).
@ -161,7 +161,7 @@ namespace
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept
{ {
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
HRESULT hr = CoCreateInstance( HRESULT hr = CoCreateInstance(
CLSID_WICImagingFactory2, CLSID_WICImagingFactory2,
nullptr, nullptr,
@ -187,14 +187,14 @@ namespace
); );
return SUCCEEDED(hr) ? TRUE : FALSE; return SUCCEEDED(hr) ? TRUE : FALSE;
} }
#else #else
return SUCCEEDED(CoCreateInstance( return SUCCEEDED(CoCreateInstance(
CLSID_WICImagingFactory, CLSID_WICImagingFactory,
nullptr, nullptr,
CLSCTX_INPROC_SERVER, CLSCTX_INPROC_SERVER,
__uuidof(IWICImagingFactory), __uuidof(IWICImagingFactory),
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
#endif #endif
} }
IWICImagingFactory* GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept