codec.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
#include <wowlib/formats/adt/boundaries.hpp>
 
namespace wowlib::formats::adt::detail {
  inline constexpr std::size_t AlphaDim = 64;
  inline constexpr std::size_t AlphaTexels = AlphaDim * AlphaDim;
  inline constexpr std::size_t Alpha4BitBytes = AlphaTexels / 2;
  inline constexpr std::size_t ShadowBytes = AlphaTexels / 8;

  class TerrainMapCodec {
  protected:
    static void _fixLastRowCol(std::span<std::uint8_t> map) {
      for (std::size_t r = 0; r < AlphaDim; ++r) map[r * AlphaDim + 63] = map[r * AlphaDim + 62];
      for (std::size_t c = 0; c < AlphaDim; ++c) map[63 * AlphaDim + c] = map[62 * AlphaDim + c];
    }
  };

  class AlphaMapCodec : TerrainMapCodec {
  public:
    explicit AlphaMapCodec(AlphaFormat format) noexcept : _format{format} {}

    [[nodiscard]]
    std::vector<std::uint8_t> decode(std::span<const std::byte> src, bool compressed, bool fixEdges) const {
      std::vector<std::uint8_t> map;
      if (compressed) decodeRle(src, map);
      else if (_format == AlphaFormat::Highres8Bit) decode8Bit(src, map);
      else decode4Bit(src, map);
      if (fixEdges) _fixLastRowCol(map);
      return map;
    }

    void encode(std::span<const std::uint8_t> map, bool compressed, std::vector<std::byte>& out) const {
      if (compressed) encodeRle(map, out);
      else if (_format == AlphaFormat::Highres8Bit) encode8Bit(map, out);
      else encode4Bit(map, out);
    }
 
  protected:
    void decode4Bit(std::span<const std::byte> src, std::vector<std::uint8_t>& out) const {
      out.resize(AlphaTexels);
      for (std::size_t i = 0; i < Alpha4BitBytes && i < src.size(); ++i) {
        const auto b = std::to_integer<std::uint8_t>(src[i]);
        out[2 * i] = static_cast<std::uint8_t>((b & 0x0F) * 0x11);
        out[2 * i + 1] = static_cast<std::uint8_t>((b >> 4) * 0x11);
      }
    }

    void decode8Bit(std::span<const std::byte> src, std::vector<std::uint8_t>& out) const {
      out.resize(AlphaTexels);
      for (std::size_t i = 0; i < AlphaTexels && i < src.size(); ++i) out[i] = std::to_integer<std::uint8_t>(src[i]);
    }

    void decodeRle(std::span<const std::byte> src, std::vector<std::uint8_t>& out) const {
      out.clear();
      out.reserve(AlphaTexels);
      std::size_t p = 0;
      while (out.size() < AlphaTexels && p < src.size()) {
        const auto control = std::to_integer<std::uint8_t>(src[p++]);
        const std::size_t count = control & 0x7F;
        if (control & 0x80) // fill
        {
          if (p >= src.size()) break;
          const auto value = std::to_integer<std::uint8_t>(src[p++]);
          for (std::size_t k = 0; k < count && out.size() < AlphaTexels; ++k) out.push_back(value);
        }
        else // copy
        {
          for (std::size_t k = 0; k < count && out.size() < AlphaTexels && p < src.size(); ++k) out.push_back(
            std::to_integer<std::uint8_t>(src[p++]));
        }
      }
      out.resize(AlphaTexels);
    }

    void encode4Bit(std::span<const std::uint8_t> map, std::vector<std::byte>& out) const {
      for (std::size_t i = 0; i < Alpha4BitBytes; ++i) {
        const auto lo = static_cast<std::uint8_t>(map[2 * i] >> 4);
        const auto hi = static_cast<std::uint8_t>(map[2 * i + 1] >> 4);
        out.push_back(static_cast<std::byte>(lo | (hi << 4)));
      }
    }

    void encode8Bit(std::span<const std::uint8_t> map, std::vector<std::byte>& out) const {
      for (std::uint8_t v : map) out.push_back(static_cast<std::byte>(v));
    }

    void encodeRle(std::span<const std::uint8_t> map, std::vector<std::byte>& out) const {
      for (std::size_t row = 0; row < AlphaDim; ++row) {
        const std::uint8_t* r = map.data() + row * AlphaDim;
        std::size_t i = 0;
        std::size_t copyStart = AlphaDim + 1; // "none"
        const auto flushCopy = [&](std::size_t end) {
          if (copyStart > AlphaDim) return;
          out.push_back(static_cast<std::byte>(end - copyStart));
          // copy, count
          for (std::size_t k = copyStart; k < end; ++k) out.push_back(static_cast<std::byte>(r[k]));
          copyStart = AlphaDim + 1;
        };
        while (i < AlphaDim) {
          std::size_t run = 1;
          while (i + run < AlphaDim && r[i + run] == r[i]) ++run;
          if (run >= 3) {
            flushCopy(i);
            out.push_back(static_cast<std::byte>(0x80 | run)); // fill
            out.push_back(static_cast<std::byte>(r[i]));
            i += run;
          }
          else {
            if (copyStart > AlphaDim) copyStart = i;
            ++i;
          }
        }
        flushCopy(AlphaDim);
      }
    }
 
  private:
    AlphaFormat _format;
  };

  class ShadowMapCodec : TerrainMapCodec {
  public:
    [[nodiscard]]
    std::vector<std::uint8_t> decode(std::span<const std::byte> src, bool fixEdges) const {
      std::vector<std::uint8_t> map(AlphaTexels, 0);
      for (std::size_t i = 0; i < AlphaTexels && i / 8 < src.size(); ++i) {
        const auto b = std::to_integer<std::uint8_t>(src[i / 8]);
        map[i] = (b >> (i % 8)) & 1;
      }
      if (fixEdges) _fixLastRowCol(map);
      return map;
    }

    void encode(std::span<const std::uint8_t> map, std::vector<std::byte>& out) const {
      for (std::size_t byte = 0; byte < ShadowBytes; ++byte) {
        std::uint8_t packed = 0;
        for (std::size_t bit = 0; bit < 8; ++bit)
          if (map[byte * 8 + bit] & 1) packed |= static_cast<std::uint8_t>(1 << bit);
        out.push_back(static_cast<std::byte>(packed));
      }
    }
  };
}