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

Resync DDSTextureLoader, WICTextureLoader

Browse Source
This commit is contained in:
Chuck Walbourn 2016-09-22 22:34:50 -07:00
parent d74689c111
commit 2f31eb519c
8 changed files with 1020 additions and 1020 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1028
DDSTextureLoader/DDSTextureLoader.cpp
View File

File diff suppressed because it is too large Load Diff

2
DDSTextureLoader/DDSTextureLoader.h
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------------
// File: DDSTextureLoader.h
//
// Functions for loading a DDS texture and creating a Direct3D 11 runtime resource for it
// Functions for loading a DDS texture and creating a Direct3D runtime resource for it
//
// Note these functions are useful as a light-weight runtime loader for DDS files. For
// a full-featured DDS file reader, writer, and texture processing pipeline see

236
DDSTextureLoader/DDSTextureLoader12.cpp
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------------
// File: DDSTextureLoader12.cpp
//
// Functions for loading a DDS texture and creating a Direct3D 12 runtime resource for it
// Functions for loading a DDS texture and creating a Direct3D runtime resource for it
//
// Note these functions are useful as a light-weight runtime loader for DDS files. For
// a full-featured DDS file reader, writer, and texture processing pipeline see
@ -155,8 +155,8 @@ namespace
HRESULT LoadTextureDataFromFile(
_In_z_ const wchar_t* fileName,
std::unique_ptr<uint8_t[]>& ddsData,
DDS_HEADER** header,
uint8_t** bitData,
const DDS_HEADER** header,
const uint8_t** bitData,
size_t* bitSize)
{
if (!header || !bitData || !bitSize)
@ -165,22 +165,22 @@ namespace
}
// open the file
ScopedHandle hFile( safe_handle( CreateFile2( fileName,
GENERIC_READ,
FILE_SHARE_READ,
OPEN_EXISTING,
nullptr ) ) );
ScopedHandle hFile(safe_handle(CreateFile2(fileName,
GENERIC_READ,
FILE_SHARE_READ,
OPEN_EXISTING,
nullptr)));
if ( !hFile )
if (!hFile)
{
return HRESULT_FROM_WIN32( GetLastError() );
return HRESULT_FROM_WIN32(GetLastError());
}
// Get the file size
FILE_STANDARD_INFO fileInfo;
if ( !GetFileInformationByHandleEx( hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo) ) )
if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
{
return HRESULT_FROM_WIN32( GetLastError() );
return HRESULT_FROM_WIN32(GetLastError());
}
// File is too big for 32-bit allocation, so reject read
@ -190,13 +190,13 @@ namespace
}
// Need at least enough data to fill the header and magic number to be a valid DDS
if (fileInfo.EndOfFile.LowPart < ( sizeof(DDS_HEADER) + sizeof(uint32_t) ) )
if (fileInfo.EndOfFile.LowPart < (sizeof(DDS_HEADER) + sizeof(uint32_t)))
{
return E_FAIL;
}
// create enough space for the file data
ddsData.reset( new (std::nothrow) uint8_t[fileInfo.EndOfFile.LowPart ] );
ddsData.reset(new (std::nothrow) uint8_t[fileInfo.EndOfFile.LowPart]);
if (!ddsData)
{
return E_OUTOFMEMORY;
@ -204,14 +204,14 @@ namespace
// read the data in
DWORD BytesRead = 0;
if (!ReadFile( hFile.get(),
ddsData.get(),
fileInfo.EndOfFile.LowPart,
&BytesRead,
nullptr
))
if (!ReadFile(hFile.get(),
ddsData.get(),
fileInfo.EndOfFile.LowPart,
&BytesRead,
nullptr
))
{
return HRESULT_FROM_WIN32( GetLastError() );
return HRESULT_FROM_WIN32(GetLastError());
}
if (BytesRead < fileInfo.EndOfFile.LowPart)
@ -220,13 +220,13 @@ namespace
}
// DDS files always start with the same magic number ("DDS ")
uint32_t dwMagicNumber = *( const uint32_t* )( ddsData.get() );
uint32_t dwMagicNumber = *reinterpret_cast<const uint32_t*>(ddsData.get());
if (dwMagicNumber != DDS_MAGIC)
{
return E_FAIL;
}
auto hdr = reinterpret_cast<DDS_HEADER*>( ddsData.get() + sizeof( uint32_t ) );
auto hdr = reinterpret_cast<const DDS_HEADER*>(ddsData.get() + sizeof(uint32_t));
// Verify header to validate DDS file
if (hdr->size != sizeof(DDS_HEADER) ||
@ -238,10 +238,10 @@ namespace
// Check for DX10 extension
bool bDXT10Header = false;
if ((hdr->ddspf.flags & DDS_FOURCC) &&
(MAKEFOURCC( 'D', 'X', '1', '0' ) == hdr->ddspf.fourCC))
(MAKEFOURCC('D', 'X', '1', '0') == hdr->ddspf.fourCC))
{
// Must be long enough for both headers and magic value
if (fileInfo.EndOfFile.LowPart < ( sizeof(DDS_HEADER) + sizeof(uint32_t) + sizeof(DDS_HEADER_DXT10) ) )
if (fileInfo.EndOfFile.LowPart < (sizeof(DDS_HEADER) + sizeof(uint32_t) + sizeof(DDS_HEADER_DXT10)))
{
return E_FAIL;
}
@ -251,8 +251,8 @@ namespace
// setup the pointers in the process request
*header = hdr;
ptrdiff_t offset = sizeof( uint32_t ) + sizeof( DDS_HEADER )
+ (bDXT10Header ? sizeof( DDS_HEADER_DXT10 ) : 0);
ptrdiff_t offset = sizeof(uint32_t) + sizeof(DDS_HEADER)
+ (bDXT10Header ? sizeof(DDS_HEADER_DXT10) : 0);
*bitData = ddsData.get() + offset;
*bitSize = fileInfo.EndOfFile.LowPart - offset;
@ -914,15 +914,15 @@ namespace
//--------------------------------------------------------------------------------------
HRESULT CreateTextureResource(
_In_ ID3D12Device* d3dDevice,
_In_ D3D12_RESOURCE_DIMENSION resDim,
_In_ size_t width,
_In_ size_t height,
_In_ size_t depth,
_In_ size_t mipCount,
_In_ size_t arraySize,
_In_ DXGI_FORMAT format,
_In_ D3D12_RESOURCE_FLAGS flags,
_In_ bool forceSRGB,
D3D12_RESOURCE_DIMENSION resDim,
size_t width,
size_t height,
size_t depth,
size_t mipCount,
size_t arraySize,
DXGI_FORMAT format,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture)
{
if (!d3dDevice)
@ -930,7 +930,7 @@ namespace
HRESULT hr = E_FAIL;
if (forceSRGB)
if (loadFlags & DDS_LOADER_FORCE_SRGB)
{
format = MakeSRGB(format);
}
@ -941,7 +941,7 @@ namespace
desc.MipLevels = static_cast<UINT16>(mipCount);
desc.DepthOrArraySize = (resDim == D3D12_RESOURCE_DIMENSION_TEXTURE3D) ? static_cast<UINT16>(depth) : static_cast<UINT16>(arraySize);
desc.Format = format;
desc.Flags = flags;
desc.Flags = resFlags;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Dimension = resDim;
@ -969,13 +969,12 @@ namespace
HRESULT CreateTextureFromDDS(_In_ ID3D12Device* d3dDevice,
_In_ const DDS_HEADER* header,
_In_reads_bytes_(bitSize) const uint8_t* bitData,
_In_ size_t bitSize,
_In_ size_t maxsize,
_In_ D3D12_RESOURCE_FLAGS flags,
_In_ bool forceSRGB,
_In_ bool reserveFullMipChain,
size_t bitSize,
size_t maxsize,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
_Out_ std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
_Out_opt_ bool* outIsCubeMap)
{
HRESULT hr = S_OK;
@ -1165,13 +1164,13 @@ namespace
if (SUCCEEDED(hr))
{
size_t reservedMips = mipCount;
if (reserveFullMipChain)
if (loadFlags & DDS_LOADER_MIP_RESERVE)
{
reservedMips = std::min<size_t>(D3D12_REQ_MIP_LEVELS, CountMips(width, height));
}
hr = CreateTextureResource(d3dDevice, resDim, twidth, theight, tdepth, reservedMips - skipMip, arraySize,
format, flags, forceSRGB, texture);
format, resFlags, loadFlags, texture);
if (FAILED(hr) && !maxsize && (mipCount > 1))
{
@ -1184,7 +1183,7 @@ namespace
if (SUCCEEDED(hr))
{
hr = CreateTextureResource(d3dDevice, resDim, twidth, theight, tdepth, mipCount - skipMip, arraySize,
format, flags, forceSRGB, texture);
format, resFlags, loadFlags, texture);
}
}
}
@ -1224,7 +1223,6 @@ namespace
return DDS_ALPHA_MODE_UNKNOWN;
}
} // anonymous namespace
@ -1241,43 +1239,41 @@ HRESULT DirectX::LoadDDSTextureFromMemory(
bool* isCubeMap)
{
return LoadDDSTextureFromMemoryEx(
d3dDevice,
ddsData,
ddsDataSize,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
false,
false,
texture,
subresources,
d3dDevice,
ddsData,
ddsDataSize,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
DDS_LOADER_DEFAULT,
texture,
subresources,
alphaMode,
isCubeMap);
}
_Use_decl_annotations_
HRESULT DirectX::LoadDDSTextureFromMemoryEx(
HRESULT DirectX::LoadDDSTextureFromMemoryEx(
ID3D12Device* d3dDevice,
const uint8_t* ddsData,
size_t ddsDataSize,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
ID3D12Resource** texture,
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
DDS_ALPHA_MODE* alphaMode,
bool* isCubeMap )
bool* isCubeMap)
{
if ( texture )
if (texture)
{
*texture = nullptr;
}
if ( alphaMode )
if (alphaMode)
{
*alphaMode = DDS_ALPHA_MODE_UNKNOWN;
}
if ( isCubeMap )
if (isCubeMap)
{
*isCubeMap = false;
}
@ -1293,13 +1289,13 @@ HRESULT DirectX::LoadDDSTextureFromMemoryEx(
return E_FAIL;
}
uint32_t dwMagicNumber = *( const uint32_t* )( ddsData );
uint32_t dwMagicNumber = *(const uint32_t*)(ddsData);
if (dwMagicNumber != DDS_MAGIC)
{
return E_FAIL;
}
auto header = reinterpret_cast<const DDS_HEADER*>( ddsData + sizeof( uint32_t ) );
auto header = reinterpret_cast<const DDS_HEADER*>(ddsData + sizeof(uint32_t));
// Verify header to validate DDS file
if (header->size != sizeof(DDS_HEADER) ||
@ -1311,7 +1307,7 @@ HRESULT DirectX::LoadDDSTextureFromMemoryEx(
// Check for DX10 extension
bool bDXT10Header = false;
if ((header->ddspf.flags & DDS_FOURCC) &&
(MAKEFOURCC( 'D', 'X', '1', '0' ) == header->ddspf.fourCC) )
(MAKEFOURCC('D', 'X', '1', '0') == header->ddspf.fourCC))
{
// Must be long enough for both headers and magic value
if (ddsDataSize < (sizeof(DDS_HEADER) + sizeof(uint32_t) + sizeof(DDS_HEADER_DXT10)))
@ -1322,23 +1318,23 @@ HRESULT DirectX::LoadDDSTextureFromMemoryEx(
bDXT10Header = true;
}
ptrdiff_t offset = sizeof( uint32_t )
+ sizeof( DDS_HEADER )
+ (bDXT10Header ? sizeof( DDS_HEADER_DXT10 ) : 0);
ptrdiff_t offset = sizeof(uint32_t)
+ sizeof(DDS_HEADER)
+ (bDXT10Header ? sizeof(DDS_HEADER_DXT10) : 0);
HRESULT hr = CreateTextureFromDDS( d3dDevice,
header, ddsData + offset, ddsDataSize - offset, maxsize,
flags, forceSRGB, reserveFullMipChain,
texture, subresources, isCubeMap );
if ( SUCCEEDED(hr) )
HRESULT hr = CreateTextureFromDDS(d3dDevice,
header, ddsData + offset, ddsDataSize - offset, maxsize,
resFlags, loadFlags,
texture, subresources, isCubeMap);
if (SUCCEEDED(hr))
{
if (texture != 0 && *texture != 0)
{
SetDebugObjectName(*texture, L"DDSTextureLoader");
}
if ( alphaMode )
*alphaMode = GetAlphaMode( header );
if (alphaMode)
*alphaMode = GetAlphaMode(header);
}
return hr;
@ -1347,7 +1343,7 @@ HRESULT DirectX::LoadDDSTextureFromMemoryEx(
//--------------------------------------------------------------------------------------
_Use_decl_annotations_
HRESULT DirectX::LoadDDSTextureFromFile(
HRESULT DirectX::LoadDDSTextureFromFile(
ID3D12Device* d3dDevice,
const wchar_t* fileName,
ID3D12Resource** texture,
@ -1355,20 +1351,19 @@ HRESULT DirectX::LoadDDSTextureFromFile(
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
size_t maxsize,
DDS_ALPHA_MODE* alphaMode,
bool* isCubeMap )
bool* isCubeMap)
{
return LoadDDSTextureFromFileEx(
d3dDevice,
fileName,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
false,
false,
return LoadDDSTextureFromFileEx(
d3dDevice,
fileName,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
DDS_LOADER_DEFAULT,
texture,
ddsData,
subresources,
subresources,
alphaMode,
isCubeMap );
isCubeMap);
}
_Use_decl_annotations_
@ -1376,24 +1371,23 @@ HRESULT DirectX::LoadDDSTextureFromFileEx(
ID3D12Device* d3dDevice,
const wchar_t* fileName,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& ddsData,
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
DDS_ALPHA_MODE* alphaMode,
bool* isCubeMap )
bool* isCubeMap)
{
if ( texture )
if (texture)
{
*texture = nullptr;
}
if ( alphaMode )
if (alphaMode)
{
*alphaMode = DDS_ALPHA_MODE_UNKNOWN;
}
if ( isCubeMap )
if (isCubeMap)
{
*isCubeMap = false;
}
@ -1403,42 +1397,42 @@ HRESULT DirectX::LoadDDSTextureFromFileEx(
return E_INVALIDARG;
}
DDS_HEADER* header = nullptr;
uint8_t* bitData = nullptr;
const DDS_HEADER* header = nullptr;
const uint8_t* bitData = nullptr;
size_t bitSize = 0;
HRESULT hr = LoadTextureDataFromFile( fileName,
ddsData,
&header,
&bitData,
&bitSize
);
HRESULT hr = LoadTextureDataFromFile(fileName,
ddsData,
&header,
&bitData,
&bitSize
);
if (FAILED(hr))
{
return hr;
}
hr = CreateTextureFromDDS( d3dDevice,
header, bitData, bitSize, maxsize,
flags, forceSRGB, reserveFullMipChain,
texture, subresources, isCubeMap );
hr = CreateTextureFromDDS(d3dDevice,
header, bitData, bitSize, maxsize,
resFlags, loadFlags,
texture, subresources, isCubeMap);
if ( SUCCEEDED(hr) )
if (SUCCEEDED(hr))
{
#if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
if (texture != 0)
{
CHAR strFileA[MAX_PATH];
int result = WideCharToMultiByte( CP_ACP,
WC_NO_BEST_FIT_CHARS,
fileName,
-1,
strFileA,
MAX_PATH,
nullptr,
FALSE
);
if ( result > 0 )
int result = WideCharToMultiByte(CP_ACP,
WC_NO_BEST_FIT_CHARS,
fileName,
-1,
strFileA,
MAX_PATH,
nullptr,
FALSE
);
if (result > 0)
{
const wchar_t* pstrName = wcsrchr(fileName, '\\');
if (!pstrName)
@ -1458,8 +1452,8 @@ HRESULT DirectX::LoadDDSTextureFromFileEx(
}
#endif
if ( alphaMode )
*alphaMode = GetAlphaMode( header );
if (alphaMode)
*alphaMode = GetAlphaMode(header);
}
return hr;

19
DDSTextureLoader/DDSTextureLoader12.h
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------------
// File: DDSTextureLoader12.h
//
// Functions for loading a DDS texture and creating a Direct3D 12 runtime resource for it
// Functions for loading a DDS texture and creating a Direct3D runtime resource for it
//
// Note these functions are useful as a light-weight runtime loader for DDS files. For
// a full-featured DDS file reader, writer, and texture processing pipeline see
@ -38,6 +38,13 @@ namespace DirectX
DDS_ALPHA_MODE_CUSTOM = 4,
};
enum DDS_LOADER_FLAGS
{
DDS_LOADER_DEFAULT = 0,
DDS_LOADER_FORCE_SRGB = 0x1,
DDS_LOADER_MIP_RESERVE = 0x8,
};
// Standard version
HRESULT __cdecl LoadDDSTextureFromMemory(
_In_ ID3D12Device* d3dDevice,
@ -65,9 +72,8 @@ namespace DirectX
_In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
size_t ddsDataSize,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,
_Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr,
@ -77,9 +83,8 @@ namespace DirectX
_In_ ID3D12Device* d3dDevice,
_In_z_ const wchar_t* szFileName,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& ddsData,
std::vector<D3D12_SUBRESOURCE_DATA>& subresources,

634
WICTextureLoader/WICTextureLoader.cpp
View File

File diff suppressed because it is too large Load Diff

67
WICTextureLoader/WICTextureLoader.h
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------------
// File: WICTextureLoader.h
//
// Function for loading a WIC image and creating a Direct3D 11 runtime texture for it
// Function for loading a WIC image and creating a Direct3D runtime texture for it
// (auto-generating mipmaps if possible)
//
// Note: Assumes application has already called CoInitializeEx
@ -33,23 +33,28 @@
namespace DirectX
{
enum WIC_LOADER_FLAGS
{
WIC_LOADER_DEFAULT = 0,
WIC_LOADER_FORCE_SRGB = 0x1,
WIC_LOADER_IGNORE_SRGB = 0x2,
};
// Standard version
HRESULT CreateWICTextureFromMemory(
_In_ ID3D11Device* d3dDevice,
_In_reads_bytes_(wicDataSize) const uint8_t* wicData,
_In_ size_t wicDataSize,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0
);
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0);
HRESULT CreateWICTextureFromFile(
_In_ ID3D11Device* d3dDevice,
_In_z_ const wchar_t* szFileName,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0
);
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0);
// Standard version with optional auto-gen mipmap support
HRESULT CreateWICTextureFromMemory(
@ -57,19 +62,17 @@ namespace DirectX
_In_opt_ ID3D11DeviceContext* d3dContext,
_In_reads_bytes_(wicDataSize) const uint8_t* wicData,
_In_ size_t wicDataSize,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0
);
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0);
HRESULT CreateWICTextureFromFile(
_In_ ID3D11Device* d3dDevice,
_In_opt_ ID3D11DeviceContext* d3dContext,
_In_z_ const wchar_t* szFileName,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0
);
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView,
_In_ size_t maxsize = 0);
// Extended version
HRESULT CreateWICTextureFromMemoryEx(
@ -77,14 +80,13 @@ namespace DirectX
_In_reads_bytes_(wicDataSize) const uint8_t* wicData,
_In_ size_t wicDataSize,
_In_ size_t maxsize,
D3D11_USAGE usage,
_In_ D3D11_USAGE usage,
_In_ unsigned int bindFlags,
_In_ unsigned int cpuAccessFlags,
_In_ unsigned int miscFlags,
_In_ bool forceSRGB,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView
);
_In_ unsigned int loadFlags,
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView);
HRESULT CreateWICTextureFromFileEx(
_In_ ID3D11Device* d3dDevice,
@ -94,10 +96,9 @@ namespace DirectX
_In_ unsigned int bindFlags,
_In_ unsigned int cpuAccessFlags,
_In_ unsigned int miscFlags,
_In_ bool forceSRGB,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView
);
_In_ unsigned int loadFlags,
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView);
// Extended version with optional auto-gen mipmap support
HRESULT CreateWICTextureFromMemoryEx(
@ -110,10 +111,9 @@ namespace DirectX
_In_ unsigned int bindFlags,
_In_ unsigned int cpuAccessFlags,
_In_ unsigned int miscFlags,
_In_ bool forceSRGB,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView
);
_In_ unsigned int loadFlags,
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView);
HRESULT CreateWICTextureFromFileEx(
_In_ ID3D11Device* d3dDevice,
@ -124,8 +124,7 @@ namespace DirectX
_In_ unsigned int bindFlags,
_In_ unsigned int cpuAccessFlags,
_In_ unsigned int miscFlags,
_In_ bool forceSRGB,
_Out_opt_ ID3D11Resource** texture,
_Out_opt_ ID3D11ShaderResourceView** textureView
);
_In_ unsigned int loadFlags,
_Outptr_opt_ ID3D11Resource** texture,
_Outptr_opt_ ID3D11ShaderResourceView** textureView);
}

