Add ETC2 support (Pocket Edition textures)

oblivioncth · oblivioncth · commit 3cf1c3c796a5 · 2025-09-04T20:26:56.000-04:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -13,7 +13,7 @@ project(Stex
 
 # Get helper scripts
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/FetchOBCMake.cmake)
-fetch_ob_cmake("v0.3.7")
+fetch_ob_cmake("4640fe55c5ececb736331d5c379a2113760e9236")
 
 # Initialize project according to standard rules
 include(OB/Project)
@@ -70,6 +70,10 @@ ob_fetch_qx(
 include(OB/FetchLibSquish)
 ob_fetch_modern_libsquish("8a6aad970285a536170de9b3fc63735a72674561")
 
+# Fetch etc2comp
+include(OB/FetchEtc2Comp)
+ob_fetch_etc2comp("v1.0")
+
 # Process Targets
 set(APP_TARGET_NAME ${PROJECT_NAMESPACE_LC}_${PROJECT_NAMESPACE_LC})
 set(APP_ALIAS_NAME ${PROJECT_NAMESPACE})
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
@@ -46,6 +46,7 @@ ob_add_standard_executable(${APP_TARGET_NAME}
             Qx::Io
             Qx::Xml
             libsquish::Squish
+            Etc::Etc
     CONFIG STANDARD
 )
 
diff --git a/app/src/command/tex-command.h b/app/src/command/tex-command.h
@@ -63,6 +63,7 @@ class TexCommand : public Command
         {u"dxt5"_s, KTex::Header::PixelFormat::DXT5},
         {u"rgb"_s, KTex::Header::PixelFormat::RGB},
         {u"rgba"_s, KTex::Header::PixelFormat::RGBA},
+        {u"etc2eac"_s, KTex::Header::PixelFormat::ETC2EAC}
     };
 
     // Messages
diff --git a/app/src/conversion.cpp b/app/src/conversion.cpp
@@ -5,7 +5,10 @@
 #include <cstring>
 
 // Squish Includes
-#include "squish/squish.h"
+#include <squish/squish.h>
+
+// etc2comp Includes
+#include <Etc/EtcImage.h>
 
 // NOTE: The Qt image formats (QImage::Format) used here are all byte ordered based on the host system, yet squish (and DST?)
 // expect the input data to always be RGB(A), which means these won't work on Big Endian ordered systems;
