Add BC3 compressed texture support

Signed-off-by: Aleksander Kamiński <[email protected]>

Author: alek-kam-robotec-ai

Code/Source/Utilities/BlockCompression.cpp

@@ -0,0 +1,81 @@
+/* Copyright 2024, Robotec.ai sp. z o.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <Utilities/BlockCompression.h>
+
+namespace RGL::Utils
+{
+    AZStd::pair<size_t, size_t> BC3Block::GetBlockIndices(uint32_t width, uint32_t x, uint32_t y)
+    {
+        return AZ::RPI::BC1Block::GetBlockIndices(width, x, y);
+    }
+
+    AZ::Color BC3Block::GetBlockColor(size_t pixelIndex) const
+    {
+        AZ::Color color = m_bc1.GetBlockColor(pixelIndex);
+        color.SetA8(GetAlpha(pixelIndex));
+        return color;
+    }
+
+    static AZ::u8 LerpU8(AZ::u8 val0, AZ::u8 val1, AZ::u8 i, AZ::u8 n)
+    {
+        return (val0 * i + val1 * (n - i)) / n;
+    }
+
+    AZ::u8 BC3Block::GetAlpha(size_t pixelIndex) const
+    {
+        AZ_Assert(pixelIndex < 16, "Unsupported pixel index for BC3: %zu", pixelIndex);
+        static constexpr AZ::u8 IndexBitShift = 16U;
+        static constexpr AZ::u8 IndexBitCount = 3U;
+
+        const AZ::u8 valueBitShift = pixelIndex * IndexBitCount + IndexBitShift;
+        const AZ::u8 index = (m_alphaData >> valueBitShift) & 0b111;
+        if (m_referenceAlpha[0] > m_referenceAlpha[1])
+        {
+            switch (index)
+            {
+            case 0:
+            case 1:
+                return m_referenceAlpha[index];
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+                return LerpU8(m_referenceAlpha[1], m_referenceAlpha[0], index - 1U, 7U);
+            }
+        }
+        else
+        {
+            switch (index)
+            {
+            case 0:
+            case 1:
+                return m_referenceAlpha[index];
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+                return LerpU8(m_referenceAlpha[1], m_referenceAlpha[0], index - 1U, 5U);
+            case 6:
+                return 0U;
+            case 7:
+                return 255U;
+            }
+        }
+
+        return 0U;
+    }
+} // namespace RGL::Utils

Code/Source/Utilities/BlockCompression.h

@@ -0,0 +1,41 @@
+/* Copyright 2024, Robotec.ai sp. z o.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <AzCore/Math/Color.h>
+#include <Atom/RPI.Public/BlockCompression.h>
+#include <AzCore/base.h>
+
+namespace RGL::Utils
+{
+    struct BC3Block
+    {
+        static AZStd::pair<size_t, size_t> GetBlockIndices(uint32_t width, uint32_t x, uint32_t y);
+
+        [[nodiscard]] AZ::Color GetBlockColor(size_t pixelIndex) const;
+        [[nodiscard]] AZ::u8 GetAlpha(size_t pixelIndex) const;
+
+        union
+        {
+            AZ::u64 m_alphaData;
+            struct
+            {
+                AZ::u8 m_referenceAlpha[2];
+                AZ::u8 m_alphaIndices[6];
+            };
+        };
+        AZ::RPI::BC1Block m_bc1;
+    };
+} // namespace RGL::Utils

Code/Source/Wrappers/RglTexture.cpp

@@ -14,6 +14,7 @@
  */
 #include <Atom/RPI.Public/BlockCompression.h>
 #include <AzCore/Name/NameDictionary.h>
+#include <Utilities/BlockCompression.h>
 #include <Utilities/RGLUtils.h>
 #include <Wrappers/RglTexture.h>
 
@@ -86,7 +87,7 @@ namespace RGL::Wrappers
 
     float RglTexture::CreateGrayFromColor(const AZ::Color& color)
     {
-        return RedGrayMultiplier * color.GetR() + GreenGrayMultiplier * color.GetG() + BlueGrayMultiplier * color.GetB();
+        return (RedGrayMultiplier * color.GetR() + GreenGrayMultiplier * color.GetG() + BlueGrayMultiplier * color.GetB()) * color.GetA();
     }
 
     uint8_t RglTexture::CreateGray8FromColor(const AZ::Color& color)
@@ -119,7 +120,10 @@ namespace RGL::Wrappers
         using Format = AZ::RHI::Format;
         const auto format = imageDescriptor.m_format;
         const auto& size = imageDescriptor.m_size;
-        if (format == Format::BC1_UNORM || format == Format::BC1_UNORM_SRGB || format == Format::BC4_UNORM)
+        static AZStd::set<AZ::RHI::Format> SupportedFormats{
+            Format::BC1_UNORM, Format::BC1_UNORM_SRGB, Format::BC3_UNORM, Format::BC3_UNORM_SRGB, Format::BC4_UNORM,
+        };
+        if (SupportedFormats.contains(format))
         {
             tempRglTextureData.resize(size.m_width * size.m_height);
 
@@ -135,13 +139,18 @@ namespace RGL::Wrappers
                         LoadBlockToGrays(
                             reinterpret_cast<const AZ::RPI::BC4Block*>(imageData.data() + srcIdx), tempRglTextureData, x, y, size.m_width);
                     }
-                    else
+                    else if (format == Format::BC1_UNORM || format == Format::BC1_UNORM_SRGB)
                     {
                         LoadBlockToGrays(
                             reinterpret_cast<const AZ::RPI::BC1Block*>(imageData.data() + srcIdx), tempRglTextureData, x, y, size.m_width);
                     }
+                    else if (format == Format::BC3_UNORM || format == Format::BC3_UNORM_SRGB)
+                    {
+                        LoadBlockToGrays(
+                            reinterpret_cast<const Utils::BC3Block*>(imageData.data() + srcIdx), tempRglTextureData, x, y, size.m_width);
+                    }
 
-                    srcIdx += 8;
+                    srcIdx += GetFormatSize(format);
                     if (srcIdx == imageData.size() && ++sliceIdx < imageDescriptor.m_arraySize)
                     {
                         imageData = imageAsset->GetSubImageData(0, sliceIdx);
@@ -157,7 +166,8 @@ namespace RGL::Wrappers
             AZ_Warning(
                 ConstructTraceWindowName(__func__).c_str(),
                 false,
-                "Image is of unsupported type: %s. Only BC1 and BC4 formats are currently supported. Skipping...",
+                "Image \"%s\" is of unsupported type: %s. Only BC1 and BC4 formats are currently supported. Skipping...",
+                imageAsset.ToString<AZStd::string>().c_str(),
                 ToString(imageDescriptor.m_format));
         }
 

Code/rgl_files.cmake

@@ -36,6 +36,8 @@ set(FILES
         Source/Model/ModelLibrary.h
         Source/RGLSystemComponent.cpp
         Source/RGLSystemComponent.h
+        Source/Utilities/BlockCompression.cpp
+        Source/Utilities/BlockCompression.h
         Source/Utilities/RGLUtils.cpp
         Source/Utilities/RGLUtils.h
         Source/Wrappers/RglEntity.cpp