Add functions to support Standard Swizzle textures

[isplunke]

Implement z-order curve "swizzling" for 2D and 3D textures to support the pixel order used for "Standard Swizzle" as defined by D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE.

These functions only perform the row-major <=> z-order curve operation. 64KB alignment, miptail packing, and other requirements are handled in other distinct operations.

[isplunke]

@microsoft-github-policy-service agree company="Microsoft"

[walbourn]

This only works for 2D arrays without mipmaps. For some example of more general scenarios (mips, arrays with mips, volumes, volumes with mips) see TransformImage in DirectXTexMisc.cpp

[isplunke]

Looked at TransformImage in DirectXTexMisc.cpp. I only saw mips being used in the 3d case. And even in that one, we're kind of just iterating for index = 0; index < nImages.

In the case: array of 2d images, we're iterating through each image independantley. So I don't think there's anything new to do there?

In the 3d case. I should separate slice (which is being swizzled) and layer( which is not being swizzled). But what order is the array of srcImages? layerMajor or sliceMajor?

[walbourn]

For the 3D case, my understanding is you would do:

size_t width = mdata.width;
size_t height = mdata.height;
size_t depth = mdata.depth;
for (size_t level = 0; level < mdata.mipLevels; ++level)
{
    auto destPtrBase = result.GetImage(level, 0, 0); // All slices of a given depth are always continuous in ScratchImage.
    for(size_t z = 0; z < depth; ++z)
    {
        auto srcImage = result.GetImage(level, 0, z);
        for(size_t h = 0; h < height; ++h)
        {
            for(size_t x = 0; 0 < width; ++w)
            {
                // swizzle using x, y, z copying from srcImage to destPtrBase + swizzleIndex
            }
        }
    }

    if (height > 1)
        height >>= 1;

    if (width > 1)
        width >>= 1;

    if (depth > 1)
        depth >>= 1;
}

[walbourn]

Note for testing, I'll add coverage to the test suite which will likely just do a swizzle and deswizzle and make sure the bits match.

As for determining if the swizzle is correct, I probably need to make a test app that renders using WARP which supports standard swizzle.