Skip to content

Commit 68b9cc7

Browse files
walbournwalbourn
committed
StandardSwizzle3D merged into main function
1 parent a41c71e commit 68b9cc7

File tree

2 files changed

+155
-129
lines changed

2 files changed

+155
-129
lines changed

‎DirectXTex/DirectXTex.h

+7-3
Original file line numberDiff line numberDiff line change
@@ -730,9 +730,13 @@ namespace DirectX
730730
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_ size_t item,
731731
_In_ float alphaReference, _Inout_ ScratchImage& mipChain) noexcept;
732732

733-
HRESULT __cdecl StandardSwizzle(_In_ const Image& srcImage, _In_ bool toSwizzle, _Out_ ScratchImage& image) noexcept;
734-
HRESULT __cdecl StandardSwizzle(_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_ bool toSwizzle, _Out_ ScratchImage& result) noexcept;
735-
HRESULT __cdecl StandardSwizzle3D(_In_reads_(depth) const Image* srcImages, _In_ size_t depth, _In_ const TexMetadata& metadata, _In_ bool toSwizzle, _Out_ ScratchImage& result) noexcept;
733+
HRESULT __cdecl StandardSwizzle(
734+
_In_ const Image& srcImage, _In_ bool toSwizzle,
735+
_Out_ ScratchImage& image) noexcept;
736+
HRESULT __cdecl StandardSwizzle(
737+
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_ bool toSwizzle,
738+
_Out_ ScratchImage& result) noexcept;
739+
// Performs row-major linear <-> z-order curve swizzling
736740

737741
enum TEX_PMALPHA_FLAGS : unsigned long
738742
{

‎DirectXTex/DirectXTexSwizzle.cpp

+148-126
Original file line numberDiff line numberDiff line change
@@ -60,14 +60,10 @@ namespace
6060
#else
6161
constexpr size_t MAX_TEXTURE_SIZE = UINT32_MAX;
6262
#endif
63-
}
64-
6563

6664
//-------------------------------------------------------------------------------------
6765
// 2D z-order curve
6866
//-------------------------------------------------------------------------------------
69-
namespace
70-
{
7167
constexpr uint16_t STANDARD_SWIZZLE_MASK_8 = 0b1010101000001111;
7268
constexpr uint16_t STANDARD_SWIZZLE_MASK_16 = 0b1010101010001111;
7369
constexpr uint16_t STANDARD_SWIZZLE_MASK_32 = 0b1010101010001111;
@@ -199,24 +195,90 @@ namespace
199195

200196
return S_OK;
201197
}
198+
199+
200+
//-------------------------------------------------------------------------------------
201+
// 3D z-order curve
202+
//-------------------------------------------------------------------------------------
203+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_8 = 0b1001000000001111;
204+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_16 = 0b1001000000001111;
205+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_32 = 0b1001001000001111;
206+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_64 = 0b1001001100001111;
207+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_128 = 0b1001001100001111;
208+
209+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_8 = 0b0100101000110000;
210+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_16 = 0b0100101000110001;
211+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_32 = 0b0100100100110011;
212+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_64 = 0b0100100000110111;
213+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_128 = 0b0100100000111111;
214+
215+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_8 = 0b0010010111000000;
216+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_16 = 0b0010010111000001;
217+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_32 = 0b0010010011000011;
218+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_64 = 0b0010010011000111;
219+
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_128 = 0b0010010011001111;
220+
221+
inline int GetSwizzleMask3D_X(size_t bytesPerPixel) noexcept
222+
{
223+
switch(bytesPerPixel)
224+
{
225+
case 1: return VOLUME_STANDARD_SWIZZLE_X_8;
226+
case 2: return VOLUME_STANDARD_SWIZZLE_X_16;
227+
case 8: return VOLUME_STANDARD_SWIZZLE_X_64;
228+
case 16: return VOLUME_STANDARD_SWIZZLE_X_128;
229+
default: return VOLUME_STANDARD_SWIZZLE_X_32;
230+
}
231+
}
232+
233+
inline int GetSwizzleMask3D_Y(size_t bytesPerPixel) noexcept
234+
{
235+
switch(bytesPerPixel)
236+
{
237+
case 1: return VOLUME_STANDARD_SWIZZLE_Y_8;
238+
case 2: return VOLUME_STANDARD_SWIZZLE_Y_16;
239+
case 8: return VOLUME_STANDARD_SWIZZLE_Y_64;
240+
case 16: return VOLUME_STANDARD_SWIZZLE_Y_128;
241+
default: return VOLUME_STANDARD_SWIZZLE_Y_32;
242+
}
243+
}
244+
245+
inline int GetSwizzleMask3D_Z(size_t bytesPerPixel) noexcept
246+
{
247+
switch(bytesPerPixel)
248+
{
249+
case 1: return VOLUME_STANDARD_SWIZZLE_Z_8;
250+
case 2: return VOLUME_STANDARD_SWIZZLE_Z_16;
251+
case 8: return VOLUME_STANDARD_SWIZZLE_Z_64;
252+
case 16: return VOLUME_STANDARD_SWIZZLE_Z_128;
253+
default: return VOLUME_STANDARD_SWIZZLE_Z_32;
254+
}
255+
}
202256
}
203257

