Add .astc texture replacement support

Previously, we only supported ASTC .dds
files, which are non-standard.

Author: encounter

cmake/aurora_gx.cmake

@@ -4,6 +4,7 @@ add_library(aurora_gx STATIC
         lib/gfx/depth_peek.cpp
         lib/gfx/pipeline_cache.cpp
         lib/gfx/render_worker.cpp
+        lib/gfx/astc_io.cpp
         lib/gfx/dds_io.cpp
         lib/gfx/tex_copy_conv.cpp
         lib/gfx/tex_palette_conv.cpp

lib/gfx/astc_io.cpp

@@ -0,0 +1,118 @@
+#include "astc_io.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <filesystem>
+#include <utility>
+
+#include "dds_io.hpp"
+#include "texture.hpp"
+
+namespace aurora::gfx::astc {
+namespace {
+struct ASTCHeader {
+  uint8_t magic[4];
+  uint8_t blockWidth;
+  uint8_t blockHeight;
+  uint8_t blockDepth;
+  uint8_t xSize[3];
+  uint8_t ySize[3];
+  uint8_t zSize[3];
+};
+static_assert(sizeof(ASTCHeader) == 16);
+
+constexpr std::array<uint8_t, 4> kASTCMagic{0x13, 0xab, 0xa1, 0x5c};
+
+uint32_t read_u24_le(const uint8_t bytes[3]) noexcept {
+  return static_cast<uint32_t>(bytes[0]) | (static_cast<uint32_t>(bytes[1]) << 8) |
+         (static_cast<uint32_t>(bytes[2]) << 16);
+}
+
+std::optional<wgpu::TextureFormat> resolve_astc_format(uint8_t blockWidth, uint8_t blockHeight,
+                                                       uint8_t blockDepth) noexcept {
+  if (blockDepth != 1) {
+    return std::nullopt;
+  }
+
+  switch ((static_cast<uint32_t>(blockWidth) << 8) | blockHeight) {
+  case 0x0404:
+    return wgpu::TextureFormat::ASTC4x4Unorm;
+  case 0x0504:
+    return wgpu::TextureFormat::ASTC5x4Unorm;
+  case 0x0505:
+    return wgpu::TextureFormat::ASTC5x5Unorm;
+  case 0x0605:
+    return wgpu::TextureFormat::ASTC6x5Unorm;
+  case 0x0606:
+    return wgpu::TextureFormat::ASTC6x6Unorm;
+  case 0x0805:
+    return wgpu::TextureFormat::ASTC8x5Unorm;
+  case 0x0806:
+    return wgpu::TextureFormat::ASTC8x6Unorm;
+  case 0x0808:
+    return wgpu::TextureFormat::ASTC8x8Unorm;
+  case 0x0a05:
+    return wgpu::TextureFormat::ASTC10x5Unorm;
+  case 0x0a06:
+    return wgpu::TextureFormat::ASTC10x6Unorm;
+  case 0x0a08:
+    return wgpu::TextureFormat::ASTC10x8Unorm;
+  case 0x0a0a:
+    return wgpu::TextureFormat::ASTC10x10Unorm;
+  case 0x0c0a:
+    return wgpu::TextureFormat::ASTC12x10Unorm;
+  case 0x0c0c:
+    return wgpu::TextureFormat::ASTC12x12Unorm;
+  default:
+    return std::nullopt;
+  }
+}
+} // namespace
+
+std::optional<ConvertedTexture> parse_astc_bytes(ArrayRef<uint8_t> bytes) noexcept {
+  if (bytes.size() < sizeof(ASTCHeader)) {
+    return std::nullopt;
+  }
+
+  const auto* header = reinterpret_cast<const ASTCHeader*>(bytes.data());
+  if (!std::equal(kASTCMagic.begin(), kASTCMagic.end(), header->magic)) {
+    return std::nullopt;
+  }
+
+  const uint32_t width = read_u24_le(header->xSize);
+  const uint32_t height = read_u24_le(header->ySize);
+  const uint32_t depth = read_u24_le(header->zSize);
+  if (width == 0 || height == 0 || depth != 1) {
+    return std::nullopt;
+  }
+
+  const auto format = resolve_astc_format(header->blockWidth, header->blockHeight, header->blockDepth);
+  if (!format.has_value()) {
+    return std::nullopt;
+  }
+
+  const auto expectedSize = calc_texture_size(*format, width, height, 1);
+  if (expectedSize == 0 || sizeof(ASTCHeader) + expectedSize > bytes.size()) {
+    return std::nullopt;
+  }
+
+  ByteBuffer data{expectedSize};
+  std::memcpy(data.data(), bytes.data() + sizeof(ASTCHeader), data.size());
+  return ConvertedTexture{
+      .format = *format,
+      .width = width,
+      .height = height,
+      .mips = 1,
+      .data = std::move(data),
+  };
+}
+
+std::optional<ConvertedTexture> load_astc_file(const std::filesystem::path& path) noexcept {
+  const auto bytes = dds::read_binary_file(path);
+  if (!bytes.has_value()) {
+    return std::nullopt;
+  }
+  return parse_astc_bytes(*bytes);
+}
+} // namespace aurora::gfx::astc

lib/gfx/astc_io.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "common.hpp"
+#include "texture_convert.hpp"
+
+#include <filesystem>
+#include <optional>
+
+namespace aurora::gfx::astc {
+std::optional<ConvertedTexture> parse_astc_bytes(ArrayRef<uint8_t> bytes) noexcept;
+std::optional<ConvertedTexture> load_astc_file(const std::filesystem::path& path) noexcept;
+} // namespace aurora::gfx::astc

lib/gfx/texture_replacement.cpp

@@ -4,6 +4,7 @@
 #include "../gx/gx.hpp"
 #include "../internal.hpp"
 #include "../webgpu/gpu.hpp"
+#include "astc_io.hpp"
 #include "dds_io.hpp"
 #include "png_io.hpp"
 #include "texture_convert.hpp"
@@ -112,6 +113,10 @@ bool iequals_ascii(std::string_view lhs, std::string_view rhs) noexcept {
   return true;
 }
 
+bool is_supported_texture_file_extension(std::string_view extension) noexcept {
+  return iequals_ascii(extension, ".astc") || iequals_ascii(extension, ".dds") || iequals_ascii(extension, ".png");
+}
+
 int compare_ascii_ci(std::string_view lhs, std::string_view rhs) noexcept {
   const size_t count = std::min(lhs.size(), rhs.size());
   for (size_t i = 0; i < count; ++i) {
@@ -260,7 +265,8 @@ aurora::ArrayRef<uint8_t> tlut_bytes(const GXTlutObj_& tlut) noexcept {
   return {static_cast<const uint8_t*>(tlut.data), static_cast<size_t>(tlut.numEntries) * sizeof(uint16_t)};
 }
 
-std::optional<uint64_t> compute_referenced_tlut_hash(const GXTexObj_& obj, aurora::ArrayRef<uint8_t> tlutData) noexcept {
+std::optional<uint64_t> compute_referenced_tlut_hash(const GXTexObj_& obj,
+                                                     aurora::ArrayRef<uint8_t> tlutData) noexcept {
   const uint32_t textureSize = texture_base_level_size(obj);
   const auto* textureData = static_cast<const uint8_t*>(obj.data);
   if (!is_palette_format(obj.format()) || !obj.has_data() || textureSize == 0 || tlutData.empty()) {
@@ -391,7 +397,7 @@ std::optional<aurora::texture::TextureSourceKey> parse_replacement_filename(std:
     return std::nullopt;
   }
 
-  if (!iequals_ascii(filename.substr(dot), ".dds") && !iequals_ascii(filename.substr(dot), ".png")) {
+  if (!is_supported_texture_file_extension(filename.substr(dot))) {
     return std::nullopt;
   }
 
@@ -480,10 +486,17 @@ std::optional<aurora::texture::TextureSourceKey> parse_replacement_filename(std:
 }
 
 std::optional<aurora::gfx::ConvertedTexture> load_texture_file(const std::filesystem::path& path) {
-  if (iequals_ascii(fs_path_to_string(path.extension()), ".png")) {
+  const auto extension = fs_path_to_string(path.extension());
+  if (iequals_ascii(extension, ".astc")) {
+    return aurora::gfx::astc::load_astc_file(path);
+  }
+  if (iequals_ascii(extension, ".png")) {
     return aurora::gfx::png::load_png_file(path);
   }
-  return aurora::gfx::dds::load_dds_file(path);
+  if (iequals_ascii(extension, ".dds")) {
+    return aurora::gfx::dds::load_dds_file(path);
+  }
+  return std::nullopt;
 }
 
 bool remove_mipmaps(aurora::gfx::ConvertedTexture& texture) noexcept {
@@ -1091,7 +1104,7 @@ ReplacementGroup load_replacement_directory(const std::filesystem::path& root, R
     }
 
     const auto extension = fs_path_to_string(path.extension());
-    if (!iequals_ascii(extension, ".dds") && !iequals_ascii(extension, ".png")) {
+    if (!is_supported_texture_file_extension(extension)) {
       continue;
     }
 
@@ -1147,7 +1160,9 @@ std::optional<TextureHandle> find_source_replacement_locked(const GXTexObj_& obj
   const auto replacementKey = find_source_replacement_key_locked(sourceKey);
   if (!replacementKey.has_value()) {
     const bool alwaysReportMissingKey = false; // Enable for debugging
-    if (g_config.allowTextureDumps || alwaysReportMissingKey) { report_missing_key(sourceKey, obj); }
+    if (g_config.allowTextureDumps || alwaysReportMissingKey) {
+      report_missing_key(sourceKey, obj);
+    }
     return std::nullopt;
   }