Resync DDSTextureLoader, WICTextureLoader

DDSTextureLoader/DDSTextureLoader.h

@@ -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

DDSTextureLoader/DDSTextureLoader12.cpp

@@ -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,
+        const DDS_HEADER** header,
-        uint8_t** bitData,
+        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,
+        ScopedHandle hFile(safe_handle(CreateFile2(fileName,
-                                                      GENERIC_READ,
+            GENERIC_READ,
-                                                      FILE_SHARE_READ,
+            FILE_SHARE_READ,
-                                                      OPEN_EXISTING,
+            OPEN_EXISTING,
-                                                      nullptr ) ) );
+            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(),
+        if (!ReadFile(hFile.get(),
-                       ddsData.get(),
+            ddsData.get(),
-                       fileInfo.EndOfFile.LowPart,
+            fileInfo.EndOfFile.LowPart,
-                       &BytesRead,
+            &BytesRead,
-                       nullptr
+            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 )
+        ptrdiff_t offset = sizeof(uint32_t) + sizeof(DDS_HEADER)
-                           + (bDXT10Header ? sizeof( DDS_HEADER_DXT10 ) : 0);
+            + (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,
+        D3D12_RESOURCE_DIMENSION resDim,
-        _In_ size_t width,
+        size_t width,
-        _In_ size_t height,
+        size_t height,
-        _In_ size_t depth,
+        size_t depth,
-        _In_ size_t mipCount,
+        size_t mipCount,
-        _In_ size_t arraySize,
+        size_t arraySize,
-        _In_ DXGI_FORMAT format,
+        DXGI_FORMAT format,
-        _In_ D3D12_RESOURCE_FLAGS flags,
+        D3D12_RESOURCE_FLAGS resFlags,
-        _In_ bool forceSRGB,
+        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,
+        size_t bitSize,
-        _In_ size_t maxsize,
+        size_t maxsize,
-        _In_ D3D12_RESOURCE_FLAGS flags,
+        D3D12_RESOURCE_FLAGS resFlags,
-        _In_ bool forceSRGB,
+        unsigned int loadFlags,
-        _In_ bool reserveFullMipChain,
         _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, 
+        d3dDevice,
-        ddsData, 
+        ddsData,
-        ddsDataSize, 
+        ddsDataSize,
-        maxsize, 
+        maxsize,
-        D3D12_RESOURCE_FLAG_NONE, 
+        D3D12_RESOURCE_FLAG_NONE,
-        false, 
+        DDS_LOADER_DEFAULT,
-        false,
+        texture,
-        texture, 
+        subresources,
-        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,
+    D3D12_RESOURCE_FLAGS resFlags,
-    bool forceSRGB,
+    unsigned int loadFlags,
-    bool reserveFullMipChain,
     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 )
+    ptrdiff_t offset = sizeof(uint32_t)
-                       + sizeof( DDS_HEADER )
+        + sizeof(DDS_HEADER)
-                       + (bDXT10Header ? sizeof( DDS_HEADER_DXT10 ) : 0);
+        + (bDXT10Header ? sizeof(DDS_HEADER_DXT10) : 0);
 
-    HRESULT hr = CreateTextureFromDDS( d3dDevice, 
+    HRESULT hr = CreateTextureFromDDS(d3dDevice,
-                                       header, ddsData + offset, ddsDataSize - offset, maxsize,
+        header, ddsData + offset, ddsDataSize - offset, maxsize,
-                                       flags, forceSRGB, reserveFullMipChain,
+        resFlags, loadFlags,
-                                       texture, subresources, isCubeMap );
+        texture, subresources, isCubeMap);
-    if ( SUCCEEDED(hr) )
+    if (SUCCEEDED(hr))
     {
         if (texture != 0 && *texture != 0)
         {
             SetDebugObjectName(*texture, L"DDSTextureLoader");
         }
 
-        if ( alphaMode )
+        if (alphaMode)
-            *alphaMode = GetAlphaMode( header );
+            *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( 
+    return LoadDDSTextureFromFileEx(
-        d3dDevice, 
+        d3dDevice,
-        fileName, 
+        fileName,
-        maxsize, 
+        maxsize,
-        D3D12_RESOURCE_FLAG_NONE, 
+        D3D12_RESOURCE_FLAG_NONE,
-        false,
+        DDS_LOADER_DEFAULT,
-        false,
         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,
+    D3D12_RESOURCE_FLAGS resFlags,
-    bool forceSRGB,
+    unsigned int loadFlags,
-    bool reserveFullMipChain,
     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;
+    const DDS_HEADER* header = nullptr;
-    uint8_t* bitData = nullptr;
+    const uint8_t* bitData = nullptr;
     size_t bitSize = 0;
 
-    HRESULT hr = LoadTextureDataFromFile( fileName,
+    HRESULT hr = LoadTextureDataFromFile(fileName,
-                                          ddsData,
+        ddsData,
-                                          &header,
+        &header,
-                                          &bitData,
+        &bitData,
-                                          &bitSize
+        &bitSize
-                                        );
+    );
     if (FAILED(hr))
     {
         return hr;
     }
 
-    hr = CreateTextureFromDDS( d3dDevice,
+    hr = CreateTextureFromDDS(d3dDevice,
-                               header, bitData, bitSize, maxsize,
+        header, bitData, bitSize, maxsize,
-                               flags, forceSRGB, reserveFullMipChain,
+        resFlags, loadFlags,
-                               texture, subresources, isCubeMap );
+        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,
+            int result = WideCharToMultiByte(CP_ACP,
-                                              WC_NO_BEST_FIT_CHARS,
+                WC_NO_BEST_FIT_CHARS,
-                                              fileName,
+                fileName,
-                                              -1,
+                -1,
-                                              strFileA,
+                strFileA,
-                                              MAX_PATH,
+                MAX_PATH,
-                                              nullptr,
+                nullptr,
-                                              FALSE
+                FALSE
-                               );
+            );
-            if ( result > 0 )
+            if (result > 0)
             {
                 const wchar_t* pstrName = wcsrchr(fileName, '\\');
                 if (!pstrName)
@@ -1458,8 +1452,8 @@ HRESULT DirectX::LoadDDSTextureFromFileEx(
         }
 #endif
 
-        if ( alphaMode )
+        if (alphaMode)
-            *alphaMode = GetAlphaMode( header );
+            *alphaMode = GetAlphaMode(header);
     }
 
     return hr;

DDSTextureLoader/DDSTextureLoader12.h

@@ -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,
+        D3D12_RESOURCE_FLAGS resFlags,
-        bool forceSRGB,
+        unsigned int loadFlags,
-        bool reserveFullMipChain,
         _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,
+        D3D12_RESOURCE_FLAGS resFlags,
-        bool forceSRGB,
+        unsigned int loadFlags,
-        bool reserveFullMipChain,
         _Outptr_ ID3D12Resource** texture,
         std::unique_ptr<uint8_t[]>& ddsData,
         std::vector<D3D12_SUBRESOURCE_DATA>& subresources,

WICTextureLoader/WICTextureLoader.h

@@ -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,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
-        _In_ size_t maxsize = 0
+        _In_ size_t maxsize = 0);
-        );
 
     HRESULT CreateWICTextureFromFile(
         _In_ ID3D11Device* d3dDevice,
         _In_z_ const wchar_t* szFileName,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
-        _In_ size_t maxsize = 0
+        _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,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
-        _In_ size_t maxsize = 0
+        _In_ size_t maxsize = 0);
-        );
 
     HRESULT CreateWICTextureFromFile(
         _In_ ID3D11Device* d3dDevice,
         _In_opt_ ID3D11DeviceContext* d3dContext,
         _In_z_ const wchar_t* szFileName,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
-        _In_ size_t maxsize = 0
+        _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,
+        _In_ unsigned int loadFlags,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView
+        _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,
+        _In_ unsigned int loadFlags,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView
+        _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,
+        _In_ unsigned int loadFlags,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView
+        _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,
+        _In_ unsigned int loadFlags,
-        _Out_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11Resource** texture,
-        _Out_opt_ ID3D11ShaderResourceView** textureView
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView);
-        );
 }

