Texture Loader: added option to compress textures into BC formats

Author: TheMostDiligent

TextureLoader/include/TextureLoaderImpl.hpp

@@ -76,6 +76,7 @@ class TextureLoaderImpl final : public ObjectBase<ITextureLoader>
     void LoadFromImage(Image* pImage, const TextureLoadInfo& TexLoadInfo);
     void LoadFromKTX(const TextureLoadInfo& TexLoadInfo, const Uint8* pData, size_t DataSize);
     void LoadFromDDS(const TextureLoadInfo& TexLoadInfo, const Uint8* pData, size_t DataSize);
+    void CompressSubresources(Uint32 NumComponents, Uint32 NumSrcComponents, const TextureLoadInfo& TexLoadInfo);
 
 private:
     RefCntAutoPtr<IDataBlob> m_pDataBlob;

TextureLoader/interface/TextureLoader.h

@@ -54,6 +54,29 @@ DILIGENT_TYPED_ENUM(TEXTURE_LOAD_MIP_FILTER, Uint8)
     TEXTURE_LOAD_MIP_FILTER_MOST_FREQUENT
 };
 
+/// Texture compression mode
+DILIGENT_TYPED_ENUM(TEXTURE_LOAD_COMPRESS_MODE, Uint8)
+{
+    /// Do not compress the texture.
+    TEXTURE_LOAD_COMPRESS_MODE_NONE = 0,
+
+    /// Compress the texture using BC compression.
+    /// 
+    /// \remarks    The BC texture format is selected based on the number of channels in the
+    ///             source image:
+    ///                 * R8    -> BC4_UNORM
+    ///                 * RG8   -> BC5_UNORM
+    ///                 * RGB8  -> BC1_UNORM / BC1_UNORM_SRGB
+    ///                 * RGBA8 -> BC3_UNORM / BC3_UNORM_SRGB
+    TEXTURE_LOAD_COMPRESS_MODE_BC,
+
+    /// Compress the texture using high-quality BC compression.
+    ///
+    /// \remarks    This mode is similar to TEXTURE_LOAD_COMPRESS_MODE_BC, but uses higher
+    ///             quality settings that result in better image quality at the cost of
+    ///             30%-40% longer compression time.
+    TEXTURE_LOAD_COMPRESS_MODE_BC_HIGH_QUAL,
+};
 
 /// Texture loading information
 struct TextureLoadInfo
@@ -100,6 +123,9 @@ struct TextureLoadInfo
     /// Coarse mip filter type, see Diligent::TEXTURE_LOAD_MIP_FILTER.
     TEXTURE_LOAD_MIP_FILTER MipFilter   DEFAULT_VALUE(TEXTURE_LOAD_MIP_FILTER_DEFAULT);
 
+    /// Texture compression mode, see Diligent::TEXTURE_LOAD_COMPRESS_MODE.
+    TEXTURE_LOAD_COMPRESS_MODE CompressMode DEFAULT_VALUE(TEXTURE_LOAD_COMPRESS_MODE_NONE);
+
     /// Texture component swizzle.
     ///
     /// \remarks    When the number of channels in the source image is less than

TextureLoader/src/TextureLoaderImpl.cpp

@@ -30,6 +30,7 @@
 #include <limits>
 #include <math.h>
 #include <vector>
+#include <array>
 
 #include "TextureLoaderImpl.hpp"
 #include "GraphicsAccessories.hpp"
@@ -43,6 +44,10 @@
 #include "DataBlobImpl.hpp"
 #include "Align.hpp"
 
+#define STB_DXT_STATIC
+#define STB_DXT_IMPLEMENTATION
+#include "../../ThirdParty/stb/stb_dxt.h"
+
 extern "C"
 {
     Diligent::DECODE_PNG_RESULT Diligent_DecodePng(Diligent::IDataBlob* pSrcPngBits,
@@ -194,8 +199,8 @@ void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexL
 {
     VERIFY_EXPR(pImage != nullptr);
 
-    const auto& ImgDesc  = pImage->GetDesc();
-    const auto  CompSize = GetValueSize(ImgDesc.ComponentType);
+    const ImageDesc& ImgDesc  = pImage->GetDesc();
+    const Uint32     CompSize = GetValueSize(ImgDesc.ComponentType);
 
     m_TexDesc.Type      = RESOURCE_DIM_TEX_2D;
     m_TexDesc.Width     = ImgDesc.Width;
@@ -335,8 +340,126 @@ void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexL
             }
         }
     }
+
+    if (TexLoadInfo.CompressMode != TEXTURE_LOAD_COMPRESS_MODE_NONE)
+    {
+        CompressSubresources(NumComponents, ImgDesc.NumComponents, TexLoadInfo);
+        m_pImage.Release();
+    }
 }
 