@@ -84,6 +87,7 @@ QVector<QImage> ToTexConverter::generateMipMaps(const QImage& baseImage)
 
 QVector<KTex::MipMapImage> ToTexConverter::convertToTargetFormat(const QVector<QImage>& images)
 {
+    auto pxFormat = mOptions.pixelFormat;
     QVector<KTex::MipMapImage> outputImages;
 
     for(const QImage& image : images)
@@ -94,21 +98,72 @@ QVector<KTex::MipMapImage> ToTexConverter::convertToTargetFormat(const QVector<Q
         mipMap.setWidth(image.width());
         mipMap.setHeight(image.height());
 
-        // Uncompressed steps
-        if(mOptions.pixelFormat == KTex::Header::PixelFormat::RGBA ||
-           mOptions.pixelFormat == KTex::Header::PixelFormat::RGB)
-        {
-            mipMap.setPitch(image.bytesPerLine());
-            mipMap.setImageDataSize(image.sizeInBytes());
-            std::memcpy(mipMap.imageData().data(), image.bits(), image.sizeInBytes());
-        }
-        else // Compressed steps
+        // Encoder specific steps
+        switch(pxFormat) // Use variants, inheritance, or other functions for this if many more types are added
         {
-            int squishFlag = getSquishCompressionFlag(mOptions.pixelFormat);
-            mipMap.setPitch(squish::GetStorageRequirements(image.width(), 1, squishFlag));
-            mipMap.setImageDataSize(squish::GetStorageRequirements(image.width(), image.height(), squishFlag));
-            squish::CompressImage(image.bits(), image.width(), image.height(), image.bytesPerLine(),
-                                  mipMap.imageData().data(), squishFlag);
+            using enum KTex::Header::PixelFormat;
+
+            case RGB:
+            case RGBA:
+                mipMap.setPitch(image.bytesPerLine());
+                mipMap.setImageDataSize(image.sizeInBytes());
+                std::memcpy(mipMap.imageData().data(), image.bits(), image.sizeInBytes());
+                break;
+
+            case DXT1:
+            case DXT3:
+            case DXT5:
+            {
+                int squishFlag = getSquishCompressionFlag(pxFormat);
+                mipMap.setPitch(squish::GetStorageRequirements(image.width(), 1, squishFlag)); // Space for one row of blocks
+                mipMap.setImageDataSize(squish::GetStorageRequirements(image.width(), image.height(), squishFlag));
+                squish::CompressImage(image.bits(), image.width(), image.height(), image.bytesPerLine(),
+                                      mipMap.imageData().data(), squishFlag);
+            }
+
+            case ETC2EAC:
+            {
+                /* The pitch calculation below boils down to:
+                 *     p = blocks_per_row * block_size
+                 *     where
+                 *     block_size varies with format
+                 *     blocks_per_row = ceil(width/4)
+                 */
+
+                // Get texture info
+                auto etcFormat = Etc::Image::Format::RGBA8; // Make function for this, like for squish, if more ETC formats are supported
+
+                // Create ETC image
+                auto errMetric = image.isGrayscale() ? Etc::ErrorMetric::GRAY : Etc::ErrorMetric::NUMERIC; // Could try the Rec 709 option for color
+                /* The standard allows viewing a POD struct as a sequence of bytes (e.g. auto data = reinterpret_cast<uchar*>(myStruct)),
+                 * but does not allow the other way around; however, in the case of a very simple struct of ints, almost no known compiler
+                 * inserts padding between the members, so here we're gonna try what is technically UB, casting an array to a struct, since
+                 * it generally works and this application is non-critical. This is possible because each struct member is exactly 1-byte in
+                 * size and is laid out in the correct R-G-B-A order.
+                 *
+                 * This lib has a really strange interface, as it was hacked together by someone else after its initial creation.
+                 * You make an image with uncompressed pixel data, despite the type (Etc::Image) being named like you already have
+                 * a compressed image, and then call Encode.
+                 */
+                Etc::Image etcImage(etcFormat, (const Etc::ColorR8G8B8A8*)image.bits(), image.width(), image.height(), errMetric);
+
+                // Prepare mip-map
+                mipMap.setPitch(etcImage.GetNumberOfBlockColumns() * etcImage.GetBlockSize()); // Space for one row of blocks
+                mipMap.setImageDataSize(etcImage.GetEncodingBitsBytes());
+
+                // Encode
+                constexpr float quality = 90; /* (0-100) could add flag to allow adjusting, but awkward since its just for this format, though we could just
+                                               * say "for formats where it applies" and for now it's only this one. Kram uses 49 by default and states that
+                                               * unity uses "80".
+                                               */
+                auto status = etcImage.EncodeSinglepass(quality, reinterpret_cast<uchar*>(mipMap.imageData().data()));
+                if(status != Etc::Image::SUCCESS)
+                    qWarning("Unexpected ETC2 encode error: 0x%x", status);
+                break;
+            }
+
+            default:
+                qCritical("Unhandled encoding pixel format!");
         }
 
         outputImages.append(mipMap);
@@ -166,31 +221,63 @@ const KTex::MipMapImage& FromTexConverter::getMainImage() { return mSourceTex.mi
 
 QImage FromTexConverter::convertToStandardFormat(const KTex::MipMapImage& mainImage)
 {
-    QByteArray rawData;
-    quint16 pitch;
-    QImage::Format rawFormat = mSourceTex.header().pixelFormat() == KTex::Header::PixelFormat::RGB ? QImage::Format_RGB888 :
-                               mOptions.demultiplyAlpha ? QImage::Format_RGBA8888_Premultiplied : QImage::Format_RGBA8888;
-
-    // Uncompressed steps
-    if(mSourceTex.header().pixelFormat() == KTex::Header::PixelFormat::RGBA ||
-       mSourceTex.header().pixelFormat() == KTex::Header::PixelFormat::RGB)
-    {
-        pitch = mainImage.pitch();
-        rawData = mainImage.imageData(); // Implicit sharing avoids copy
-    }
-    else // Compressed steps
+    QByteArray decodedData;
+    quint16 decodedPitch{};
+    QImage::Format decodedFormat{};
+
+    auto pxFormat = mSourceTex.header().pixelFormat();
+    switch(pxFormat) // Use variants, inheritance, or other functions for this if many more types are added
     {
-        // Always outputs in RGBA
-        int squishFlag = getSquishCompressionFlag(mSourceTex.header().pixelFormat());
-        pitch = mainImage.width() * 4;
-        rawData.resize(mainImage.width() * mainImage.height() * 4);
-        squish::DecompressImage(reinterpret_cast<uchar*>(rawData.data()), mainImage.width(), mainImage.height(), pitch,
-                                mainImage.imageData().data(), squishFlag);
+        using enum KTex::Header::PixelFormat;
+
+        case RGB:
+            decodedFormat = QImage::Format_RGB888;
+            decodedPitch = mainImage.pitch();
+            decodedData = mainImage.imageData(); // Implicit sharing avoids copy
+            break;
+
+        case RGBA:
+            decodedFormat = mOptions.demultiplyAlpha ? QImage::Format_RGBA8888_Premultiplied : QImage::Format_RGBA8888;
+            decodedPitch = mainImage.pitch();
+            decodedData = mainImage.imageData(); // Implicit sharing avoids copy
+            break;
+
+        case DXT1:
+        case DXT3:
+        case DXT5:
+        {
+            decodedFormat = mOptions.demultiplyAlpha ? QImage::Format_RGBA8888_Premultiplied : QImage::Format_RGBA8888;
+            decodedPitch = mainImage.width() * 4;
+            int squishFlag = getSquishCompressionFlag(pxFormat);
+            decodedData.resize(mainImage.width() * mainImage.height() * 4);
+            squish::DecompressImage(reinterpret_cast<uchar*>(decodedData.data()), mainImage.width(), mainImage.height(), decodedPitch,
+                                    mainImage.imageData().data(), squishFlag);
+            break;
+        }
+
+        case ETC2EAC:
+        {
+            decodedFormat = mOptions.demultiplyAlpha ? QImage::Format_RGBA8888_Premultiplied : QImage::Format_RGBA8888;
+            decodedPitch = mainImage.width() * 4;
+            auto etcFormat = Etc::Image::Format::RGBA8; // Make function for this, like for squish, if more ETC formats are supported
+            decodedData.resize(mainImage.width() * mainImage.height() * 4);
+            /* This lib has a really strange interface, as it was hacked together by someone else after its initial creation.
+             * You make an image with no pixel data set and then pass the pixel data as part of the Encode call
+             */
+            Etc::Image etcImage(etcFormat, nullptr, 1024, 1024, Etc::ErrorMetric::NUMERIC);
+            auto status = etcImage.Decode(reinterpret_cast<const uchar*>(mainImage.imageData().data()),
+                                          reinterpret_cast<uchar*>(decodedData.data()));
+            if(status != Etc::Image::SUCCESS)
+                qWarning("Unexpected ETC2 decode error: 0x%x", status);
+            break;
+        }
 
+        default:
+            qCritical("Unhandled decoding pixel format!");
     }
 
     // Create QImage from buffer
-    QImage bufferedImage = QImage(reinterpret_cast<uchar*>(rawData.data()), mainImage.width(), mainImage.height(), pitch, rawFormat);
+    QImage bufferedImage = QImage(reinterpret_cast<uchar*>(decodedData.data()), mainImage.width(), mainImage.height(), decodedPitch, decodedFormat);
 
     // Copy and detach image so it isn't reliant on buffer that will be destroyed
     QImage standaloneImage = bufferedImage.copy();
diff --git a/app/src/klei/k-tex.cpp b/app/src/klei/k-tex.cpp
@@ -115,6 +115,7 @@ bool KTex::supportedPixelFormat(quint8 pixelFormatVal)
         case static_cast<quint8>(Header::PixelFormat::DXT5):
         case static_cast<quint8>(Header::PixelFormat::RGB):
         case static_cast<quint8>(Header::PixelFormat::RGBA):
+        case static_cast<quint8>(Header::PixelFormat::ETC2EAC): // GL_COMPRESSED_RGBA8_ETC2_EAC
             return true;
         default:
             return false;
diff --git a/app/src/klei/k-tex.h b/app/src/klei/k-tex.h
@@ -27,7 +27,8 @@ class KTex
             DXT3 = 0x01,
             DXT5 = 0x02,
             RGBA = 0x04,
-            RGB = 0x05
+            RGB = 0x05,
+            ETC2EAC = 0x11
         };
         enum class TextureType : quint8{
             OneD = 0x00,

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ ob_add_standard_executable(${APP_TARGET_NAME}`
`46`	`46`	`Qx::Io`
`47`	`47`	`Qx::Xml`
`48`	`48`	`libsquish::Squish`
	`49`	`+ Etc::Etc`
`49`	`50`	`CONFIG STANDARD`
`50`	`51`	`)`
`51`	`52`