mirror of
https://github.com/microsoft/DirectXTex.git
synced 2025-07-09 11:40:14 +02:00
Convert internal functions to use Internal namespace instead of leading underscore (#266)
Fixes clang v13 -Wreserved-identifier warning
This commit is contained in:
Chuck Walbourn
GitHub
parent
192e674537
commit
469c65406a
@ -827,6 +827,13 @@ namespace DirectX
|
||||
void __cdecl SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept;
|
||||
#endif
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// DDS helper functions
|
||||
HRESULT __cdecl EncodeDDSHeader(
|
||||
_In_ const TexMetadata& metadata, DDS_FLAGS flags,
|
||||
_Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize,
|
||||
_Out_ size_t& required) noexcept;
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// Direct3D 11 functions
|
||||
#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
#include "BC.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -122,25 +123,25 @@ namespace
|
||||
ptrdiff_t bytesLeft = pEnd - sptr;
|
||||
assert(bytesLeft > 0);
|
||||
size_t bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft));
|
||||
if (!_LoadScanline(&temp[0], pw, sptr, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[0], pw, sptr, bytesToRead, format))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 1)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch);
|
||||
if (!_LoadScanline(&temp[4], pw, sptr + rowPitch, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[4], pw, sptr + rowPitch, bytesToRead, format))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 2)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 2);
|
||||
if (!_LoadScanline(&temp[8], pw, sptr + rowPitch * 2, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[8], pw, sptr + rowPitch * 2, bytesToRead, format))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 3)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 3);
|
||||
if (!_LoadScanline(&temp[12], pw, sptr + rowPitch * 3, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[12], pw, sptr + rowPitch * 3, bytesToRead, format))
|
||||
return E_FAIL;
|
||||
}
|
||||
}
|
||||
@ -176,7 +177,7 @@ namespace
|
||||
}
|
||||
}
|
||||
|
||||
_ConvertScanline(temp, 16, result.format, format, cflags | srgb);
|
||||
ConvertScanline(temp, 16, result.format, format, cflags | srgb);
|
||||
|
||||
if (pfEncode)
|
||||
pfEncode(dptr, temp, bcflags);
|
||||
@ -264,25 +265,25 @@ namespace
|
||||
size_t bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft));
|
||||
|
||||
XM_ALIGNED_DATA(16) XMVECTOR temp[16];
|
||||
if (!_LoadScanline(&temp[0], pw, pSrc, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[0], pw, pSrc, bytesToRead, format))
|
||||
fail = true;
|
||||
|
||||
if (ph > 1)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch);
|
||||
if (!_LoadScanline(&temp[4], pw, pSrc + rowPitch, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[4], pw, pSrc + rowPitch, bytesToRead, format))
|
||||
fail = true;
|
||||
|
||||
if (ph > 2)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 2);
|
||||
if (!_LoadScanline(&temp[8], pw, pSrc + rowPitch * 2, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[8], pw, pSrc + rowPitch * 2, bytesToRead, format))
|
||||
fail = true;
|
||||
|
||||
if (ph > 3)
|
||||
{
|
||||
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 3);
|
||||
if (!_LoadScanline(&temp[12], pw, pSrc + rowPitch * 3, bytesToRead, format))
|
||||
if (!LoadScanline(&temp[12], pw, pSrc + rowPitch * 3, bytesToRead, format))
|
||||
fail = true;
|
||||
}
|
||||
}
|
||||
@ -316,7 +317,7 @@ namespace
|
||||
}
|
||||
}
|
||||
|
||||
_ConvertScanline(temp, 16, result.format, format, cflags | srgb);
|
||||
ConvertScanline(temp, 16, result.format, format, cflags | srgb);
|
||||
|
||||
if (pfEncode)
|
||||
pfEncode(pDest, temp, bcflags);
|
||||
@ -453,27 +454,27 @@ namespace
|
||||
for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
|
||||
{
|
||||
pfDecode(temp, sptr);
|
||||
_ConvertScanline(temp, 16, format, cformat, TEX_FILTER_DEFAULT);
|
||||
ConvertScanline(temp, 16, format, cformat, TEX_FILTER_DEFAULT);
|
||||
|
||||
size_t pw = std::min<size_t>(4, cImage.width - w);
|
||||
assert(pw > 0 && ph > 0);
|
||||
|
||||
if (!_StoreScanline(dptr, rowPitch, format, &temp[0], pw))
|
||||
if (!StoreScanline(dptr, rowPitch, format, &temp[0], pw))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 1)
|
||||
{
|
||||
if (!_StoreScanline(dptr + rowPitch, rowPitch, format, &temp[4], pw))
|
||||
if (!StoreScanline(dptr + rowPitch, rowPitch, format, &temp[4], pw))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 2)
|
||||
{
|
||||
if (!_StoreScanline(dptr + rowPitch * 2, rowPitch, format, &temp[8], pw))
|
||||
if (!StoreScanline(dptr + rowPitch * 2, rowPitch, format, &temp[8], pw))
|
||||
return E_FAIL;
|
||||
|
||||
if (ph > 3)
|
||||
{
|
||||
if (!_StoreScanline(dptr + rowPitch * 3, rowPitch, format, &temp[12], pw))
|
||||
if (!StoreScanline(dptr + rowPitch * 3, rowPitch, format, &temp[12], pw))
|
||||
return E_FAIL;
|
||||
}
|
||||
}
|
||||
@ -492,12 +493,7 @@ namespace
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
namespace DirectX
|
||||
{
|
||||
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
|
||||
// Also used by Image
|
||||
|
||||
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
|
||||
bool DirectX::Internal::IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
|
||||
{
|
||||
if (!cImage.pixels)
|
||||
return false;
|
||||
@ -580,7 +576,6 @@ namespace DirectX
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//=====================================================================================
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include "BCDirectCompute.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -69,15 +70,15 @@ namespace
|
||||
const uint8_t *pSrc = srcImage.pixels;
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
_ConvertScanline(scanline.get(), srcImage.width, format, srcImage.format, filter);
|
||||
ConvertScanline(scanline.get(), srcImage.width, format, srcImage.format, filter);
|
||||
|
||||
if (!_StoreScanline(pDest, img->rowPitch, format, scanline.get(), srcImage.width))
|
||||
if (!StoreScanline(pDest, img->rowPitch, format, scanline.get(), srcImage.width))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
@ -123,13 +124,13 @@ namespace
|
||||
const uint8_t *pSrc = srcImage.pixels;
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
_ConvertScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.format, filter);
|
||||
ConvertScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.format, filter);
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
pDest += img->rowPitch;
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
using namespace DirectX::PackedVector;
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
@ -199,7 +200,7 @@ namespace
|
||||
// (can be used in place as well) otherwise copies the image row unmodified.
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
void DirectX::_CopyScanline(
|
||||
void DirectX::Internal::CopyScanline(
|
||||
void* pDestination,
|
||||
size_t outSize,
|
||||
const void* pSource,
|
||||
@ -444,7 +445,7 @@ void DirectX::_CopyScanline(
|
||||
// (can be used in place as well) otherwise copies the image row unmodified.
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
void DirectX::_SwizzleScanline(
|
||||
void DirectX::Internal::SwizzleScanline(
|
||||
void* pDestination,
|
||||
size_t outSize,
|
||||
const void* pSource,
|
||||
@ -614,7 +615,7 @@ void DirectX::_SwizzleScanline(
|
||||
// Returns true if supported, false if expansion case not supported
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_ExpandScanline(
|
||||
bool DirectX::Internal::ExpandScanline(
|
||||
void* pDestination,
|
||||
size_t outSize,
|
||||
DXGI_FORMAT outFormat,
|
||||
@ -755,7 +756,7 @@ bool DirectX::_ExpandScanline(
|
||||
return false;
|
||||
|
||||
#pragma warning(suppress: 6101)
|
||||
_Use_decl_annotations_ bool DirectX::_LoadScanline(
|
||||
_Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
|
||||
XMVECTOR* pDestination,
|
||||
size_t count,
|
||||
const void* pSource,
|
||||
@ -1603,7 +1604,7 @@ _Use_decl_annotations_ bool DirectX::_LoadScanline(
|
||||
return false;
|
||||
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_StoreScanline(
|
||||
bool DirectX::Internal::StoreScanline(
|
||||
void* pDestination,
|
||||
size_t size,
|
||||
DXGI_FORMAT format,
|
||||
@ -2470,7 +2471,7 @@ bool DirectX::_StoreScanline(
|
||||
// Convert DXGI image to/from GUID_WICPixelFormat128bppRGBAFloat (no range conversions)
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& image) noexcept
|
||||
HRESULT DirectX::Internal::ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& image) noexcept
|
||||
{
|
||||
if (!srcImage.pixels)
|
||||
return E_POINTER;
|
||||
@ -2496,7 +2497,7 @@ HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& ima
|
||||
const uint8_t *pSrc = srcImage.pixels;
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
@ -2510,7 +2511,7 @@ HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& ima
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& destImage) noexcept
|
||||
HRESULT DirectX::Internal::ConvertFromR32G32B32A32(const Image& srcImage, const Image& destImage) noexcept
|
||||
{
|
||||
assert(srcImage.format == DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
|
||||
@ -2525,7 +2526,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& de
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, reinterpret_cast<const XMVECTOR*>(pSrc), srcImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, reinterpret_cast<const XMVECTOR*>(pSrc), srcImage.width))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -2536,7 +2537,10 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& de
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT format, ScratchImage& image) noexcept
|
||||
HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
|
||||
const Image& srcImage,
|
||||
DXGI_FORMAT format,
|
||||
ScratchImage& image) noexcept
|
||||
{
|
||||
if (!srcImage.pixels)
|
||||
return E_POINTER;
|
||||
@ -2552,7 +2556,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT for
|
||||
return E_POINTER;
|
||||
}
|
||||
|
||||
hr = _ConvertFromR32G32B32A32(srcImage, *img);
|
||||
hr = ConvertFromR32G32B32A32(srcImage, *img);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
@ -2563,7 +2567,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT for
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertFromR32G32B32A32(
|
||||
HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
|
||||
const Image* srcImages,
|
||||
size_t nimages,
|
||||
const TexMetadata& metadata,
|
||||
@ -2620,7 +2624,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(
|
||||
|
||||
for (size_t h = 0; h < src.height; ++h)
|
||||
{
|
||||
if (!_StoreScanline(pDest, dst.rowPitch, format, reinterpret_cast<const XMVECTOR*>(pSrc), src.width))
|
||||
if (!StoreScanline(pDest, dst.rowPitch, format, reinterpret_cast<const XMVECTOR*>(pSrc), src.width))
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
@ -2639,7 +2643,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(
|
||||
// Convert DXGI image to/from GUID_WICPixelFormat64bppRGBAHalf (no range conversions)
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& image) noexcept
|
||||
HRESULT DirectX::Internal::ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& image) noexcept
|
||||
{
|
||||
if (!srcImage.pixels)
|
||||
return E_POINTER;
|
||||
@ -2672,7 +2676,7 @@ HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& ima
|
||||
const uint8_t *pSrc = srcImage.pixels;
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
@ -2691,7 +2695,7 @@ HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& ima
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& destImage) noexcept
|
||||
HRESULT DirectX::Internal::ConvertFromR16G16B16A16(const Image& srcImage, const Image& destImage) noexcept
|
||||
{
|
||||
assert(srcImage.format == DXGI_FORMAT_R16G16B16A16_FLOAT);
|
||||
|
||||
@ -2715,7 +2719,7 @@ HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& de
|
||||
reinterpret_cast<const HALF*>(pSrc), sizeof(HALF),
|
||||
srcImage.width * 4);
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -2734,7 +2738,7 @@ HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& de
|
||||
// where a = 0.055
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_StoreScanlineLinear(
|
||||
bool DirectX::Internal::StoreScanlineLinear(
|
||||
void* pDestination,
|
||||
size_t size,
|
||||
DXGI_FORMAT format,
|
||||
@ -2799,7 +2803,7 @@ bool DirectX::_StoreScanlineLinear(
|
||||
}
|
||||
}
|
||||
|
||||
return _StoreScanline(pDestination, size, format, pSource, count, threshold);
|
||||
return StoreScanline(pDestination, size, format, pSource, count, threshold);
|
||||
}
|
||||
|
||||
|
||||
@ -2811,7 +2815,7 @@ bool DirectX::_StoreScanlineLinear(
|
||||
// where a = 0.055
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_LoadScanlineLinear(
|
||||
bool DirectX::Internal::LoadScanlineLinear(
|
||||
XMVECTOR* pDestination,
|
||||
size_t count,
|
||||
const void* pSource,
|
||||
@ -2858,7 +2862,7 @@ bool DirectX::_LoadScanlineLinear(
|
||||
break;
|
||||
}
|
||||
|
||||
if (_LoadScanline(pDestination, count, pSource, size, format))
|
||||
if (LoadScanline(pDestination, count, pSource, size, format))
|
||||
{
|
||||
// sRGB input processing (sRGB -> Linear RGB)
|
||||
if (flags & TEX_FILTER_SRGB_IN)
|
||||
@ -2988,7 +2992,7 @@ namespace
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
uint32_t DirectX::_GetConvertFlags(DXGI_FORMAT format) noexcept
|
||||
uint32_t DirectX::Internal::GetConvertFlags(DXGI_FORMAT format) noexcept
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
// Ensure conversion table is in ascending order
|
||||
@ -3008,7 +3012,7 @@ uint32_t DirectX::_GetConvertFlags(DXGI_FORMAT format) noexcept
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
void DirectX::_ConvertScanline(
|
||||
void DirectX::Internal::ConvertScanline(
|
||||
XMVECTOR* pBuffer,
|
||||
size_t count,
|
||||
DXGI_FORMAT outFormat,
|
||||
@ -3046,8 +3050,8 @@ void DirectX::_ConvertScanline(
|
||||
return;
|
||||
}
|
||||
|
||||
assert(_GetConvertFlags(inFormat) == in->flags);
|
||||
assert(_GetConvertFlags(outFormat) == out->flags);
|
||||
assert(GetConvertFlags(inFormat) == in->flags);
|
||||
assert(GetConvertFlags(outFormat) == out->flags);
|
||||
|
||||
// Handle SRGB filtering modes
|
||||
switch (inFormat)
|
||||
@ -3903,7 +3907,7 @@ namespace
|
||||
#pragma warning( disable : 4127 )
|
||||
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_StoreScanlineDither(
|
||||
bool DirectX::Internal::StoreScanlineDither(
|
||||
void* pDestination,
|
||||
size_t size,
|
||||
DXGI_FORMAT format,
|
||||
@ -4363,7 +4367,7 @@ bool DirectX::_StoreScanlineDither(
|
||||
return false;
|
||||
|
||||
default:
|
||||
return _StoreScanline(pDestination, size, format, pSource, count, threshold);
|
||||
return StoreScanline(pDestination, size, format, pSource, count, threshold);
|
||||
}
|
||||
}
|
||||
|
||||
@ -4402,7 +4406,7 @@ namespace
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!_DXGIToWIC(sformat, pfGUID) || !_DXGIToWIC(tformat, targetGUID))
|
||||
if (!DXGIToWIC(sformat, pfGUID) || !DXGIToWIC(tformat, targetGUID))
|
||||
{
|
||||
// Source or target format are not WIC supported native pixel formats
|
||||
return false;
|
||||
@ -4525,7 +4529,7 @@ namespace
|
||||
filter &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT);
|
||||
}
|
||||
|
||||
auto wicsrgb = _CheckWICColorSpace(pfGUID, targetGUID);
|
||||
auto wicsrgb = CheckWICColorSpace(pfGUID, targetGUID);
|
||||
|
||||
if (wicsrgb != (filter & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)))
|
||||
{
|
||||
@ -4592,7 +4596,8 @@ namespace
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = FC->Initialize(source.Get(), targetGUID, _GetWICDither(filter), nullptr, static_cast<double>(threshold) * 100.0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(source.Get(), targetGUID, GetWICDither(filter), nullptr,
|
||||
static_cast<double>(threshold) * 100.0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -4636,12 +4641,12 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
|
||||
if (!_StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, pDiffusionErrors))
|
||||
if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, pDiffusionErrors))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -4659,12 +4664,12 @@ namespace
|
||||
// Ordered dithering
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
|
||||
if (!_StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, nullptr))
|
||||
if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, nullptr))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -4676,12 +4681,12 @@ namespace
|
||||
// No dithering
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -4694,7 +4699,7 @@ namespace
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
DXGI_FORMAT _PlanarToSingle(_In_ DXGI_FORMAT format) noexcept
|
||||
DXGI_FORMAT PlanarToSingle(_In_ DXGI_FORMAT format) noexcept
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
@ -5077,7 +5082,7 @@ HRESULT DirectX::ConvertToSinglePlane(const Image& srcImage, ScratchImage& image
|
||||
if (!srcImage.pixels)
|
||||
return E_POINTER;
|
||||
|
||||
DXGI_FORMAT format = _PlanarToSingle(srcImage.format);
|
||||
DXGI_FORMAT format = PlanarToSingle(srcImage.format);
|
||||
if (format == DXGI_FORMAT_UNKNOWN)
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
@ -5125,7 +5130,7 @@ HRESULT DirectX::ConvertToSinglePlane(
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
DXGI_FORMAT format = _PlanarToSingle(metadata.format);
|
||||
DXGI_FORMAT format = PlanarToSingle(metadata.format);
|
||||
if (format == DXGI_FORMAT_UNKNOWN)
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
@ -5189,7 +5194,7 @@ HRESULT DirectX::ConvertToSinglePlane(
|
||||
//-------------------------------------------------------------------------------------
|
||||
DirectX::FORMAT_TYPE DirectX::FormatDataType(_In_ DXGI_FORMAT fmt) noexcept
|
||||
{
|
||||
auto cflags = _GetConvertFlags(fmt);
|
||||
const auto cflags = GetConvertFlags(fmt);
|
||||
|
||||
switch (cflags & (CONVF_FLOAT | CONVF_UNORM | CONVF_UINT | CONVF_SNORM | CONVF_SINT))
|
||||
{
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include "DDS.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(DDS_DIMENSION_TEXTURE1D), "header enum mismatch");
|
||||
static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(DDS_DIMENSION_TEXTURE2D), "header enum mismatch");
|
||||
@ -558,7 +559,7 @@ namespace
|
||||
// Encodes DDS file header (magic value, header, optional DX10 extended header)
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::_EncodeDDSHeader(
|
||||
HRESULT DirectX::EncodeDDSHeader(
|
||||
const TexMetadata& metadata,
|
||||
DDS_FLAGS flags,
|
||||
void* pDestination,
|
||||
@ -889,7 +890,7 @@ namespace
|
||||
TEXP_LEGACY_A8L8
|
||||
};
|
||||
|
||||
inline TEXP_LEGACY_FORMAT _FindLegacyFormat(uint32_t flags) noexcept
|
||||
inline TEXP_LEGACY_FORMAT FindLegacyFormat(uint32_t flags) noexcept
|
||||
{
|
||||
TEXP_LEGACY_FORMAT lformat = TEXP_LEGACY_UNKNOWN;
|
||||
|
||||
@ -1253,7 +1254,7 @@ namespace
|
||||
}
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!_DetermineImageArray(metadata, cpFlags, nimages, pixelSize))
|
||||
if (!DetermineImageArray(metadata, cpFlags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
if ((nimages == 0) || (nimages != image.GetImageCount()))
|
||||
@ -1272,7 +1273,7 @@ namespace
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
|
||||
if (!_SetupImageArray(
|
||||
if (!SetupImageArray(
|
||||
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(pPixels)),
|
||||
pixelSize,
|
||||
metadata,
|
||||
@ -1366,7 +1367,7 @@ namespace
|
||||
{
|
||||
if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
|
||||
{
|
||||
if (!_ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
pSrc, spitch,
|
||||
(convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
|
||||
tflags))
|
||||
@ -1374,7 +1375,7 @@ namespace
|
||||
}
|
||||
else
|
||||
{
|
||||
TEXP_LEGACY_FORMAT lformat = _FindLegacyFormat(convFlags);
|
||||
TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
|
||||
if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
|
||||
pSrc, spitch, lformat, pal8,
|
||||
tflags))
|
||||
@ -1383,12 +1384,12 @@ namespace
|
||||
}
|
||||
else if (convFlags & CONV_FLAGS_SWIZZLE)
|
||||
{
|
||||
_SwizzleScanline(pDest, dpitch, pSrc, spitch,
|
||||
SwizzleScanline(pDest, dpitch, pSrc, spitch,
|
||||
metadata.format, tflags);
|
||||
}
|
||||
else
|
||||
{
|
||||
_CopyScanline(pDest, dpitch, pSrc, spitch,
|
||||
CopyScanline(pDest, dpitch, pSrc, spitch,
|
||||
metadata.format, tflags);
|
||||
}
|
||||
|
||||
@ -1459,7 +1460,7 @@ namespace
|
||||
{
|
||||
if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
|
||||
{
|
||||
if (!_ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
pSrc, spitch,
|
||||
(convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
|
||||
tflags))
|
||||
@ -1467,7 +1468,7 @@ namespace
|
||||
}
|
||||
else
|
||||
{
|
||||
TEXP_LEGACY_FORMAT lformat = _FindLegacyFormat(convFlags);
|
||||
TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
|
||||
if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
|
||||
pSrc, spitch, lformat, pal8,
|
||||
tflags))
|
||||
@ -1476,11 +1477,11 @@ namespace
|
||||
}
|
||||
else if (convFlags & CONV_FLAGS_SWIZZLE)
|
||||
{
|
||||
_SwizzleScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
|
||||
SwizzleScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
|
||||
}
|
||||
else
|
||||
{
|
||||
_CopyScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
|
||||
CopyScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
|
||||
}
|
||||
|
||||
pSrc += spitch;
|
||||
@ -1533,11 +1534,11 @@ namespace
|
||||
{
|
||||
if (convFlags & CONV_FLAGS_SWIZZLE)
|
||||
{
|
||||
_SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
|
||||
SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
|
||||
}
|
||||
else
|
||||
{
|
||||
_CopyScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
|
||||
CopyScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
|
||||
}
|
||||
|
||||
pPixels += rowPitch;
|
||||
@ -1992,7 +1993,7 @@ HRESULT DirectX::SaveToDDSMemory(
|
||||
|
||||
// Determine memory required
|
||||
size_t required = 0;
|
||||
HRESULT hr = _EncodeDDSHeader(metadata, flags, nullptr, 0, required);
|
||||
HRESULT hr = EncodeDDSHeader(metadata, flags, nullptr, 0, required);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -2033,7 +2034,7 @@ HRESULT DirectX::SaveToDDSMemory(
|
||||
auto pDestination = static_cast<uint8_t*>(blob.GetBufferPointer());
|
||||
assert(pDestination);
|
||||
|
||||
hr = _EncodeDDSHeader(metadata, flags, pDestination, blob.GetBufferSize(), required);
|
||||
hr = EncodeDDSHeader(metadata, flags, pDestination, blob.GetBufferSize(), required);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
blob.Release();
|
||||
@ -2083,16 +2084,22 @@ HRESULT DirectX::SaveToDDSMemory(
|
||||
return hr;
|
||||
}
|
||||
|
||||
size_t rowPitch = images[index].rowPitch;
|
||||
const size_t rowPitch = images[index].rowPitch;
|
||||
|
||||
const uint8_t * __restrict sPtr = images[index].pixels;
|
||||
uint8_t * __restrict dPtr = pDestination;
|
||||
|
||||
size_t lines = ComputeScanlines(metadata.format, images[index].height);
|
||||
size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
|
||||
const size_t lines = ComputeScanlines(metadata.format, images[index].height);
|
||||
const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
|
||||
size_t tremaining = remaining;
|
||||
for (size_t j = 0; j < lines; ++j)
|
||||
{
|
||||
if (tremaining < csize)
|
||||
{
|
||||
blob.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
memcpy(dPtr, sPtr, csize);
|
||||
|
||||
sPtr += rowPitch;
|
||||
@ -2149,16 +2156,22 @@ HRESULT DirectX::SaveToDDSMemory(
|
||||
return hr;
|
||||
}
|
||||
|
||||
size_t rowPitch = images[index].rowPitch;
|
||||
const size_t rowPitch = images[index].rowPitch;
|
||||
|
||||
const uint8_t * __restrict sPtr = images[index].pixels;
|
||||
uint8_t * __restrict dPtr = pDestination;
|
||||
|
||||
size_t lines = ComputeScanlines(metadata.format, images[index].height);
|
||||
size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
|
||||
const size_t lines = ComputeScanlines(metadata.format, images[index].height);
|
||||
const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
|
||||
size_t tremaining = remaining;
|
||||
for (size_t j = 0; j < lines; ++j)
|
||||
{
|
||||
if (tremaining < csize)
|
||||
{
|
||||
blob.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
memcpy(dPtr, sPtr, csize);
|
||||
|
||||
sPtr += rowPitch;
|
||||
@ -2206,7 +2219,7 @@ HRESULT DirectX::SaveToDDSFile(
|
||||
const size_t MAX_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10);
|
||||
uint8_t header[MAX_HEADER_SIZE];
|
||||
size_t required;
|
||||
HRESULT hr = _EncodeDDSHeader(metadata, flags, header, MAX_HEADER_SIZE, required);
|
||||
HRESULT hr = EncodeDDSHeader(metadata, flags, header, MAX_HEADER_SIZE, required);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
namespace
|
||||
@ -100,7 +101,7 @@ namespace
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
ScratchImage temp;
|
||||
HRESULT hr = _ConvertToR16G16B16A16(srcImage, temp);
|
||||
HRESULT hr = ConvertToR16G16B16A16(srcImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -123,7 +124,7 @@ namespace
|
||||
|
||||
temp.Release();
|
||||
|
||||
hr = _ConvertFromR16G16B16A16(*tdest, destImage);
|
||||
hr = ConvertFromR16G16B16A16(*tdest, destImage);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -142,7 +143,7 @@ namespace
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
ScratchImage temp;
|
||||
HRESULT hr = _ConvertToR32G32B32A32(srcImage, temp);
|
||||
HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -165,7 +166,7 @@ namespace
|
||||
|
||||
temp.Release();
|
||||
|
||||
hr = _ConvertFromR32G32B32A32(*tdest, destImage);
|
||||
hr = ConvertFromR32G32B32A32(*tdest, destImage);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -245,7 +246,7 @@ HRESULT DirectX::FlipRotate(
|
||||
}
|
||||
|
||||
WICPixelFormatGUID pfGUID;
|
||||
if (_DXGIToWIC(srcImage.format, pfGUID))
|
||||
if (DXGIToWIC(srcImage.format, pfGUID))
|
||||
{
|
||||
// Case 1: Source format is supported by Windows Imaging Component
|
||||
hr = PerformFlipRotateUsingWIC(srcImage, flags, pfGUID, *rimage);
|
||||
@ -345,7 +346,7 @@ HRESULT DirectX::FlipRotate(
|
||||
}
|
||||
|
||||
WICPixelFormatGUID pfGUID;
|
||||
bool wicpf = _DXGIToWIC(metadata.format, pfGUID);
|
||||
bool wicpf = DXGIToWIC(metadata.format, pfGUID);
|
||||
|
||||
for (size_t index = 0; index < nimages; ++index)
|
||||
{
|
||||
|
||||
@ -11,14 +11,8 @@
|
||||
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
namespace DirectX
|
||||
{
|
||||
extern bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
|
||||
extern bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept;
|
||||
extern bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
|
||||
}
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
#ifndef WIN32
|
||||
namespace
|
||||
@ -37,7 +31,7 @@ namespace
|
||||
// Determines number of image array entries and pixel size
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_DetermineImageArray(
|
||||
bool DirectX::Internal::DetermineImageArray(
|
||||
const TexMetadata& metadata,
|
||||
CP_FLAGS cpFlags,
|
||||
size_t& nImages,
|
||||
@ -140,7 +134,7 @@ bool DirectX::_DetermineImageArray(
|
||||
// Fills in the image array entries
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_SetupImageArray(
|
||||
bool DirectX::Internal::SetupImageArray(
|
||||
uint8_t *pMemory,
|
||||
size_t pixelSize,
|
||||
const TexMetadata& metadata,
|
||||
@ -311,7 +305,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
||||
if (!mdata.width || mdata.height != 1 || mdata.depth != 1 || !mdata.arraySize)
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (!_CalculateMipLevels(mdata.width, 1, mipLevels))
|
||||
if (!CalculateMipLevels(mdata.width, 1, mipLevels))
|
||||
return E_INVALIDARG;
|
||||
break;
|
||||
|
||||
@ -325,7 +319,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
|
||||
if (!_CalculateMipLevels(mdata.width, mdata.height, mipLevels))
|
||||
if (!CalculateMipLevels(mdata.width, mdata.height, mipLevels))
|
||||
return E_INVALIDARG;
|
||||
break;
|
||||
|
||||
@ -333,7 +327,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
||||
if (!mdata.width || !mdata.height || !mdata.depth || mdata.arraySize != 1)
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (!_CalculateMipLevels3D(mdata.width, mdata.height, mdata.depth, mipLevels))
|
||||
if (!CalculateMipLevels3D(mdata.width, mdata.height, mdata.depth, mipLevels))
|
||||
return E_INVALIDARG;
|
||||
break;
|
||||
|
||||
@ -354,7 +348,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
||||
m_metadata.dimension = mdata.dimension;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
@ -371,7 +365,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
m_size = pixelSize;
|
||||
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
{
|
||||
Release();
|
||||
return E_FAIL;
|
||||
@ -405,7 +399,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
if (IsPalettized(fmt))
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
if (!_CalculateMipLevels(width, height, mipLevels))
|
||||
if (!CalculateMipLevels(width, height, mipLevels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
Release();
|
||||
@ -421,7 +415,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
m_metadata.dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
@ -438,7 +432,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
m_size = pixelSize;
|
||||
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
{
|
||||
Release();
|
||||
return E_FAIL;
|
||||
@ -456,7 +450,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
if (IsPalettized(fmt))
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
if (!_CalculateMipLevels3D(width, height, depth, mipLevels))
|
||||
if (!CalculateMipLevels3D(width, height, depth, mipLevels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
Release();
|
||||
@ -472,7 +466,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
m_metadata.dimension = TEX_DIMENSION_TEXTURE3D;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
@ -492,7 +486,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
|
||||
}
|
||||
m_size = pixelSize;
|
||||
|
||||
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
{
|
||||
Release();
|
||||
return E_FAIL;
|
||||
@ -793,7 +787,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
|
||||
{
|
||||
for (size_t index = 0; index < m_nimages; ++index)
|
||||
{
|
||||
if (!_IsAlphaAllOpaqueBC(m_image[index]))
|
||||
if (!IsAlphaAllOpaqueBC(m_image[index]))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -815,7 +809,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
|
||||
|
||||
for (size_t h = 0; h < img.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), img.width, pPixels, img.rowPitch, img.format))
|
||||
if (!LoadScanline(scanline.get(), img.width, pPixels, img.rowPitch, img.format))
|
||||
return false;
|
||||
|
||||
const XMVECTOR* ptr = scanline.get();
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include "filters.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
namespace
|
||||
@ -104,7 +105,8 @@ namespace
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = converter->Initialize(src, desiredPixelFormat, _GetWICDither(filter), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = converter->Initialize(src, desiredPixelFormat, GetWICDither(filter), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
@ -160,7 +162,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
{
|
||||
return E_FAIL;
|
||||
}
|
||||
@ -173,7 +175,7 @@ namespace
|
||||
*(ptr++) = XMVectorSelect(alpha, v, g_XMSelect1110);
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
{
|
||||
return E_FAIL;
|
||||
}
|
||||
@ -242,13 +244,13 @@ namespace
|
||||
size_t coverageCount = 0;
|
||||
for (size_t y = 0; y < srcImage.height - 1; ++y)
|
||||
{
|
||||
if (!_LoadScanlineLinear(row0.get(), srcImage.width, pSrcRow0, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
|
||||
if (!LoadScanlineLinear(row0.get(), srcImage.width, pSrcRow0, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
|
||||
{
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const uint8_t *pSrcRow1 = pSrcRow0 + srcImage.rowPitch;
|
||||
if (!_LoadScanlineLinear(row1.get(), srcImage.width, pSrcRow1, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
|
||||
if (!LoadScanlineLinear(row1.get(), srcImage.width, pSrcRow1, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
|
||||
{
|
||||
return E_FAIL;
|
||||
}
|
||||
@ -343,20 +345,11 @@ namespace
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace DirectX
|
||||
{
|
||||
bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
|
||||
bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept;
|
||||
// Also used by Compress
|
||||
|
||||
#ifdef WIN32
|
||||
HRESULT _ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC, _In_ bool iswic2, _In_ IWICBitmap* original,
|
||||
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter, _Inout_ const Image* img) noexcept;
|
||||
// Also used by Resize
|
||||
#endif
|
||||
|
||||
bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::Internal::CalculateMipLevels(
|
||||
size_t width,
|
||||
size_t height,
|
||||
size_t& mipLevels) noexcept
|
||||
{
|
||||
if (mipLevels > 1)
|
||||
{
|
||||
@ -375,7 +368,12 @@ namespace DirectX
|
||||
return true;
|
||||
}
|
||||
|
||||
bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::Internal::CalculateMipLevels3D(
|
||||
size_t width,
|
||||
size_t height,
|
||||
size_t depth,
|
||||
size_t& mipLevels) noexcept
|
||||
{
|
||||
if (mipLevels > 1)
|
||||
{
|
||||
@ -397,7 +395,7 @@ namespace DirectX
|
||||
#ifdef WIN32
|
||||
//--- Resizing color and alpha channels separately using WIC ---
|
||||
_Use_decl_annotations_
|
||||
HRESULT _ResizeSeparateColorAndAlpha(
|
||||
HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
||||
IWICImagingFactory* pWIC,
|
||||
bool iswic2,
|
||||
IWICBitmap* original,
|
||||
@ -409,7 +407,7 @@ namespace DirectX
|
||||
if (!pWIC || !original || !img)
|
||||
return E_POINTER;
|
||||
|
||||
const WICBitmapInterpolationMode interpolationMode = _GetWICInterp(filter);
|
||||
const WICBitmapInterpolationMode interpolationMode = GetWICInterp(filter);
|
||||
|
||||
WICPixelFormatGUID desiredPixelFormat = GUID_WICPixelFormatUndefined;
|
||||
HRESULT hr = original->GetPixelFormat(&desiredPixelFormat);
|
||||
@ -612,7 +610,6 @@ namespace DirectX
|
||||
return hr;
|
||||
}
|
||||
#endif // WIN32
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -770,7 +767,7 @@ namespace
|
||||
|
||||
if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
|
||||
{
|
||||
hr = _ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), width, height, filter, img);
|
||||
hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), width, height, filter, img);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
}
|
||||
@ -784,7 +781,9 @@ namespace
|
||||
if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
hr = scaler->Initialize(source.Get(), static_cast<UINT>(width), static_cast<UINT>(height), _GetWICInterp(filter));
|
||||
hr = scaler->Initialize(source.Get(),
|
||||
static_cast<UINT>(width), static_cast<UINT>(height),
|
||||
GetWICInterp(filter));
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -815,7 +814,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(scaler.Get(), pfGUID, _GetWICDither(filter), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(scaler.Get(), pfGUID, GetWICDither(filter), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -943,7 +943,7 @@ namespace
|
||||
{
|
||||
if ((lasty ^ sy) >> 16)
|
||||
{
|
||||
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
return E_FAIL;
|
||||
lasty = sy;
|
||||
}
|
||||
@ -955,7 +955,7 @@ namespace
|
||||
sx += xinc;
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
|
||||
@ -976,6 +976,8 @@ namespace
|
||||
//--- 2D Box Filter ---
|
||||
HRESULT Generate2DMipsBoxFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -1033,13 +1035,13 @@ namespace
|
||||
|
||||
for (size_t y = 0; y < nheight; ++y)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
|
||||
if (urow0 != urow1)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
}
|
||||
@ -1051,7 +1053,7 @@ namespace
|
||||
AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -1070,6 +1072,8 @@ namespace
|
||||
//--- 2D Linear Filter ---
|
||||
HRESULT Generate2DMipsLinearFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -1113,10 +1117,10 @@ namespace
|
||||
size_t rowPitch = src->rowPitch;
|
||||
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
_CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
|
||||
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
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
@ -1136,7 +1140,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -1152,7 +1156,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -1163,7 +1167,7 @@ namespace
|
||||
BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -1181,6 +1185,8 @@ namespace
|
||||
//--- 2D Cubic Filter ---
|
||||
HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -1226,10 +1232,10 @@ namespace
|
||||
size_t rowPitch = src->rowPitch;
|
||||
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
_CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
|
||||
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
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
@ -1254,7 +1260,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u0 == u1)
|
||||
@ -1287,7 +1293,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u1 == u2)
|
||||
@ -1313,7 +1319,7 @@ namespace
|
||||
{
|
||||
u2 = toY.u2;
|
||||
|
||||
if (!_LoadScanlineLinear(row2, width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row2, width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -1330,7 +1336,7 @@ namespace
|
||||
{
|
||||
u3 = toY.u3;
|
||||
|
||||
if (!_LoadScanlineLinear(row3, width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row3, width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -1348,7 +1354,7 @@ namespace
|
||||
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))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -1367,11 +1373,11 @@ namespace
|
||||
//--- 2D Triangle Filter ---
|
||||
HRESULT Generate2DMipsTriangleFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
using namespace TriangleFilter;
|
||||
|
||||
// This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
|
||||
|
||||
assert(levels > 1);
|
||||
@ -1411,12 +1417,12 @@ namespace
|
||||
uint8_t* pDest = dest->pixels;
|
||||
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
HRESULT hr = _Create(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
hr = _Create(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -1483,7 +1489,7 @@ namespace
|
||||
if ((pSrc + rowPitch) > pEndSrc)
|
||||
return E_FAIL;
|
||||
|
||||
if (!_LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += rowPitch;
|
||||
@ -1555,7 +1561,7 @@ namespace
|
||||
}
|
||||
|
||||
// This performs any required clamping
|
||||
if (!_StoreScanlineLinear(pDest + (dest->rowPitch * v), dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
|
||||
if (!StoreScanlineLinear(pDest + (dest->rowPitch * v), dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
|
||||
return E_FAIL;
|
||||
|
||||
// Put row on freelist to reuse it's allocated scanline
|
||||
@ -1698,7 +1704,7 @@ namespace
|
||||
{
|
||||
if ((lasty ^ sy) >> 16)
|
||||
{
|
||||
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
return E_FAIL;
|
||||
lasty = sy;
|
||||
}
|
||||
@ -1710,7 +1716,7 @@ namespace
|
||||
sx += xinc;
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
|
||||
@ -1747,7 +1753,7 @@ namespace
|
||||
{
|
||||
if ((lasty ^ sy) >> 16)
|
||||
{
|
||||
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
|
||||
return E_FAIL;
|
||||
lasty = sy;
|
||||
}
|
||||
@ -1759,7 +1765,7 @@ namespace
|
||||
sx += xinc;
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
|
||||
@ -1784,6 +1790,8 @@ namespace
|
||||
//--- 3D Box Filter ---
|
||||
HRESULT Generate3DMipsBoxFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!depth || !mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -1860,24 +1868,24 @@ namespace
|
||||
|
||||
for (size_t y = 0; y < nheight; ++y)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow0, width, pSrc1, aRowPitch, srca->format, filter))
|
||||
if (!LoadScanlineLinear(urow0, width, pSrc1, aRowPitch, srca->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc1 += aRowPitch;
|
||||
|
||||
if (urow0 != urow1)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow1, width, pSrc1, aRowPitch, srca->format, filter))
|
||||
if (!LoadScanlineLinear(urow1, width, pSrc1, aRowPitch, srca->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc1 += aRowPitch;
|
||||
}
|
||||
|
||||
if (!_LoadScanlineLinear(vrow0, width, pSrc2, bRowPitch, srcb->format, filter))
|
||||
if (!LoadScanlineLinear(vrow0, width, pSrc2, bRowPitch, srcb->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc2 += bRowPitch;
|
||||
|
||||
if (vrow0 != vrow1)
|
||||
{
|
||||
if (!_LoadScanlineLinear(vrow1, width, pSrc2, bRowPitch, srcb->format, filter))
|
||||
if (!LoadScanlineLinear(vrow1, width, pSrc2, bRowPitch, srcb->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc2 += bRowPitch;
|
||||
}
|
||||
@ -1890,7 +1898,7 @@ namespace
|
||||
vrow0[x2], vrow1[x2], vrow2[x2], vrow3[x2])
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -1915,13 +1923,13 @@ namespace
|
||||
|
||||
for (size_t y = 0; y < nheight; ++y)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
|
||||
if (urow0 != urow1)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
}
|
||||
@ -1933,7 +1941,7 @@ namespace
|
||||
AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -1956,6 +1964,8 @@ namespace
|
||||
//--- 3D Linear Filter ---
|
||||
HRESULT Generate3DMipsLinearFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!depth || !mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -1990,10 +2000,10 @@ namespace
|
||||
for (size_t level = 1; level < levels; ++level)
|
||||
{
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
_CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
|
||||
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
|
||||
memset(urow0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
@ -2006,7 +2016,7 @@ namespace
|
||||
{
|
||||
// 3D linear filter
|
||||
size_t ndepth = depth >> 1;
|
||||
_CreateLinearFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, lfZ);
|
||||
CreateLinearFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, lfZ);
|
||||
|
||||
for (size_t slice = 0; slice < ndepth; ++slice)
|
||||
{
|
||||
@ -2036,8 +2046,8 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(urow0, width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(vrow0, width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter))
|
||||
if (!LoadScanlineLinear(urow0, width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(vrow0, width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -2054,8 +2064,8 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(urow1, width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(vrow1, width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter))
|
||||
if (!LoadScanlineLinear(urow1, width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(vrow1, width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -2066,7 +2076,7 @@ namespace
|
||||
TRILINEAR_INTERPOLATE(target[x], toX, toY, toZ, urow0, urow1, vrow0, vrow1)
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -2099,7 +2109,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(urow0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -2115,7 +2125,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(urow1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -2126,7 +2136,7 @@ namespace
|
||||
BILINEAR_INTERPOLATE(target[x], toX, toY, urow0, urow1)
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -2149,6 +2159,8 @@ namespace
|
||||
//--- 3D Cubic Filter ---
|
||||
HRESULT Generate3DMipsCubicFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!depth || !mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
@ -2192,10 +2204,10 @@ namespace
|
||||
for (size_t level = 1; level < levels; ++level)
|
||||
{
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
_CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
|
||||
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
|
||||
for (size_t j = 0; j < 4; ++j)
|
||||
@ -2211,7 +2223,7 @@ namespace
|
||||
{
|
||||
// 3D cubic filter
|
||||
size_t ndepth = depth >> 1;
|
||||
_CreateCubicFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, (filter & TEX_FILTER_MIRROR_W) != 0, cfZ);
|
||||
CreateCubicFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, (filter & TEX_FILTER_MIRROR_W) != 0, cfZ);
|
||||
|
||||
for (size_t slice = 0; slice < ndepth; ++slice)
|
||||
{
|
||||
@ -2246,10 +2258,10 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(urow[0], width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(urow[1], width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter)
|
||||
|| !_LoadScanlineLinear(urow[2], width, srcc->pixels + (srcc->rowPitch * u0), srcc->rowPitch, srcc->format, filter)
|
||||
|| !_LoadScanlineLinear(urow[3], width, srcd->pixels + (srcd->rowPitch * u0), srcd->rowPitch, srcd->format, filter))
|
||||
if (!LoadScanlineLinear(urow[0], width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(urow[1], width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter)
|
||||
|| !LoadScanlineLinear(urow[2], width, srcc->pixels + (srcc->rowPitch * u0), srcc->rowPitch, srcc->format, filter)
|
||||
|| !LoadScanlineLinear(urow[3], width, srcd->pixels + (srcd->rowPitch * u0), srcd->rowPitch, srcd->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u0 == u1)
|
||||
@ -2291,10 +2303,10 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(vrow[0], width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(vrow[1], width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter)
|
||||
|| !_LoadScanlineLinear(vrow[2], width, srcc->pixels + (srcc->rowPitch * u1), srcc->rowPitch, srcc->format, filter)
|
||||
|| !_LoadScanlineLinear(vrow[3], width, srcd->pixels + (srcd->rowPitch * u1), srcd->rowPitch, srcd->format, filter))
|
||||
if (!LoadScanlineLinear(vrow[0], width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(vrow[1], width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter)
|
||||
|| !LoadScanlineLinear(vrow[2], width, srcc->pixels + (srcc->rowPitch * u1), srcc->rowPitch, srcc->format, filter)
|
||||
|| !LoadScanlineLinear(vrow[3], width, srcd->pixels + (srcd->rowPitch * u1), srcd->rowPitch, srcd->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u1 == u2)
|
||||
@ -2326,10 +2338,10 @@ namespace
|
||||
{
|
||||
u2 = toY.u2;
|
||||
|
||||
if (!_LoadScanlineLinear(srow[0], width, srca->pixels + (srca->rowPitch * u2), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(srow[1], width, srcb->pixels + (srcb->rowPitch * u2), srcb->rowPitch, srcb->format, filter)
|
||||
|| !_LoadScanlineLinear(srow[2], width, srcc->pixels + (srcc->rowPitch * u2), srcc->rowPitch, srcc->format, filter)
|
||||
|| !_LoadScanlineLinear(srow[3], width, srcd->pixels + (srcd->rowPitch * u2), srcd->rowPitch, srcd->format, filter))
|
||||
if (!LoadScanlineLinear(srow[0], width, srca->pixels + (srca->rowPitch * u2), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(srow[1], width, srcb->pixels + (srcb->rowPitch * u2), srcb->rowPitch, srcb->format, filter)
|
||||
|| !LoadScanlineLinear(srow[2], width, srcc->pixels + (srcc->rowPitch * u2), srcc->rowPitch, srcc->format, filter)
|
||||
|| !LoadScanlineLinear(srow[3], width, srcd->pixels + (srcd->rowPitch * u2), srcd->rowPitch, srcd->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -2349,10 +2361,10 @@ namespace
|
||||
{
|
||||
u3 = toY.u3;
|
||||
|
||||
if (!_LoadScanlineLinear(trow[0], width, srca->pixels + (srca->rowPitch * u3), srca->rowPitch, srca->format, filter)
|
||||
|| !_LoadScanlineLinear(trow[1], width, srcb->pixels + (srcb->rowPitch * u3), srcb->rowPitch, srcb->format, filter)
|
||||
|| !_LoadScanlineLinear(trow[2], width, srcc->pixels + (srcc->rowPitch * u3), srcc->rowPitch, srcc->format, filter)
|
||||
|| !_LoadScanlineLinear(trow[3], width, srcd->pixels + (srcd->rowPitch * u3), srcd->rowPitch, srcd->format, filter))
|
||||
if (!LoadScanlineLinear(trow[0], width, srca->pixels + (srca->rowPitch * u3), srca->rowPitch, srca->format, filter)
|
||||
|| !LoadScanlineLinear(trow[1], width, srcb->pixels + (srcb->rowPitch * u3), srcb->rowPitch, srcb->format, filter)
|
||||
|| !LoadScanlineLinear(trow[2], width, srcc->pixels + (srcc->rowPitch * u3), srcc->rowPitch, srcc->format, filter)
|
||||
|| !LoadScanlineLinear(trow[3], width, srcd->pixels + (srcd->rowPitch * u3), srcd->rowPitch, srcd->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -2376,7 +2388,7 @@ namespace
|
||||
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))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -2412,7 +2424,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(urow[0], width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(urow[0], width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u0 == u1)
|
||||
@ -2445,7 +2457,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(vrow[0], width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(vrow[0], width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u1 == u2)
|
||||
@ -2471,7 +2483,7 @@ namespace
|
||||
{
|
||||
u2 = toY.u2;
|
||||
|
||||
if (!_LoadScanlineLinear(srow[0], width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(srow[0], width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -2488,7 +2500,7 @@ namespace
|
||||
{
|
||||
u3 = toY.u3;
|
||||
|
||||
if (!_LoadScanlineLinear(trow[0], width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(trow[0], width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -2505,7 +2517,7 @@ namespace
|
||||
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))
|
||||
return E_FAIL;
|
||||
pDest += dest->rowPitch;
|
||||
}
|
||||
@ -2528,11 +2540,11 @@ namespace
|
||||
//--- 3D Triangle Filter ---
|
||||
HRESULT Generate3DMipsTriangleFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
if (!depth || !mipChain.GetImages())
|
||||
return E_INVALIDARG;
|
||||
|
||||
using namespace TriangleFilter;
|
||||
|
||||
// This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
|
||||
|
||||
assert(levels > 1);
|
||||
@ -2559,17 +2571,17 @@ namespace
|
||||
for (size_t level = 1; level < levels; ++level)
|
||||
{
|
||||
size_t nwidth = (width > 1) ? (width >> 1) : 1;
|
||||
HRESULT hr = _Create(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
hr = _Create(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
size_t ndepth = (depth > 1) ? (depth >> 1) : 1;
|
||||
hr = _Create(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, tfZ);
|
||||
hr = CreateTriangleFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, tfZ);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -2649,7 +2661,7 @@ namespace
|
||||
if ((pSrc + rowPitch) > pEndSrc)
|
||||
return E_FAIL;
|
||||
|
||||
if (!_LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
|
||||
if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += rowPitch;
|
||||
@ -2738,7 +2750,7 @@ namespace
|
||||
}
|
||||
|
||||
// This performs any required clamping
|
||||
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pDest += dest->rowPitch;
|
||||
@ -2790,7 +2802,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
if (!baseImage.pixels)
|
||||
return E_POINTER;
|
||||
|
||||
if (!_CalculateMipLevels(baseImage.width, baseImage.height, levels))
|
||||
if (!CalculateMipLevels(baseImage.width, baseImage.height, levels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (levels <= 1)
|
||||
@ -2809,7 +2821,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
bool usewic = UseWICFiltering(baseImage.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
bool wicpf = (usewic) ? _DXGIToWIC(baseImage.format, pfGUID, true) : false;
|
||||
bool wicpf = (usewic) ? DXGIToWIC(baseImage.format, pfGUID, true) : false;
|
||||
|
||||
if (usewic && !wicpf)
|
||||
{
|
||||
@ -2854,7 +2866,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
|
||||
assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
ScratchImage temp;
|
||||
hr = _ConvertToR32G32B32A32(baseImage, temp);
|
||||
hr = ConvertToR32G32B32A32(baseImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -2875,7 +2887,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
|
||||
temp.Release();
|
||||
|
||||
return _ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2984,7 +2996,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
|| IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
if (!_CalculateMipLevels(metadata.width, metadata.height, levels))
|
||||
if (!CalculateMipLevels(metadata.width, metadata.height, levels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (levels <= 1)
|
||||
@ -3024,7 +3036,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
bool wicpf = (usewic) ? _DXGIToWIC(metadata.format, pfGUID, true) : false;
|
||||
bool wicpf = (usewic) ? DXGIToWIC(metadata.format, pfGUID, true) : false;
|
||||
|
||||
if (usewic && !wicpf)
|
||||
{
|
||||
@ -3090,7 +3102,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
ScratchImage temp;
|
||||
hr = _ConvertToR32G32B32A32(baseImages[item], temp);
|
||||
hr = ConvertToR32G32B32A32(baseImages[item], temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -3103,7 +3115,7 @@ HRESULT DirectX::GenerateMipMaps(
|
||||
return hr;
|
||||
}
|
||||
|
||||
return _ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3220,7 +3232,7 @@ HRESULT DirectX::GenerateMipMaps3D(
|
||||
size_t width = baseImages[0].width;
|
||||
size_t height = baseImages[0].height;
|
||||
|
||||
if (!_CalculateMipLevels3D(width, height, depth, levels))
|
||||
if (!CalculateMipLevels3D(width, height, depth, levels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (levels <= 1)
|
||||
@ -3328,7 +3340,7 @@ HRESULT DirectX::GenerateMipMaps3D(
|
||||
|| IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
if (!_CalculateMipLevels3D(metadata.width, metadata.height, metadata.depth, levels))
|
||||
if (!CalculateMipLevels3D(metadata.width, metadata.height, metadata.depth, levels))
|
||||
return E_INVALIDARG;
|
||||
|
||||
if (levels <= 1)
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
@ -101,11 +102,11 @@ namespace
|
||||
for (size_t h = 0; h < image1.height; ++h)
|
||||
{
|
||||
XMVECTOR* ptr1 = scanline.get();
|
||||
if (!_LoadScanline(ptr1, width, pSrc1, rowPitch1, image1.format))
|
||||
if (!LoadScanline(ptr1, width, pSrc1, rowPitch1, image1.format))
|
||||
return E_FAIL;
|
||||
|
||||
XMVECTOR* ptr2 = scanline.get() + width;
|
||||
if (!_LoadScanline(ptr2, width, pSrc2, rowPitch2, image2.format))
|
||||
if (!LoadScanline(ptr2, width, pSrc2, rowPitch2, image2.format))
|
||||
return E_FAIL;
|
||||
|
||||
for (size_t i = 0; i < width; ++i)
|
||||
@ -198,7 +199,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < image.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), width, pSrc, rowPitch, image.format))
|
||||
if (!LoadScanline(scanline.get(), width, pSrc, rowPitch, image.format))
|
||||
return E_FAIL;
|
||||
|
||||
pixelFunc(scanline.get(), width, h);
|
||||
@ -242,7 +243,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
|
||||
if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
#ifdef _DEBUG
|
||||
@ -251,7 +252,7 @@ namespace
|
||||
|
||||
pixelFunc(dScanline, sScanline, width, h);
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, dScanline, width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, dScanline, width))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += spitch;
|
||||
@ -364,12 +365,12 @@ HRESULT DirectX::CopyRectangle(
|
||||
if (((pSrc + copyS) > pEndSrc) || ((pDest + copyD) > pEndDest))
|
||||
return E_FAIL;
|
||||
|
||||
if (!_LoadScanline(scanline.get(), srcRect.w, pSrc, copyS, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcRect.w, pSrc, copyS, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
_ConvertScanline(scanline.get(), srcRect.w, dstImage.format, srcImage.format, filter);
|
||||
ConvertScanline(scanline.get(), srcRect.w, dstImage.format, srcImage.format, filter);
|
||||
|
||||
if (!_StoreScanline(pDest, copyD, dstImage.format, scanline.get(), srcRect.w))
|
||||
if (!StoreScanline(pDest, copyD, dstImage.format, scanline.get(), srcRect.w))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -79,7 +80,7 @@ namespace
|
||||
if (!srcImage.pixels || !normalMap.pixels)
|
||||
return E_INVALIDARG;
|
||||
|
||||
const uint32_t convFlags = _GetConvertFlags(format);
|
||||
const uint32_t convFlags = GetConvertFlags(format);
|
||||
if (!convFlags)
|
||||
return E_FAIL;
|
||||
|
||||
@ -117,7 +118,7 @@ namespace
|
||||
const uint8_t* pSrc = srcImage.pixels;
|
||||
|
||||
// Read first scanline row into 'row1'
|
||||
if (!_LoadScanline(row1, width, pSrc, rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row1, width, pSrc, rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
// Setup 'row0'
|
||||
@ -129,7 +130,7 @@ namespace
|
||||
else
|
||||
{
|
||||
// Read last row (Wrap V)
|
||||
if (!_LoadScanline(row0, width, pSrc + (rowPitch * (height - 1)), rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row0, width, pSrc + (rowPitch * (height - 1)), rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -144,7 +145,7 @@ namespace
|
||||
// Load next scanline of source image
|
||||
if (y < (height - 1))
|
||||
{
|
||||
if (!_LoadScanline(row2, width, pSrc, rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row2, width, pSrc, rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -152,13 +153,13 @@ namespace
|
||||
if (flags & CNMAP_MIRROR_V)
|
||||
{
|
||||
// Use last row of source image
|
||||
if (!_LoadScanline(row2, width, srcImage.pixels + (rowPitch * (height - 1)), rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row2, width, srcImage.pixels + (rowPitch * (height - 1)), rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Use first row of source image (Wrap V)
|
||||
if (!_LoadScanline(row2, width, srcImage.pixels, rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row2, width, srcImage.pixels, rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
}
|
||||
}
|
||||
@ -227,7 +228,7 @@ namespace
|
||||
}
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, normalMap.rowPitch, format, target, width))
|
||||
if (!StoreScanline(pDest, normalMap.rowPitch, format, target, width))
|
||||
return E_FAIL;
|
||||
|
||||
// Cycle buffers
|
||||
|
||||
@ -203,17 +203,20 @@ using WICPixelFormatGUID = GUID;
|
||||
#define E_NOT_SUFFICIENT_BUFFER static_cast<HRESULT>(0x8007007AL)
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
namespace DirectX
|
||||
{
|
||||
//---------------------------------------------------------------------------------
|
||||
namespace Internal
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
// WIC helper functions
|
||||
#ifdef WIN32
|
||||
DXGI_FORMAT __cdecl _WICToDXGI(_In_ const GUID& guid) noexcept;
|
||||
bool __cdecl _DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) 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;
|
||||
|
||||
TEX_FILTER_FLAGS __cdecl _CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
|
||||
TEX_FILTER_FLAGS __cdecl CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
|
||||
|
||||
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ TEX_FILTER_FLAGS flags) noexcept
|
||||
inline WICBitmapDitherType __cdecl GetWICDither(_In_ TEX_FILTER_FLAGS flags) noexcept
|
||||
{
|
||||
static_assert(TEX_FILTER_DITHER == 0x10000, "TEX_FILTER_DITHER* flag values don't match mask");
|
||||
|
||||
@ -233,7 +236,7 @@ namespace DirectX
|
||||
}
|
||||
}
|
||||
|
||||
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ WIC_FLAGS flags) noexcept
|
||||
inline WICBitmapDitherType __cdecl GetWICDither(_In_ WIC_FLAGS flags) noexcept
|
||||
{
|
||||
switch (flags & TEX_FILTER_DITHER_MASK)
|
||||
{
|
||||
@ -248,7 +251,7 @@ namespace DirectX
|
||||
}
|
||||
}
|
||||
|
||||
inline WICBitmapInterpolationMode __cdecl _GetWICInterp(_In_ WIC_FLAGS flags) noexcept
|
||||
inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ WIC_FLAGS flags) noexcept
|
||||
{
|
||||
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
|
||||
|
||||
@ -274,7 +277,7 @@ namespace DirectX
|
||||
}
|
||||
}
|
||||
|
||||
inline WICBitmapInterpolationMode __cdecl _GetWICInterp(_In_ TEX_FILTER_FLAGS flags) noexcept
|
||||
inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ TEX_FILTER_FLAGS flags) noexcept
|
||||
{
|
||||
switch (flags & TEX_FILTER_MODE_MASK)
|
||||
{
|
||||
@ -296,11 +299,11 @@ namespace DirectX
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// Image helper functions
|
||||
_Success_(return) bool __cdecl _DetermineImageArray(
|
||||
_Success_(return) bool __cdecl DetermineImageArray(
|
||||
_In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
|
||||
_Out_ size_t& nImages, _Out_ size_t& pixelSize) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _SetupImageArray(
|
||||
_Success_(return) bool __cdecl SetupImageArray(
|
||||
_In_reads_bytes_(pixelSize) uint8_t* pMemory, _In_ size_t pixelSize,
|
||||
_In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
|
||||
_Out_writes_(nImages) Image* images, _In_ size_t nImages) noexcept;
|
||||
@ -339,69 +342,84 @@ namespace DirectX
|
||||
CONVF_RGBA_MASK = 0xF0000,
|
||||
};
|
||||
|
||||
uint32_t __cdecl _GetConvertFlags(_In_ DXGI_FORMAT format) noexcept;
|
||||
uint32_t __cdecl GetConvertFlags(_In_ DXGI_FORMAT format) noexcept;
|
||||
|
||||
void __cdecl _CopyScanline(
|
||||
void __cdecl CopyScanline(
|
||||
_When_(pDestination == pSource, _Inout_updates_bytes_(outSize))
|
||||
_When_(pDestination != pSource, _Out_writes_bytes_(outSize))
|
||||
void* pDestination, _In_ size_t outSize,
|
||||
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
|
||||
_In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
|
||||
|
||||
void __cdecl _SwizzleScanline(
|
||||
void __cdecl SwizzleScanline(
|
||||
_When_(pDestination == pSource, _In_)
|
||||
_When_(pDestination != pSource, _Out_writes_bytes_(outSize))
|
||||
void* pDestination, _In_ size_t outSize,
|
||||
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
|
||||
_In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _ExpandScanline(
|
||||
_Success_(return) bool __cdecl ExpandScanline(
|
||||
_Out_writes_bytes_(outSize) void* pDestination, _In_ size_t outSize,
|
||||
_In_ DXGI_FORMAT outFormat,
|
||||
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
|
||||
_In_ DXGI_FORMAT inFormat, _In_ uint32_t tflags) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _LoadScanline(
|
||||
_Success_(return) bool __cdecl LoadScanline(
|
||||
_Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size, _In_ DXGI_FORMAT format) noexcept;
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size,
|
||||
_In_ DXGI_FORMAT format) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _LoadScanlineLinear(
|
||||
_Success_(return) bool __cdecl LoadScanlineLinear(
|
||||
_Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size, _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS flags) noexcept;
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size,
|
||||
_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS flags) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _StoreScanline(
|
||||
_Success_(return) bool __cdecl StoreScanline(
|
||||
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
|
||||
_In_reads_(count) const XMVECTOR* pSource, _In_ size_t count, _In_ float threshold = 0) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _StoreScanlineLinear(
|
||||
_Success_(return) bool __cdecl StoreScanlineLinear(
|
||||
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
|
||||
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count, _In_ TEX_FILTER_FLAGS flags, _In_ float threshold = 0) noexcept;
|
||||
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
|
||||
_In_ TEX_FILTER_FLAGS flags, _In_ float threshold = 0) noexcept;
|
||||
|
||||
_Success_(return) bool __cdecl _StoreScanlineDither(
|
||||
_Success_(return) bool __cdecl StoreScanlineDither(
|
||||
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
|
||||
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count, _In_ float threshold, size_t y, size_t z,
|
||||
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
|
||||
_In_ float threshold, size_t y, size_t z,
|
||||
_Inout_updates_all_opt_(count + 2) XMVECTOR* pDiffusionErrors) noexcept;
|
||||
|
||||
HRESULT __cdecl _ConvertToR32G32B32A32(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
|
||||
HRESULT __cdecl ConvertToR32G32B32A32(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
|
||||
|
||||
HRESULT __cdecl _ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
|
||||
HRESULT __cdecl _ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ DXGI_FORMAT format, _Inout_ ScratchImage& image) noexcept;
|
||||
HRESULT __cdecl _ConvertFromR32G32B32A32(
|
||||
HRESULT __cdecl ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
|
||||
HRESULT __cdecl ConvertFromR32G32B32A32(
|
||||
_In_ const Image& srcImage, _In_ DXGI_FORMAT format, _Inout_ ScratchImage& image) noexcept;
|
||||
HRESULT __cdecl ConvertFromR32G32B32A32(
|
||||
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
|
||||
_In_ DXGI_FORMAT format, _Out_ ScratchImage& result) noexcept;
|
||||
|
||||
HRESULT __cdecl _ConvertToR16G16B16A16(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
|
||||
HRESULT __cdecl ConvertToR16G16B16A16(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
|
||||
|
||||
HRESULT __cdecl _ConvertFromR16G16B16A16(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
|
||||
HRESULT __cdecl ConvertFromR16G16B16A16(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
|
||||
|
||||
void __cdecl _ConvertScanline(
|
||||
void __cdecl ConvertScanline(
|
||||
_Inout_updates_all_(count) XMVECTOR* pBuffer, _In_ size_t count,
|
||||
_In_ DXGI_FORMAT outFormat, _In_ DXGI_FORMAT inFormat, _In_ TEX_FILTER_FLAGS flags) noexcept;
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// DDS helper functions
|
||||
HRESULT __cdecl _EncodeDDSHeader(
|
||||
_In_ const TexMetadata& metadata, DDS_FLAGS flags,
|
||||
_Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize, _Out_ size_t& required) noexcept;
|
||||
// Misc helper functions
|
||||
bool IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
|
||||
bool CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
|
||||
bool CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth,
|
||||
_Inout_ size_t& mipLevels) noexcept;
|
||||
|
||||
} // namespace
|
||||
#ifdef WIN32
|
||||
HRESULT ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC,
|
||||
_In_ bool iswic2,
|
||||
_In_ IWICBitmap* original,
|
||||
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter,
|
||||
_Inout_ const Image* img) noexcept;
|
||||
#endif
|
||||
|
||||
} // namespace Internal
|
||||
} // namespace DirectX
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -42,7 +43,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
XMVECTOR* ptr = scanline.get();
|
||||
@ -54,7 +55,7 @@ namespace
|
||||
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -87,7 +88,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
|
||||
XMVECTOR* ptr = scanline.get();
|
||||
@ -99,7 +100,7 @@ namespace
|
||||
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
|
||||
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -127,7 +128,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
XMVECTOR* ptr = scanline.get();
|
||||
@ -142,7 +143,7 @@ namespace
|
||||
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
@ -175,7 +176,7 @@ namespace
|
||||
|
||||
for (size_t h = 0; h < srcImage.height; ++h)
|
||||
{
|
||||
if (!_LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
|
||||
XMVECTOR* ptr = scanline.get();
|
||||
@ -190,7 +191,7 @@ namespace
|
||||
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
|
||||
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += srcImage.rowPitch;
|
||||
|
||||
@ -14,16 +14,9 @@
|
||||
#include "filters.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
#ifdef WIN32
|
||||
namespace DirectX
|
||||
{
|
||||
extern HRESULT _ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC, _In_ bool iswic2, _In_ IWICBitmap* original,
|
||||
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter, _Inout_ const Image* img) noexcept;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace
|
||||
{
|
||||
#ifdef WIN32
|
||||
@ -72,7 +65,7 @@ namespace
|
||||
|
||||
if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
|
||||
{
|
||||
hr = _ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), destImage.width, destImage.height, filter, &destImage);
|
||||
hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), destImage.width, destImage.height, filter, &destImage);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
}
|
||||
@ -83,7 +76,9 @@ namespace
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = scaler->Initialize(source.Get(), static_cast<UINT>(destImage.width), static_cast<UINT>(destImage.height), _GetWICInterp(filter));
|
||||
hr = scaler->Initialize(source.Get(),
|
||||
static_cast<UINT>(destImage.width), static_cast<UINT>(destImage.height),
|
||||
GetWICInterp(filter));
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -114,7 +109,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(scaler.Get(), pfGUID, _GetWICDither(filter), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(scaler.Get(), pfGUID, GetWICDither(filter), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -141,7 +137,7 @@ namespace
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
ScratchImage temp;
|
||||
HRESULT hr = _ConvertToR32G32B32A32(srcImage, temp);
|
||||
HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -164,7 +160,7 @@ namespace
|
||||
|
||||
temp.Release();
|
||||
|
||||
hr = _ConvertFromR32G32B32A32(*tdest, destImage);
|
||||
hr = ConvertFromR32G32B32A32(*tdest, destImage);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -281,7 +277,7 @@ namespace
|
||||
{
|
||||
if ((lasty ^ sy) >> 16)
|
||||
{
|
||||
if (!_LoadScanline(row, srcImage.width, pSrc + (rowPitch * (sy >> 16)), rowPitch, srcImage.format))
|
||||
if (!LoadScanline(row, srcImage.width, pSrc + (rowPitch * (sy >> 16)), rowPitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
lasty = sy;
|
||||
}
|
||||
@ -293,7 +289,7 @@ namespace
|
||||
sx += xinc;
|
||||
}
|
||||
|
||||
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, target, destImage.width))
|
||||
if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, target, destImage.width))
|
||||
return E_FAIL;
|
||||
pDest += destImage.rowPitch;
|
||||
|
||||
@ -307,6 +303,8 @@ namespace
|
||||
//--- Box Filter ---
|
||||
HRESULT ResizeBoxFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
assert(srcImage.pixels && destImage.pixels);
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
@ -338,13 +336,13 @@ namespace
|
||||
|
||||
for (size_t y = 0; y < destImage.height; ++y)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow0, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(urow0, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
|
||||
if (urow0 != urow1)
|
||||
{
|
||||
if (!_LoadScanlineLinear(urow1, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(urow1, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
pSrc += rowPitch;
|
||||
}
|
||||
@ -356,7 +354,7 @@ namespace
|
||||
AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
|
||||
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
|
||||
return E_FAIL;
|
||||
pDest += destImage.rowPitch;
|
||||
}
|
||||
@ -368,6 +366,8 @@ namespace
|
||||
//--- Linear Filter ---
|
||||
HRESULT ResizeLinearFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
assert(srcImage.pixels && destImage.pixels);
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
@ -383,8 +383,8 @@ namespace
|
||||
LinearFilter* lfX = lf.get();
|
||||
LinearFilter* lfY = lf.get() + destImage.width;
|
||||
|
||||
_CreateLinearFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
_CreateLinearFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
|
||||
CreateLinearFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
|
||||
CreateLinearFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
|
||||
|
||||
XMVECTOR* target = scanline.get();
|
||||
|
||||
@ -414,7 +414,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -430,7 +430,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -441,7 +441,7 @@ namespace
|
||||
BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
|
||||
}
|
||||
|
||||
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
|
||||
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
|
||||
return E_FAIL;
|
||||
pDest += destImage.rowPitch;
|
||||
}
|
||||
@ -453,6 +453,8 @@ namespace
|
||||
//--- Cubic Filter ---
|
||||
HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
assert(srcImage.pixels && destImage.pixels);
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
@ -468,8 +470,8 @@ namespace
|
||||
CubicFilter* cfX = cf.get();
|
||||
CubicFilter* cfY = cf.get() + destImage.width;
|
||||
|
||||
_CreateCubicFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
_CreateCubicFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
|
||||
CreateCubicFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
|
||||
CreateCubicFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
|
||||
|
||||
XMVECTOR* target = scanline.get();
|
||||
|
||||
@ -506,7 +508,7 @@ namespace
|
||||
{
|
||||
u0 = toY.u0;
|
||||
|
||||
if (!_LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u0 == u1)
|
||||
@ -539,7 +541,7 @@ namespace
|
||||
{
|
||||
u1 = toY.u1;
|
||||
|
||||
if (!_LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else if (toY.u1 == u2)
|
||||
@ -565,7 +567,7 @@ namespace
|
||||
{
|
||||
u2 = toY.u2;
|
||||
|
||||
if (!_LoadScanlineLinear(row2, srcImage.width, pSrc + (rowPitch * u2), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row2, srcImage.width, pSrc + (rowPitch * u2), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
else
|
||||
@ -582,7 +584,7 @@ namespace
|
||||
{
|
||||
u3 = toY.u3;
|
||||
|
||||
if (!_LoadScanlineLinear(row3, srcImage.width, pSrc + (rowPitch * u3), rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row3, srcImage.width, pSrc + (rowPitch * u3), rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
@ -600,7 +602,7 @@ namespace
|
||||
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))
|
||||
return E_FAIL;
|
||||
pDest += destImage.rowPitch;
|
||||
}
|
||||
@ -612,11 +614,11 @@ namespace
|
||||
//--- Triangle Filter ---
|
||||
HRESULT ResizeTriangleFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
||||
assert(srcImage.pixels && destImage.pixels);
|
||||
assert(srcImage.format == destImage.format);
|
||||
|
||||
using namespace TriangleFilter;
|
||||
|
||||
// Allocate initial temporary space (1 scanline, accumulation rows, plus X and Y filters)
|
||||
auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
|
||||
if (!scanline)
|
||||
@ -629,12 +631,12 @@ namespace
|
||||
TriangleRow * rowFree = nullptr;
|
||||
|
||||
std::unique_ptr<Filter> tfX;
|
||||
HRESULT hr = _Create(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
HRESULT hr = CreateTriangleFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
std::unique_ptr<Filter> tfY;
|
||||
hr = _Create(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
hr = CreateTriangleFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -701,7 +703,7 @@ namespace
|
||||
if ((pSrc + rowPitch) > pEndSrc)
|
||||
return E_FAIL;
|
||||
|
||||
if (!_LoadScanlineLinear(row, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
if (!LoadScanlineLinear(row, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
|
||||
return E_FAIL;
|
||||
|
||||
pSrc += rowPitch;
|
||||
@ -773,7 +775,7 @@ namespace
|
||||
}
|
||||
|
||||
// This performs any required clamping
|
||||
if (!_StoreScanlineLinear(pDest + (destImage.rowPitch * v), destImage.rowPitch, destImage.format, pAccSrc, destImage.width, filter))
|
||||
if (!StoreScanlineLinear(pDest + (destImage.rowPitch * v), destImage.rowPitch, destImage.format, pAccSrc, destImage.width, filter))
|
||||
return E_FAIL;
|
||||
|
||||
// Put row on freelist to reuse it's allocated scanline
|
||||
@ -866,7 +868,7 @@ HRESULT DirectX::Resize(
|
||||
bool usewic = UseWICFiltering(srcImage.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
bool wicpf = (usewic) ? _DXGIToWIC(srcImage.format, pfGUID, true) : false;
|
||||
bool wicpf = (usewic) ? DXGIToWIC(srcImage.format, pfGUID, true) : false;
|
||||
|
||||
if (usewic && !wicpf)
|
||||
{
|
||||
@ -953,7 +955,7 @@ HRESULT DirectX::Resize(
|
||||
bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
bool wicpf = (usewic) ? _DXGIToWIC(metadata.format, pfGUID, true) : false;
|
||||
bool wicpf = (usewic) ? DXGIToWIC(metadata.format, pfGUID, true) : false;
|
||||
|
||||
if (usewic && !wicpf)
|
||||
{
|
||||
|
||||
@ -20,6 +20,7 @@
|
||||
//
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -270,7 +271,7 @@ namespace
|
||||
|
||||
for (size_t y = 0; y < image->height; ++y)
|
||||
{
|
||||
_CopyScanline(pPixels, image->rowPitch, pPixels, image->rowPitch, image->format, TEXP_SCANLINE_SETALPHA);
|
||||
CopyScanline(pPixels, image->rowPitch, pPixels, image->rowPitch, image->format, TEXP_SCANLINE_SETALPHA);
|
||||
pPixels += image->rowPitch;
|
||||
}
|
||||
|
||||
@ -1792,7 +1793,7 @@ HRESULT DirectX::LoadFromTGAFile(
|
||||
|
||||
for (size_t h = 0; h < img->height; ++h)
|
||||
{
|
||||
_SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, mdata.format, tflags);
|
||||
SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, mdata.format, tflags);
|
||||
pPixels += rowPitch;
|
||||
}
|
||||
}
|
||||
@ -2115,11 +2116,11 @@ HRESULT DirectX::SaveToTGAMemory(
|
||||
}
|
||||
else if (convFlags & CONV_FLAGS_SWIZZLE)
|
||||
{
|
||||
_SwizzleScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
SwizzleScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
}
|
||||
else
|
||||
{
|
||||
_CopyScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
CopyScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
}
|
||||
|
||||
dPtr += rowPitch;
|
||||
@ -2268,11 +2269,11 @@ HRESULT DirectX::SaveToTGAFile(
|
||||
}
|
||||
else if (convFlags & CONV_FLAGS_SWIZZLE)
|
||||
{
|
||||
_SwizzleScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
SwizzleScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
}
|
||||
else
|
||||
{
|
||||
_CopyScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
CopyScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
|
||||
}
|
||||
|
||||
pPixels += image.rowPitch;
|
||||
|
||||
@ -133,7 +133,7 @@ namespace
|
||||
//=====================================================================================
|
||||
|
||||
_Use_decl_annotations_
|
||||
DXGI_FORMAT DirectX::_WICToDXGI(const GUID& guid) noexcept
|
||||
DXGI_FORMAT DirectX::Internal::WICToDXGI(const GUID& guid) noexcept
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
@ -153,7 +153,7 @@ DXGI_FORMAT DirectX::_WICToDXGI(const GUID& guid) noexcept
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::_DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) noexcept
|
||||
bool DirectX::Internal::DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) noexcept
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
@ -213,7 +213,7 @@ bool DirectX::_DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) no
|
||||
return false;
|
||||
}
|
||||
|
||||
TEX_FILTER_FLAGS DirectX::_CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept
|
||||
TEX_FILTER_FLAGS DirectX::Internal::CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept
|
||||
{
|
||||
TEX_FILTER_FLAGS srgb = TEX_FILTER_DEFAULT;
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "DirectXTexP.h"
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
namespace
|
||||
@ -99,7 +100,7 @@ namespace
|
||||
|
||||
*alphaMode = TEX_ALPHA_MODE_UNKNOWN;
|
||||
|
||||
DXGI_FORMAT format = _WICToDXGI(pixelFormat);
|
||||
DXGI_FORMAT format = WICToDXGI(pixelFormat);
|
||||
|
||||
if (format == DXGI_FORMAT_UNKNOWN)
|
||||
{
|
||||
@ -132,7 +133,7 @@ namespace
|
||||
if (pConvert)
|
||||
memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
|
||||
|
||||
format = _WICToDXGI(g_WICConvert[i].target);
|
||||
format = WICToDXGI(g_WICConvert[i].target);
|
||||
assert(format != DXGI_FORMAT_UNKNOWN);
|
||||
*alphaMode = g_WICConvert[i].alphaMode;
|
||||
break;
|
||||
@ -712,7 +713,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(frame, convertGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(frame, convertGUID, GetWICDither(flags), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -747,7 +749,7 @@ namespace
|
||||
return E_NOINTERFACE;
|
||||
|
||||
WICPixelFormatGUID sourceGUID;
|
||||
if (!_DXGIToWIC(metadata.format, sourceGUID))
|
||||
if (!DXGIToWIC(metadata.format, sourceGUID))
|
||||
return E_FAIL;
|
||||
|
||||
for (size_t index = 0; index < metadata.arraySize; ++index)
|
||||
@ -797,7 +799,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(frame.Get(), sourceGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(frame.Get(), sourceGUID, GetWICDither(flags), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -814,7 +817,9 @@ namespace
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = scaler->Initialize(frame.Get(), static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height), _GetWICInterp(flags));
|
||||
hr = scaler->Initialize(frame.Get(),
|
||||
static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height),
|
||||
GetWICInterp(flags));
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -845,7 +850,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(scaler.Get(), sourceGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(scaler.Get(), sourceGUID, GetWICDither(flags), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
@ -978,7 +984,7 @@ namespace
|
||||
return E_POINTER;
|
||||
|
||||
WICPixelFormatGUID pfGuid;
|
||||
if (!_DXGIToWIC(image.format, pfGuid))
|
||||
if (!DXGIToWIC(image.format, pfGuid))
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
||||
HRESULT hr = frame->Initialize(props);
|
||||
@ -1041,7 +1047,8 @@ namespace
|
||||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
hr = FC->Initialize(source.Get(), targetGuid, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut);
|
||||
hr = FC->Initialize(source.Get(), targetGuid, GetWICDither(flags), nullptr,
|
||||
0, WICBitmapPaletteTypeMedianCut);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
|
||||
@ -2463,16 +2463,16 @@ template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type, ty
|
||||
class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT
|
||||
{
|
||||
private:
|
||||
D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type;
|
||||
InnerStructType _Inner;
|
||||
D3D12_PIPELINE_STATE_SUBOBJECT_TYPE pssType;
|
||||
InnerStructType pssInner;
|
||||
public:
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : _Type(Type), _Inner(DefaultArg()) {}
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : _Type(Type), _Inner(i) {}
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { _Type = Type; _Inner = i; return *this; }
|
||||
operator InnerStructType const&() const noexcept { return _Inner; }
|
||||
operator InnerStructType&() noexcept { return _Inner; }
|
||||
InnerStructType* operator&() noexcept { return &_Inner; }
|
||||
InnerStructType const* operator&() const noexcept { return &_Inner; }
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : pssType(Type), pssInner(DefaultArg()) {}
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : pssType(Type), pssInner(i) {}
|
||||
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { pssType = Type; pssInner = i; return *this; }
|
||||
operator InnerStructType const&() const noexcept { return pssInner; }
|
||||
operator InnerStructType&() noexcept { return pssInner; }
|
||||
InnerStructType* operator&() noexcept { return &pssInner; }
|
||||
InnerStructType const* operator&() const noexcept { return &pssInner; }
|
||||
};
|
||||
#pragma warning(pop)
|
||||
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS;
|
||||
|
||||
@ -16,9 +16,11 @@
|
||||
|
||||
#include "scoped.h"
|
||||
|
||||
|
||||
namespace DirectX
|
||||
{
|
||||
|
||||
namespace Filters
|
||||
{
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Box filtering helpers
|
||||
//-------------------------------------------------------------------------------------
|
||||
@ -59,7 +61,7 @@ struct LinearFilter
|
||||
float weight1;
|
||||
};
|
||||
|
||||
inline void _CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
|
||||
inline void CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
|
||||
{
|
||||
assert(source > 0);
|
||||
assert(dest > 0);
|
||||
@ -159,7 +161,7 @@ struct CubicFilter
|
||||
float x;
|
||||
};
|
||||
|
||||
inline void _CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _In_ bool mirror, _Out_writes_(dest) CubicFilter* cf) noexcept
|
||||
inline void CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _In_ bool mirror, _Out_writes_(dest) CubicFilter* cf) noexcept
|
||||
{
|
||||
assert(source > 0);
|
||||
assert(dest > 0);
|
||||
@ -209,8 +211,6 @@ inline void _CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool w
|
||||
// Triangle filtering helpers
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
||||
namespace TriangleFilter
|
||||
{
|
||||
struct FilterTo
|
||||
{
|
||||
size_t u;
|
||||
@ -246,7 +246,7 @@ namespace TriangleFilter
|
||||
|
||||
constexpr float TF_EPSILON = 0.00001f;
|
||||
|
||||
inline HRESULT _Create(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Inout_ std::unique_ptr<Filter>& tf) noexcept
|
||||
inline HRESULT CreateTriangleFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Inout_ std::unique_ptr<Filter>& tf) noexcept
|
||||
{
|
||||
assert(source > 0);
|
||||
assert(dest > 0);
|
||||
@ -418,6 +418,5 @@ namespace TriangleFilter
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
} // namespace TriangleFilter
|
||||
|
||||
} // namespace Filters
|
||||
} // namespace DirectX
|
||||
|
||||
@ -768,7 +768,7 @@ namespace
|
||||
#endif
|
||||
}
|
||||
|
||||
IWICImagingFactory* _GetWIC() noexcept
|
||||
IWICImagingFactory* GetWIC() noexcept
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -1022,7 +1022,7 @@ HRESULT DirectX::SaveWICTextureToFile(
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
}
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
@ -863,7 +863,7 @@ namespace
|
||||
ifactory)) ? TRUE : FALSE;
|
||||
}
|
||||
|
||||
IWICImagingFactory2* _GetWIC() noexcept
|
||||
IWICImagingFactory2* GetWIC() noexcept
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -1200,7 +1200,7 @@ HRESULT DirectX::SaveWICTextureToFile(
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
@ -549,7 +549,7 @@ namespace
|
||||
#endif
|
||||
}
|
||||
|
||||
IWICImagingFactory* _GetWIC()
|
||||
IWICImagingFactory* GetWIC()
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -770,7 +770,7 @@ HRESULT DirectX::SaveWICTextureToFile(
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
}
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
@ -216,7 +216,7 @@ namespace
|
||||
#endif
|
||||
}
|
||||
|
||||
IWICImagingFactory* _GetWIC() noexcept
|
||||
IWICImagingFactory* GetWIC() noexcept
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -234,7 +234,7 @@ namespace
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
DXGI_FORMAT _WICToDXGI(const GUID& guid) noexcept
|
||||
DXGI_FORMAT WICToDXGI(const GUID& guid) noexcept
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
@ -254,9 +254,9 @@ namespace
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
size_t _WICBitsPerPixel(REFGUID targetGuid) noexcept
|
||||
size_t WICBitsPerPixel(REFGUID targetGuid) noexcept
|
||||
{
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return 0;
|
||||
|
||||
@ -449,7 +449,7 @@ namespace
|
||||
|
||||
size_t bpp = 0;
|
||||
|
||||
DXGI_FORMAT format = _WICToDXGI(pixelFormat);
|
||||
DXGI_FORMAT format = WICToDXGI(pixelFormat);
|
||||
if (format == DXGI_FORMAT_UNKNOWN)
|
||||
{
|
||||
if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
|
||||
@ -477,9 +477,9 @@ namespace
|
||||
{
|
||||
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
|
||||
|
||||
format = _WICToDXGI(g_WICConvert[i].target);
|
||||
format = WICToDXGI(g_WICConvert[i].target);
|
||||
assert(format != DXGI_FORMAT_UNKNOWN);
|
||||
bpp = _WICBitsPerPixel(convertGUID);
|
||||
bpp = WICBitsPerPixel(convertGUID);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -490,7 +490,7 @@ namespace
|
||||
}
|
||||
else
|
||||
{
|
||||
bpp = _WICBitsPerPixel(pixelFormat);
|
||||
bpp = WICBitsPerPixel(pixelFormat);
|
||||
}
|
||||
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
@ -609,7 +609,7 @@ namespace
|
||||
else if (twidth != width || theight != height)
|
||||
{
|
||||
// Resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -660,7 +660,7 @@ namespace
|
||||
else
|
||||
{
|
||||
// Format conversion but no resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -921,7 +921,7 @@ HRESULT DirectX::CreateWICTextureFromMemoryEx(
|
||||
if (wicDataSize > UINT32_MAX)
|
||||
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -1055,7 +1055,7 @@ HRESULT DirectX::CreateWICTextureFromFileEx(
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
@ -177,7 +177,7 @@ namespace
|
||||
ifactory)) ? TRUE : FALSE;
|
||||
}
|
||||
|
||||
IWICImagingFactory2* _GetWIC() noexcept
|
||||
IWICImagingFactory2* GetWIC() noexcept
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -253,7 +253,7 @@ namespace
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
DXGI_FORMAT _WICToDXGI(const GUID& guid) noexcept
|
||||
DXGI_FORMAT WICToDXGI(const GUID& guid) noexcept
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
@ -265,9 +265,9 @@ namespace
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
size_t _WICBitsPerPixel(REFGUID targetGuid) noexcept
|
||||
size_t WICBitsPerPixel(REFGUID targetGuid) noexcept
|
||||
{
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return 0;
|
||||
|
||||
@ -398,7 +398,7 @@ namespace
|
||||
|
||||
size_t bpp = 0;
|
||||
|
||||
DXGI_FORMAT format = _WICToDXGI(pixelFormat);
|
||||
DXGI_FORMAT format = WICToDXGI(pixelFormat);
|
||||
if (format == DXGI_FORMAT_UNKNOWN)
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICConvert); ++i)
|
||||
@ -407,9 +407,9 @@ namespace
|
||||
{
|
||||
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
|
||||
|
||||
format = _WICToDXGI(g_WICConvert[i].target);
|
||||
format = WICToDXGI(g_WICConvert[i].target);
|
||||
assert(format != DXGI_FORMAT_UNKNOWN);
|
||||
bpp = _WICBitsPerPixel(convertGUID);
|
||||
bpp = WICBitsPerPixel(convertGUID);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -419,7 +419,7 @@ namespace
|
||||
}
|
||||
else
|
||||
{
|
||||
bpp = _WICBitsPerPixel(pixelFormat);
|
||||
bpp = WICBitsPerPixel(pixelFormat);
|
||||
}
|
||||
|
||||
if (loadFlags & WIC_LOADER_FORCE_RGBA32)
|
||||
@ -510,7 +510,7 @@ namespace
|
||||
else if (twidth != width || theight != height)
|
||||
{
|
||||
// Resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -561,7 +561,7 @@ namespace
|
||||
else
|
||||
{
|
||||
// Format conversion but no resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -708,7 +708,7 @@ HRESULT DirectX::LoadWICTextureFromMemoryEx(
|
||||
if (wicDataSize > UINT32_MAX)
|
||||
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -789,7 +789,7 @@ HRESULT DirectX::LoadWICTextureFromFileEx(
|
||||
if (!d3dDevice || !fileName || !texture)
|
||||
return E_INVALIDARG;
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
@ -197,7 +197,7 @@ namespace
|
||||
#endif
|
||||
}
|
||||
|
||||
IWICImagingFactory* _GetWIC() noexcept
|
||||
IWICImagingFactory* GetWIC() noexcept
|
||||
{
|
||||
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
@ -215,7 +215,7 @@ namespace
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
D3DFORMAT _WICToD3D9(const GUID& guid) noexcept
|
||||
D3DFORMAT WICToD3D9(const GUID& guid) noexcept
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
@ -331,7 +331,7 @@ namespace
|
||||
WICPixelFormatGUID convertGUID;
|
||||
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &pixelFormat, sizeof(GUID));
|
||||
|
||||
D3DFORMAT format = _WICToD3D9(pixelFormat);
|
||||
D3DFORMAT format = WICToD3D9(pixelFormat);
|
||||
if (format == D3DFMT_UNKNOWN)
|
||||
{
|
||||
for (size_t i = 0; i < std::size(g_WICConvert); ++i)
|
||||
@ -340,7 +340,7 @@ namespace
|
||||
{
|
||||
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
|
||||
|
||||
format = _WICToD3D9(g_WICConvert[i].target);
|
||||
format = WICToD3D9(g_WICConvert[i].target);
|
||||
assert(format != D3DFMT_UNKNOWN);
|
||||
break;
|
||||
}
|
||||
@ -417,7 +417,7 @@ namespace
|
||||
else if (twidth != width || theight != height)
|
||||
{
|
||||
// Resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -484,7 +484,7 @@ namespace
|
||||
else
|
||||
{
|
||||
// Format conversion but no resize
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -569,7 +569,7 @@ HRESULT DirectX::CreateWICTextureFromMemoryEx(
|
||||
if (wicDataSize > UINT32_MAX)
|
||||
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
@ -627,7 +627,7 @@ HRESULT DirectX::CreateWICTextureFromFileEx(
|
||||
if (!d3dDevice || !fileName || !texture)
|
||||
return E_INVALIDARG;
|
||||
|
||||
auto pWIC = _GetWIC();
|
||||
auto pWIC = GetWIC();
|
||||
if (!pWIC)
|
||||
return E_NOINTERFACE;
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user