image.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
#include <wowlib/core/error.hpp>
#include <wowlib/db/wdc/binary.hpp>
#include <wowlib/db/wdc/bit_stream.hpp>
 
namespace wowlib::db::wdc {
  enum class StringRefMode : std::uint8_t {
    BlockRelative, 
    FieldRelative 
  };

  struct WdcSection {
    Wdc3SectionHeader header{}; 
    bool encrypted = false; 
    std::span<const std::byte> records; 
    std::span<const std::byte> strings; 
    std::span<const std::byte> idList; 
    std::span<const std::byte> copyTable; 
    std::span<const std::byte> offsetMap; 
    std::span<const std::byte> offsetMapIds; 
    std::span<const std::byte> relationship; 
    std::vector<std::uint32_t> encryptedIds; 
    std::uint32_t stringBase = 0; 
  };

  struct WdcImage {
    std::uint32_t magic = 0; 
    Wdc3Header header{}; 
    Wdc5HeaderPrefix wdc5{}; 
    StringRefMode stringMode = StringRefMode::FieldRelative;
    std::span<const std::byte> file;
    std::vector<WdcFieldStructure> fieldStructure;
    std::vector<WdcFieldStorage> fieldStorage;
    std::span<const std::byte> palletData;
    std::span<const std::byte> commonData;
    std::vector<WdcSection> sections;
    std::vector<std::byte> ownedOffsetMap;
    std::vector<std::uint32_t> ownedOffsetMapIds;

    static Result<WdcImage> parse(std::span<const std::byte> data);

    bool idIsNoninline() const {
      return (header.flags & WdcFlagNoninlineId) != 0;
    }

    bool isSparse() const { return (header.flags & WdcFlagSparse) != 0; }

    std::vector<std::uint32_t> fieldAdditionalOffsets() const;

    std::uint64_t fieldRaw(std::size_t field,
                            std::uint32_t element,
                            std::uint32_t arrayCount,
                            std::span<const std::byte> recordBytes,
                            std::uint32_t id,
                            const std::vector<std::uint32_t>& additional) const;

    std::size_t elemBitWidth(std::size_t field, std::uint32_t arrayCount) const;

    bool fieldIsSigned(std::size_t field) const {
      return field < fieldStorage.size() && fieldStorage[field].storageType == WdcCompression::BitpackedSigned;
    }
 
  private:
    static Result<WdcImage> _parseWdc1(std::span<const std::byte> data);

    static Result<WdcImage> _parseWdc3(std::span<const std::byte> data, std::uint32_t magic);

    std::uint32_t _palletValue(std::uint32_t base,
                               std::uint32_t index,
                               std::uint32_t element,
                               std::uint32_t arraySize) const;

    std::uint32_t _commonValue(std::uint32_t base, std::uint32_t size, std::uint32_t id, std::uint32_t fallback) const;
  };
}