Method WriteTextureData

Source/Engine/Tools/TextureTool/TextureTool.cpp:604–658

#if USE_EDITOR

bool TextureTool::WriteTextureData(BytesContainer& result, const TextureData& textureData, int32 mipIndex)
{
    if (textureData.Format == PixelFormat::Basis)
    {
        // Store as-is, each slice is stored in a separate block with the same size
        int32 maxDataSize = 0;
        for (int32 arrayIndex = 0; arrayIndex < textureData.Items.Count(); arrayIndex++)
        {
            auto& mipData = textureData.Items[arrayIndex].Mips[mipIndex];
            maxDataSize = Math::Max(maxDataSize, mipData.Data.Length());
        }
        result.Allocate(maxDataSize * textureData.GetArraySize());
        for (int32 arrayIndex = 0; arrayIndex < textureData.Items.Count(); arrayIndex++)
        {
            auto& mipData = textureData.Items[arrayIndex].Mips[mipIndex];
            byte* dst = result.Get() + maxDataSize * arrayIndex;
            Platform::MemoryCopy(dst, mipData.Data.Get(), mipData.Data.Length());
            Platform::MemoryClear(dst + mipData.Data.Length(), maxDataSize - mipData.Data.Length());
        }
        return false;
    }

    // Calculate the texture data storage layout
    uint32 rowPitch, slicePitch;
    const int32 mipWidth = Math::Max(1, textureData.Width >> mipIndex);
    const int32 mipHeight = Math::Max(1, textureData.Height >> mipIndex);
    RenderTools::ComputePitch(textureData.Format, mipWidth, mipHeight, rowPitch, slicePitch);
    result.Allocate(slicePitch * textureData.GetArraySize());

    // Copy array slices into mip data (sequential)
    for (int32 arrayIndex = 0; arrayIndex < textureData.Items.Count(); arrayIndex++)
    {
        auto& mipData = textureData.Items[arrayIndex].Mips[mipIndex];
        const byte* src = mipData.Data.Get();
        byte* dst = result.Get() + (slicePitch * arrayIndex);

        // Faster path if source and destination data layout matches
        if (rowPitch == mipData.RowPitch && slicePitch == mipData.DepthPitch)
        {
            Platform::MemoryCopy(dst, src, slicePitch);
        }
        else
        {
            const uint32 copyRowSize = Math::Min(mipData.RowPitch, rowPitch);
            for (uint32 line = 0; line < mipData.Lines; line++)
            {
                Platform::MemoryCopy(dst, src, copyRowSize);
                src += mipData.RowPitch;
                dst += rowPitch;
            }
        }
    }

    return false;
}

#endif