33
WICTextureLoader/WICTextureLoader12.cpp
View File

@ -269,9 +269,8 @@ namespace
HRESULT CreateTextureFromWIC(_In_ ID3D12Device* d3dDevice,
_In_ IWICBitmapFrameDecode *frame,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& decodedData,
D3D12_SUBRESOURCE_DATA& subresource)
@ -351,11 +350,11 @@ namespace
return E_FAIL;
// Handle sRGB formats
if (forceSRGB)
if (loadFlags & WIC_LOADER_FORCE_SRGB)
{
format = MakeSRGB(format);
}
else
else if (!(loadFlags & WIC_LOADER_IGNORE_SRGB))
{
ComPtr<IWICMetadataQueryReader> metareader;
if (SUCCEEDED(frame->GetMetadataQueryReader(metareader.GetAddressOf())))
@ -488,7 +487,7 @@ namespace
}
// Count the number of mips
uint32_t mipCount = (reserveFullMipChain) ? CountMips(twidth, theight) : 1;
uint32_t mipCount = (loadFlags & (WIC_LOADER_MIP_AUTOGEN | WIC_LOADER_MIP_RESERVE)) ? CountMips(twidth, theight) : 1;
// Create texture
D3D12_RESOURCE_DESC desc = {};
@ -499,7 +498,7 @@ namespace
desc.Format = format;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Flags = flags;
desc.Flags = resFlags;
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
CD3DX12_HEAP_PROPERTIES defaultHeapProperties(D3D12_HEAP_TYPE_DEFAULT);
@ -547,8 +546,7 @@ HRESULT DirectX::LoadWICTextureFromMemory(
wicDataSize,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
false,
false,
WIC_LOADER_DEFAULT,
texture,
decodedData,
subresource);
@ -562,9 +560,8 @@ HRESULT DirectX::LoadWICTextureFromMemoryEx(
const uint8_t* wicData,
size_t wicDataSize,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& decodedData,
D3D12_SUBRESOURCE_DATA& subresource)
@ -610,7 +607,7 @@ HRESULT DirectX::LoadWICTextureFromMemoryEx(
hr = CreateTextureFromWIC( d3dDevice,
frame.Get(), maxsize,
flags, forceSRGB, reserveFullMipChain,
resFlags, loadFlags,
texture, decodedData, subresource);
if ( FAILED(hr))
return hr;
@ -637,8 +634,7 @@ HRESULT DirectX::LoadWICTextureFromFile(
fileName,
maxsize,
D3D12_RESOURCE_FLAG_NONE,
false,
false,
WIC_LOADER_DEFAULT,
texture,
wicData,
subresource);
@ -651,9 +647,8 @@ HRESULT DirectX::LoadWICTextureFromFileEx(
ID3D12Device* d3dDevice,
const wchar_t* fileName,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& decodedData,
D3D12_SUBRESOURCE_DATA& subresource)
@ -682,7 +677,7 @@ HRESULT DirectX::LoadWICTextureFromFileEx(
return hr;
hr = CreateTextureFromWIC( d3dDevice, frame.Get(), maxsize,
flags, forceSRGB, reserveFullMipChain,
resFlags, loadFlags,
texture, decodedData, subresource );
#if !defined(NO_D3D12_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )

21
WICTextureLoader/WICTextureLoader12.h
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------------
// File: WICTextureLoader12.h
//
// Function for loading a WIC image and creating a Direct3D 12 runtime texture for it
// Function for loading a WIC image and creating a Direct3D runtime texture for it
// (auto-generating mipmaps if possible)
//
// Note: Assumes application has already called CoInitializeEx
@ -31,6 +31,15 @@
namespace DirectX
{
enum WIC_LOADER_FLAGS
{
WIC_LOADER_DEFAULT = 0,
WIC_LOADER_FORCE_SRGB = 0x1,
WIC_LOADER_IGNORE_SRGB = 0x2,
WIC_LOADER_MIP_AUTOGEN = 0x4,
WIC_LOADER_MIP_RESERVE = 0x8,
};
// Standard version
HRESULT __cdecl LoadWICTextureFromMemory(
_In_ ID3D12Device* d3dDevice,
@ -55,9 +64,8 @@ namespace DirectX
_In_reads_bytes_(wicDataSize) const uint8_t* wicData,
size_t wicDataSize,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& decodedData,
D3D12_SUBRESOURCE_DATA& subresource);
@ -66,9 +74,8 @@ namespace DirectX
_In_ ID3D12Device* d3dDevice,
_In_z_ const wchar_t* szFileName,
size_t maxsize,
D3D12_RESOURCE_FLAGS flags,
bool forceSRGB,
bool reserveFullMipChain,
D3D12_RESOURCE_FLAGS resFlags,
unsigned int loadFlags,
_Outptr_ ID3D12Resource** texture,
std::unique_ptr<uint8_t[]>& decodedData,
D3D12_SUBRESOURCE_DATA& subresource);