roundtrip_adt.cpp

Go to the documentation of this file.

 
#include <array>
#include <cstdint>
#include <format>
#include <string>
#include <string_view>
 
#include <wowlib/audit/detail.hpp>
#include <wowlib/core/client_builds.hpp>
#include <wowlib/formats/adt/adt.hpp>
#include <wowlib/formats/wdt/wdt.hpp>
 
namespace {
  using namespace wowlib;
  using namespace wowlib::audit;
  using namespace wowlib::formats;

  adt::AlphaFormat alphaFormatOf(wdt::root::chunks::MapHeaderFlags mphdFlags) {
    using enum wdt::root::chunks::MapHeaderFlags;
    return hasFlag(mphdFlags, AdtHasBigAlpha) ||
           hasFlag(mphdFlags, AdtHasHeightTexturing)
             ? adt::AlphaFormat::Highres8Bit
             : adt::AlphaFormat::Lowres4Bit;
  }

  std::string mapWdtOf(std::string_view tilePath) {
    const auto lastSep = tilePath.rfind('\\');
    if (lastSep == std::string_view::npos) return {};
    const std::string_view dir = tilePath.substr(0, lastSep);
    const auto prevSep = dir.rfind('\\');
    const std::string_view map = prevSep == std::string_view::npos ? dir : dir.substr(prevSep + 1);
    if (map.empty()) return {};
    return std::format("{}\\{}.wdt", dir, map);
  }

  template <ClientVersion V>
  std::optional<RoundtripReport> deriveAlpha(fs::FileSystem& fs,
                                              const std::string& path,
                                              RoundtripReport& report,
                                              adt::AlphaFormat& alpha) {
    const std::string wdtPath = mapWdtOf(path);
    if (wdtPath.empty())
      return audit::detail::failWith(report, "wdt locate",
                                      "the tile path has no map directory to derive the WDT from");
    const auto raw = fs.readFile(FileKey{wdtPath});
    if (!raw || raw->empty()) {
      // An unreadable or zero-byte map WDT is an addressing limitation, not a
      // parse failure: community-listfile placeholder maps ("unkmaps/...")
      // derive a synthetic WDT name no listfile entry or name hash resolves,
      // and abandoned maps (2.4.3 development) ship an empty placeholder WDT.
      // Without the WDT there is no alpha format, so the tile cannot be
      // audited.
      return audit::detail::skipped("no-map-wdt");
    }
    wdt::root::WDTRoot < V > root;
    if (auto r = root.read(*raw); !r)
      return audit::detail::failWith(report, "wdt parse", std::format("{}: {}", wdtPath, r.error().message));
    alpha = alphaFormatOf(root.header.flags);
    return std::nullopt;
  }

  template <ClientVersion V>
  RoundtripReport roundtripAdt(fs::FileSystem& fs, const std::string& path) {
    RoundtripReport report;
    adt::AlphaFormat alpha{};
    if (auto fail = deriveAlpha<V>(fs, path, report, alpha)) return *fail;
 
    adt::ADT < V > tile;
    if (auto r = tile.read(fs, FileKey{path}, alpha); !r) {
      if (r.error().code == ErrorCode::EncryptedContent) return audit::detail::skipped("encrypted");
      return audit::detail::failWith(report, "read", r.error().message);
    }
 
    const auto first = tile.writeFile(adt::FileKind::Monolithic, alpha);
    if (!first) return audit::detail::failWith(report, "write", first.error().message);
 
    adt::ADT < V > reparsed;
    reparsed.alphaFormat = alpha;
    if (auto r = reparsed.parseFile(*first, adt::FileKind::Monolithic); !r) return audit::detail::failWith(
      report, "reparse", r.error().message);
 
    const auto second = reparsed.writeFile(adt::FileKind::Monolithic, alpha);
    if (!second)
      return audit::detail::failWith(report, "rewrite", second.error().message);
    if (auto divergence = audit::detail::firstDivergenceChunked(*first, *second)) return audit::detail::failWith(
      report, "compare", *divergence);
    return report;
  }

  template <ClientVersion V>
  RoundtripReport roundtripAdtSplit(fs::FileSystem& fs, const std::string& path) {
    RoundtripReport report;
    adt::AlphaFormat alpha{};
    if (auto fail = deriveAlpha<V>(fs, path, report, alpha)) return *fail;
 
    adt::ADT < V > tile;
    if (auto r = tile.read(fs, FileKey{path}, alpha); !r) {
      if (r.error().code == ErrorCode::EncryptedContent) return audit::detail::skipped("encrypted");
      return audit::detail::failWith(report, "read", r.error().message);
    }
 
    constexpr std::array kinds{adt::FileKind::Root, adt::FileKind::Tex0, adt::FileKind::Obj0};
    constexpr std::array names{"root", "_tex0", "_obj0"};
 
    adt::ADT < V > reparsed;
    reparsed.alphaFormat = alpha;
    reparsed.chunks.assign(256, adt::MapChunk < V > {});
 
    std::array<FileBuffer, kinds.size()> firsts{};
    for (std::size_t i = 0; i < kinds.size(); ++i) {
      auto first = tile.writeFile(kinds[i], alpha);
      if (!first)
        return audit::detail::failWith(report, std::format("write ({})", names[i]), first.error().message);
      if (auto r = reparsed.parseFile(*first, kinds[i]); !r)
        return audit::detail::failWith(report, std::format("reparse ({})", names[i]), r.error().message);
      firsts[i] = std::move(*first);
    }
    // _obj1/_lod are round-tripped verbatim by write(); mirror that here so
    // the fresh entity is whole (they do not enter the per-kind compares).
    if constexpr (requires { tile.obj1Data; }) {
      reparsed.obj1Data = tile.obj1Data;
      reparsed.lodData = tile.lodData;
    }
 
    for (std::size_t i = 0; i < kinds.size(); ++i) {
      const auto second = reparsed.writeFile(kinds[i], alpha);
      if (!second)
        return audit::detail::failWith(report, std::format("rewrite ({})", names[i]), second.error().message);
      if (auto divergence = audit::detail::firstDivergenceChunked(firsts[i], *second))
        return audit::detail::failWith(report, std::format("compare ({})", names[i]), *divergence);
    }
    return report;
  }
}
 
namespace wowlib::audit::detail {
  RoundtripReport FormatDrivers::adt(fs::FileSystem& fs, const std::string& path, ClientVersion version) {
    RoundtripReport report = skipped("unsupported-version");
    const bool matched = withVersion(version, [&]<ClientVersion V>() {
      if constexpr (versionSupported(formats::adt::AdtVersions, V)) {
        if constexpr (V < builds::Cata) report = guarded([&] { return roundtripAdt<V>(fs, path); });
        else report = guarded([&] { return roundtripAdtSplit<V>(fs, path); });
      }
    });
    if (!matched) return unrecognizedVersion(version);
    return report;
  }
}