satellites.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstdint>
#include <cstring>
#include <format>
#include <functional>
#include <initializer_list>
#include <map>
#include <optional>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include <wowlib/core/buffer.hpp>
#include <wowlib/core/error.hpp>
#include <wowlib/formats/common/fourcc.hpp>
#include <wowlib/formats/m2/offset_block.hpp>
#include <wowlib/formats/m2/chunked/records.hpp>
 
namespace wowlib::formats::m2 {
  struct SequenceKey {
    std::uint16_t id = 0; 
    std::uint16_t variation = 0; 
 
    constexpr auto operator<=>(const SequenceKey&) const = default;
  };

  class SatellitePaths {
  public:
    explicit SatellitePaths(std::string_view modelPath)
      : _stem{modelPath} {
      for (std::string_view ext : {".m2", ".M2", ".mdx", ".MDX", ".mdl", ".MDL", ".skel", ".SKEL"})
        if (modelPath.ends_with(ext)) {
          _stem = std::string{modelPath.substr(0, modelPath.size() - ext.size())};
          break;
        }
    }

    const std::string& stem() const { return _stem; }

    std::string skin(std::uint32_t index) const {
      return std::format("{}{:02}.skin", _stem, index);
    }

    std::string lodSkin(std::uint32_t band) const {
      return std::format("{}_lod{:02}.skin", _stem, band);
    }

    std::string anim(SequenceKey key) const {
      return std::format("{}{:04}-{:02}.anim", _stem, key.id, key.variation);
    }

    std::string bone(std::uint32_t variant) const {
      return std::format("{}_{:02}.bone", _stem, variant);
    }

    std::string skel() const { return _stem + ".skel"; }

    std::string phys() const { return _stem + ".phys"; }
 
  private:
    std::string _stem;
  };

  class AnimCache {
  public:
    // .anim chunk ids, forward like all M2-family fourccs.
    static constexpr std::uint32_t Afm2Magic = fourcc("AFM2", FourCCEndian::Forward);
    static constexpr std::uint32_t AfsaMagic = fourcc("AFSA", FourCCEndian::Forward);
    static constexpr std::uint32_t AfsbMagic = fourcc("AFSB", FourCCEndian::Forward);

    static std::uint32_t afidLookup(std::span<const chunked::record::AnimFileEntry> entries, SequenceKey key) {
      for (const chunked::record::AnimFileEntry& e : entries)
        if (e.animId == key.id && e.subAnimId == key.variation) return e.fileId;
      return 0;
    }

    explicit AnimCache(std::function<Result<FileBuffer>(SequenceKey)> loader)
      : _loader{std::move(loader)} {}

    std::span<const std::byte> window(SequenceKey key, std::uint32_t target) {
      auto [it, inserted] = _files.try_emplace(key);
      if (inserted)
        if (auto file = _loader(key)) it->second = std::move(*file);
      if (!it->second) return {};
      const FileBuffer& buf = *it->second;
      std::uint32_t lead = 0;
      if (buf.size() >= 8) std::memcpy(&lead, buf.data(), 4);
      const bool chunked = lead == Afm2Magic;
      if (!chunked)
        return target == Afm2Magic ? std::span<const std::byte>{buf} : std::span<const std::byte>{};
      for (std::size_t pos = 0; pos + 8 <= buf.size();) {
        std::uint32_t fourcc = 0;
        std::uint32_t size = 0;
        std::memcpy(&fourcc, buf.data() + pos, 4);
        std::memcpy(&size, buf.data() + pos + 4, 4);
        if (size > buf.size() - pos - 8) break;
        if (fourcc == target) return std::span<const std::byte>{buf}.subspan(pos + 8, size);
        pos += 8 + size;
      }
      return {};
    }

    template <typename Sequence>
    auto sequenceBase(const std::vector<Sequence>& sequences,
                       std::span<const std::byte> inlineBase,
                       std::uint32_t target) {
      return [this, &sequences, inlineBase, target](std::size_t i) -> std::span<const std::byte> {
        if (i >= sequences.size()) return inlineBase;
        const Sequence& s = sequences[i];
        if (s.isAlias()) return {}; // aliases own no data; their stored records are stale
        if (!s.ownsAnimFile()) return inlineBase;
        return window(SequenceKey{s.id, s.variationIndex}, target);
      };
    }
 
  private:
    std::function<Result<FileBuffer>(SequenceKey)> _loader;
    std::map<SequenceKey, std::optional<FileBuffer>> _files;
  };

  class AnimBuffers {
  public:
    template <typename Sequence>
    OffsetWriteContext sink(const std::vector<Sequence>& sequences) {
      OffsetWriteContext ctx;
      ctx.sequenceSink = [this, &sequences](std::size_t i) -> FileBuffer* {
        if (i >= sequences.size()) return nullptr;
        const Sequence& s = sequences[i];
        if (!s.ownsAnimFile()) return nullptr;
        return &_bufs[SequenceKey{s.id, s.variationIndex}];
      };
      return ctx;
    }

    const std::map<SequenceKey, FileBuffer>& entries() const { return _bufs; }

    void appendChunkTo(FileBuffer& out, std::uint32_t fourcc, SequenceKey key) const {
      const auto it = _bufs.find(key);
      _appendChunk(out, fourcc,
                   it == _bufs.end() ? std::span<const std::byte>{} : std::span<const std::byte>{it->second});
    }

    static std::set<SequenceKey> mergedKeys(std::initializer_list<const AnimBuffers*> sets) {
      std::set<SequenceKey> keys;
      for (const AnimBuffers* set : sets)
        for (const auto& [key, buf] : set->_bufs) keys.insert(key);
      return keys;
    }
 
  private:
    static void _appendChunk(FileBuffer& out, std::uint32_t fourcc, std::span<const std::byte> payload) {
      const auto size = static_cast<std::uint32_t>(payload.size());
      const std::size_t at = out.size();
      out.resize(at + 8);
      std::memcpy(out.data() + at, &fourcc, 4);
      std::memcpy(out.data() + at + 4, &size, 4);
      out.insert(out.end(), payload.begin(), payload.end());
    }
 
    std::map<SequenceKey, FileBuffer> _bufs;
  };
}