+void TextureLoaderImpl::CompressSubresources(Uint32 NumComponents, Uint32 NumSrcComponents, const TextureLoadInfo& TexLoadInfo)
+{
+    TEXTURE_FORMAT CompressedFormat = TEX_FORMAT_UNKNOWN;
+    switch (NumComponents)
+    {
+        case 1:
+            CompressedFormat = TEX_FORMAT_BC4_UNORM;
+            break;
+
+        case 2:
+            CompressedFormat = TEX_FORMAT_BC5_UNORM;
+            break;
+
+        case 4:
+            if (NumSrcComponents == 3)
+                CompressedFormat = TexLoadInfo.IsSRGB ? TEX_FORMAT_BC1_UNORM_SRGB : TEX_FORMAT_BC1_UNORM;
+            else if (NumSrcComponents == 4)
+                CompressedFormat = TexLoadInfo.IsSRGB ? TEX_FORMAT_BC3_UNORM_SRGB : TEX_FORMAT_BC3_UNORM;
+            else
+                UNEXPECTED("Unexpected number of source components ", NumSrcComponents);
+            break;
+
+        default:
+            UNEXPECTED("Unexpected number of components ", NumComponents);
+    }
+
+    if (CompressedFormat == TEX_FORMAT_UNKNOWN)
+        return;
+
+    m_TexDesc.Format                       = CompressedFormat;
+    const TextureFormatAttribs& FmtAttribs = GetTextureFormatAttribs(CompressedFormat);
+
+    std::vector<std::vector<Uint8>> CompressedMips(m_SubResources.size());
+    for (Uint32 slice = 0; slice < m_TexDesc.GetArraySize(); ++slice)
+    {
+        for (Uint32 mip = 0; mip < m_TexDesc.MipLevels; ++mip)
+        {
+            const Uint32        SubResIndex   = slice * m_TexDesc.MipLevels + mip;
+            TextureSubResData&  SubResData    = m_SubResources[SubResIndex];
+            std::vector<Uint8>& CompressedMip = CompressedMips[SubResIndex];
+
+            const MipLevelProperties CompressedMipProps = GetMipLevelProperties(m_TexDesc, mip);
+            const Uint32             MaxCol             = CompressedMipProps.LogicalWidth - 1;
+            const Uint32             MaxRow             = CompressedMipProps.LogicalHeight - 1;
+            const size_t             CompressedStride   = static_cast<size_t>(CompressedMipProps.RowSize);
+            CompressedMip.resize(CompressedStride * CompressedMipProps.StorageHeight);
+
+            for (Uint32 row = 0; row < CompressedMipProps.StorageHeight; row += FmtAttribs.BlockHeight)
+            {
+                const Uint32 row0 = row;
+                const Uint32 row1 = std::min(row + 1, MaxRow);
+                const Uint32 row2 = std::min(row + 2, MaxRow);
+                const Uint32 row3 = std::min(row + 3, MaxRow);
+
+                for (Uint32 col = 0; col < CompressedMipProps.StorageWidth; col += FmtAttribs.BlockWidth)
+                {
+                    const Uint32 col0 = col;
+                    const Uint32 col1 = std::min(col + 1, MaxCol);
+                    const Uint32 col2 = std::min(col + 2, MaxCol);
+                    const Uint32 col3 = std::min(col + 3, MaxCol);
+
+                    auto ReadBlockData = [&](auto& BlockData) {
+                        using T = typename std::decay_t<decltype(BlockData)>::value_type;
+
+                        const T*     SrcPtr    = static_cast<const T*>(SubResData.pData);
+                        const size_t SrcStride = static_cast<size_t>(SubResData.Stride) / sizeof(T);
+                        // clang-format off
+                        BlockData =
+                        {
+                            SrcPtr[col0 + SrcStride * row0], SrcPtr[col1 + SrcStride * row0], SrcPtr[col2 + SrcStride * row0], SrcPtr[col3 + SrcStride * row0],
+                            SrcPtr[col0 + SrcStride * row1], SrcPtr[col1 + SrcStride * row1], SrcPtr[col2 + SrcStride * row1], SrcPtr[col3 + SrcStride * row1],
+                            SrcPtr[col0 + SrcStride * row2], SrcPtr[col1 + SrcStride * row2], SrcPtr[col2 + SrcStride * row2], SrcPtr[col3 + SrcStride * row2],
+                            SrcPtr[col0 + SrcStride * row3], SrcPtr[col1 + SrcStride * row3], SrcPtr[col2 + SrcStride * row3], SrcPtr[col3 + SrcStride * row3]
+                        };
+                        // clang-format on
+                        return reinterpret_cast<const unsigned char*>(BlockData.data());
+                    };
+
+                    Uint8* pDst = &CompressedMip[(col / FmtAttribs.BlockWidth) * FmtAttribs.ComponentSize + CompressedStride * (row / FmtAttribs.BlockHeight)];
+                    if (NumComponents == 1)
+                    {
+                        std::array<Uint8, 16> BlockData8;
+                        stb_compress_bc4_block(pDst, ReadBlockData(BlockData8));
+                    }
+                    else if (NumComponents == 2)
+                    {
+                        std::array<Uint16, 16> BlockData16;
+                        stb_compress_bc5_block(pDst, ReadBlockData(BlockData16));
+                    }
+                    else if (NumComponents == 4)
+                    {
+                        std::array<Uint32, 16> BlockData32;
+                        const int              StbDxtMode = (TexLoadInfo.CompressMode == TEXTURE_LOAD_COMPRESS_MODE_BC_HIGH_QUAL) ? STB_DXT_HIGHQUAL : STB_DXT_NORMAL;
+                        const int              StoreAlpha = NumSrcComponents == 4 ? 1 : 0;
+                        stb_compress_dxt_block(pDst, ReadBlockData(BlockData32), StoreAlpha, StbDxtMode);
+                    }
+                    else
+                    {
+                        UNEXPECTED("Unexpected number of components");
+                    }
+                }
+            }
+
+            SubResData.pData  = CompressedMip.data();
+            SubResData.Stride = CompressedStride;
+        }
+    }
+
+    m_TexDesc.Width  = AlignUp(m_TexDesc.Width, FmtAttribs.BlockWidth);
+    m_TexDesc.Height = AlignUp(m_TexDesc.Height, FmtAttribs.BlockHeight);
+    m_Mips.swap(CompressedMips);
+}
 
 void CreateTextureLoaderFromFile(const char*            FilePath,
                                  IMAGE_FILE_FORMAT      FileFormat,