WICTextureLoader/WICTextureLoader12.cpp

@@ -269,9 +269,8 @@ namespace
     HRESULT CreateTextureFromWIC(_In_ ID3D12Device* d3dDevice,
         _In_ IWICBitmapFrameDecode *frame,
         size_t maxsize,
-        D3D12_RESOURCE_FLAGS flags,
+        D3D12_RESOURCE_FLAGS resFlags,
-        bool forceSRGB,
+        unsigned int loadFlags,
-        bool reserveFullMipChain,
         _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,
+        WIC_LOADER_DEFAULT,
-        false,
         texture,
         decodedData,
         subresource);
@@ -562,9 +560,8 @@ HRESULT DirectX::LoadWICTextureFromMemoryEx(
     const uint8_t* wicData,
     size_t wicDataSize,
     size_t maxsize,
-    D3D12_RESOURCE_FLAGS flags,
+    D3D12_RESOURCE_FLAGS resFlags,
-    bool forceSRGB,
+    unsigned int loadFlags,
-    bool reserveFullMipChain,
     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,
+        WIC_LOADER_DEFAULT,
-        false,
         texture,
         wicData,
         subresource);
@@ -651,9 +647,8 @@ HRESULT DirectX::LoadWICTextureFromFileEx(
     ID3D12Device* d3dDevice,
     const wchar_t* fileName,
     size_t maxsize,
-    D3D12_RESOURCE_FLAGS flags,
+    D3D12_RESOURCE_FLAGS resFlags,
-    bool forceSRGB,
+    unsigned int loadFlags,
-    bool reserveFullMipChain,
     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) )

WICTextureLoader/WICTextureLoader12.h

@@ -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,
+        D3D12_RESOURCE_FLAGS resFlags,
-        bool forceSRGB,
+        unsigned int loadFlags,
-        bool reserveFullMipChain,
         _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,
+        D3D12_RESOURCE_FLAGS resFlags,
-        bool forceSRGB,
+        unsigned int loadFlags,
-        bool reserveFullMipChain,
         _Outptr_ ID3D12Resource** texture,
         std::unique_ptr<uint8_t[]>& decodedData,
         D3D12_SUBRESOURCE_DATA& subresource);