Function setImage

Source/Falcor/Utils/Image/ImageIO.cpp:252–331

// if image compression needs to be maintained.
template<typename T>
void setImage(
    const void* subresourceData,
    nvtt::Surface& surface,
    ExportData image,
    uint32_t srcWidth,
    uint32_t srcHeight,
    uint32_t srcDepth
)
{
    std::vector<T> modified;
    uint32_t pixelCount = srcWidth * srcHeight * srcDepth;
    uint32_t channelCount = getFormatChannelCount(image.format);
    T alpha = T(0);

    // Need to flip red and blue channels for all 8 bit formats that aren't BGRA/BGRX as NVTT only supports BGRA inputs for these cases
    bool reverseRB = getNumChannelBits(image.format, 0) == 8 && image.format != ResourceFormat::BGRA8Unorm &&
                     image.format != ResourceFormat::BGRA8UnormSrgb && image.format != ResourceFormat::BGRX8Unorm &&
                     image.format != ResourceFormat::BGRX8UnormSrgb;
    // Need to fill the alpha channel with 1's for all formats that do not have an alpha channel
    bool fillAlpha = channelCount == 2 || channelCount == 3 || image.format == ResourceFormat::BGRX8Unorm ||
                     image.format == ResourceFormat::BGRX8UnormSrgb;

    modified.resize(4 * pixelCount);

    T* src = (T*)subresourceData;
    T* dst = (T*)modified.data();
    for (uint32_t h = 0; h < image.height; ++h)
    {
        for (uint32_t w = 0; w < image.width; ++w)
        {
            uint32_t i = h * srcWidth + w;    // Source data index
            uint32_t j = h * image.width + w; // Destination data index - Same as source index if no clamping is involved
            if (channelCount == 1)
            {
                dst[j] = T(src[i]);
            }
            else if (channelCount == 2)
            {
                dst[4 * j] = reverseRB ? T(0) : T(src[2 * i]);
                dst[4 * j + 1] = T(src[2 * i + 1]);
                dst[4 * j + 2] = reverseRB ? T(src[2 * i]) : T(0);
                dst[4 * j + 3] = T(0);
            }
            else if (channelCount == 3)
            {
                dst[4 * j] = reverseRB ? T(src[3 * i + 2]) : T(src[3 * i]);
                dst[4 * j + 1] = T(src[3 * i + 1]);
                dst[4 * j + 2] = reverseRB ? T(src[3 * i]) : T(src[3 * i + 2]);
                dst[4 * j + 3] = T(0);
            }
            else if (channelCount == 4)
            {
                dst[4 * j] = reverseRB ? T(src[4 * i + 2]) : T(src[4 * i]);
                dst[4 * j + 1] = T(src[4 * i + 1]);
                dst[4 * j + 2] = reverseRB ? T(src[4 * i]) : T(src[4 * i + 2]);
                dst[4 * j + 3] = T(src[4 * i + 3]);
            }
        }