258+
259+
//=====================================================================================
260+
// Entry points
261+
//=====================================================================================
262+
204263
_Use_decl_annotations_
205264
HRESULT DirectX::StandardSwizzle(
206265
const Image& srcImage,
207266
bool toSwizzle,
208267
ScratchImage& result) noexcept
209268
{
210-
if (srcImage.height == 1
269+
if ((srcImage.height == 1)
211270
|| (srcImage.width > MAX_TEXTURE_DIMENSION) || (srcImage.height > MAX_TEXTURE_DIMENSION))
212271
{
213272
// Standard Swizzle is not defined for 1D textures or textures larger than 16k
214-
return E_INVALIDARG;
273+
return HRESULT_E_NOT_SUPPORTED;
215274
}
216275

217276
if (IsPlanar(srcImage.format) || IsPalettized(srcImage.format) || (srcImage.format == DXGI_FORMAT_R1_UNORM))
218277
return HRESULT_E_NOT_SUPPORTED;
219278

279+
if (!srcImage.pixels)
280+
return E_POINTER;
281+
220282
HRESULT hr = result.Initialize2D(srcImage.format, srcImage.width, srcImage.height, 1, 1);
221283
if (FAILED(hr))
222284
return hr;
@@ -296,11 +358,16 @@ HRESULT DirectX::StandardSwizzle(
296358
bool toSwizzle,
297359
ScratchImage& result) noexcept
298360
{
299-
if (!srcImages || !nimages
300-
|| (metadata.dimension != TEX_DIMENSION_TEXTURE2D)
301-
|| (metadata.width > MAX_TEXTURE_DIMENSION) || (metadata.height > MAX_TEXTURE_DIMENSION))
361+
if (!srcImages || !nimages)
302362
return E_INVALIDARG;
303363

364+
if (((metadata.dimension != TEX_DIMENSION_TEXTURE2D) && (metadata.dimension != TEX_DIMENSION_TEXTURE3D))
365+
|| (metadata.width > MAX_TEXTURE_DIMENSION) || (metadata.height > MAX_TEXTURE_DIMENSION))
366+
{
367+
// Standard Swizzle is not defined for 1D textures or textures larger than 16k
368+
return HRESULT_E_NOT_SUPPORTED;
369+
}
370+
304371
if (IsPlanar(metadata.format) || IsPalettized(metadata.format) || (metadata.format == DXGI_FORMAT_R1_UNORM))
305372
return HRESULT_E_NOT_SUPPORTED;
306373

@@ -329,141 +396,95 @@ HRESULT DirectX::StandardSwizzle(
329396
return E_POINTER;
330397
}
331398

332-
for (size_t index = 0; index < nimages; ++index)
399+
if (metadata.dimension == TEX_DIMENSION_TEXTURE3D)
400+
{
401+
// TODO -
402+
return E_NOTIMPL;
403+
}
404+
else
333405
{
334-
const Image& src = srcImages[index];
335-
if (src.format != metadata.format)
406+
// Handle the 2D case for TEX_DIMENSION_TEXTURE2D
407+
for (size_t index = 0; index < nimages; ++index)
336408
{
337-
result.Release();
338-
return E_FAIL;
339-
}
409+
const Image& src = srcImages[index];
410+
if (src.format != metadata.format)
411+
{
412+
result.Release();
413+
return E_FAIL;
414+
}
340415

341-
if ((src.width > MAX_TEXTURE_DIMENSION) || (src.height > MAX_TEXTURE_DIMENSION))
342-
return E_FAIL;
416+
if ((src.width > MAX_TEXTURE_DIMENSION) || (src.height > MAX_TEXTURE_DIMENSION))
417+
{
418+
result.Release();
419+
return E_FAIL;
420+
}
343421

344-
const Image& dst = dest[index];
345-
assert(dst.format == metadata.format);
422+
const Image& dst = dest[index];
423+
assert(dst.format == metadata.format);
346424

347-
if (src.width != dst.width || src.height != dst.height)
348-
{
349-
result.Release();
350-
return E_FAIL;
351-
}
425+
if (src.width != dst.width || src.height != dst.height)
426+
{
427+
result.Release();
428+
return E_FAIL;
429+
}
352430

353-
if (toSwizzle)
354-
{
355-
switch(bytesPerPixel)
431+
if (toSwizzle)
356432
{
357-
case 1:
358-
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_8, 1>(src, dst, false);
359-
break;
360-
case 2:
361-
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_16, 2>(src, dst, false);
362-
break;
363-
case 8:
364-
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_64, 8>(src, dst, isCompressed);
365-
break;
366-
case 16:
367-
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_128, 16>(src, dst, isCompressed);
368-
break;
369-
default:
370-
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_32, 4>(src, dst, false);
371-
break;
433+
switch(bytesPerPixel)
434+
{
435+
case 1:
436+
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_8, 1>(src, dst, false);
437+
break;
438+
case 2:
439+
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_16, 2>(src, dst, false);
440+
break;
441+
case 8:
442+
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_64, 8>(src, dst, isCompressed);
443+
break;
444+
case 16:
445+
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_128, 16>(src, dst, isCompressed);
446+
break;
447+
default:
448+
hr = LinearToStandardSwizzle2D<STANDARD_SWIZZLE_MASK_32, 4>(src, dst, false);
449+
break;
450+
}
372451
}
373-
}
374-
else
375-
{
376-
switch(bytesPerPixel)
452+
else
377453
{
378-
case 1:
379-
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_8, 1>(src, dst, false);
380-
break;
381-
case 2:
382-
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_16, 2>(src, dst, false);
383-
break;
384-
case 8:
385-
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_64, 8>(src, dst, isCompressed);
386-
break;
387-
case 16:
388-
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_128, 16>(src, dst, isCompressed);
389-
break;
390-
default:
391-
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_32, 4>(src, dst, false);
392-
break;
454+
switch(bytesPerPixel)
455+
{
456+
case 1:
457+
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_8, 1>(src, dst, false);
458+
break;
459+
case 2:
460+
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_16, 2>(src, dst, false);
461+
break;
462+
case 8:
463+
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_64, 8>(src, dst, isCompressed);
464+
break;
465+
case 16:
466+
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_128, 16>(src, dst, isCompressed);
467+
break;
468+
default:
469+
hr = StandardSwizzleToLinear2D<STANDARD_SWIZZLE_MASK_32, 4>(src, dst, false);
470+
break;
471+
}
393472
}
394-
}
395473

396-
if (FAILED(hr))
397-
{
398-
result.Release();
399-
return hr;
474+
if (FAILED(hr))
475+
{
476+
result.Release();
477+
return hr;
478+
}
400479
}
401480
}
402481

403482
return S_OK;
404483
}
405484

406485

407-
//-------------------------------------------------------------------------------------
408-
// 3D z-order curve
409-
//-------------------------------------------------------------------------------------
410-
namespace
411-
{
412-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_8 = 0b1001000000001111;
413-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_16 = 0b1001000000001111;
414-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_32 = 0b1001001000001111;
415-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_64 = 0b1001001100001111;
416-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_X_128 = 0b1001001100001111;
417-
418-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_8 = 0b0100101000110000;
419-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_16 = 0b0100101000110001;
420-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_32 = 0b0100100100110011;
421-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_64 = 0b0100100000110111;
422-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Y_128 = 0b0100100000111111;
423-
424-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_8 = 0b0010010111000000;
425-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_16 = 0b0010010111000001;
426-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_32 = 0b0010010011000011;
427-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_64 = 0b0010010011000111;
428-
constexpr uint16_t VOLUME_STANDARD_SWIZZLE_Z_128 = 0b0010010011001111;
429-
430-
inline int GetSwizzleMask3D_X(size_t bytesPerPixel) noexcept
431-
{
432-
switch(bytesPerPixel)
433-
{
434-
case 1: return VOLUME_STANDARD_SWIZZLE_X_8;
435-
case 2: return VOLUME_STANDARD_SWIZZLE_X_16;
436-
case 8: return VOLUME_STANDARD_SWIZZLE_X_64;
437-
case 16: return VOLUME_STANDARD_SWIZZLE_X_128;
438-
default: return VOLUME_STANDARD_SWIZZLE_X_32;
439-
}
440-
}
441-
442-
inline int GetSwizzleMask3D_Y(size_t bytesPerPixel) noexcept
443-
{
444-
switch(bytesPerPixel)
445-
{
446-
case 1: return VOLUME_STANDARD_SWIZZLE_Y_8;
447-
case 2: return VOLUME_STANDARD_SWIZZLE_Y_16;
448-
case 8: return VOLUME_STANDARD_SWIZZLE_Y_64;
449-
case 16: return VOLUME_STANDARD_SWIZZLE_Y_128;
450-
default: return VOLUME_STANDARD_SWIZZLE_Y_32;
451-
}
452-
}
453-
454-
inline int GetSwizzleMask3D_Z(size_t bytesPerPixel) noexcept
455-
{
456-
switch(bytesPerPixel)
457-
{
458-
case 1: return VOLUME_STANDARD_SWIZZLE_Z_8;
459-
case 2: return VOLUME_STANDARD_SWIZZLE_Z_16;
460-
case 8: return VOLUME_STANDARD_SWIZZLE_Z_64;
461-
case 16: return VOLUME_STANDARD_SWIZZLE_Z_128;
462-
default: return VOLUME_STANDARD_SWIZZLE_Z_32;
463-
}
464-
}
465-
}
466-
486+
#if 0
487+
// TODO: merging into main based on metadata
467488
_Use_decl_annotations_
468489
HRESULT DirectX::StandardSwizzle3D(
469490
const Image* srcImages,
@@ -566,3 +587,4 @@ HRESULT DirectX::StandardSwizzle3D(
566587

567588
return S_OK;
568589
}
590+
#endif

0 commit comments

Comments
 (0)