metaforce/DataSpec/DNACommon/DNACommon.hpp

405 lines
12 KiB
C++
Raw Normal View History

2015-06-24 20:56:23 +00:00
#ifndef __DNA_COMMON_HPP__
#define __DNA_COMMON_HPP__
#include <stdio.h>
2016-03-04 23:04:53 +00:00
#include <athena/DNAYaml.hpp>
2016-08-22 03:47:48 +00:00
#include <athena/FileReader.hpp>
#include <athena/FileWriter.hpp>
2016-03-04 23:04:53 +00:00
#include <nod/DiscBase.hpp>
#include "hecl/hecl.hpp"
#include "hecl/Database.hpp"
2015-08-05 21:46:07 +00:00
#include "../SpecBase.hpp"
2016-04-10 04:49:02 +00:00
#include "boo/ThreadLocalPtr.hpp"
2016-09-16 20:18:03 +00:00
#include "zeus/CColor.hpp"
2015-06-24 20:56:23 +00:00
2016-02-13 09:02:47 +00:00
namespace DataSpec
2015-07-01 23:50:39 +00:00
{
2016-03-04 23:04:53 +00:00
extern logvisor::Module LogDNACommon;
2016-04-10 04:49:02 +00:00
extern ThreadLocalPtr<SpecBase> g_curSpec;
extern ThreadLocalPtr<class PAKRouterBase> g_PakRouter;
2015-07-16 01:57:34 +00:00
2015-06-24 20:56:23 +00:00
/* This comes up a great deal */
2016-03-04 23:04:53 +00:00
typedef athena::io::DNA<athena::BigEndian> BigDNA;
typedef athena::io::DNAYaml<athena::BigEndian> BigYAML;
2015-06-24 20:56:23 +00:00
2015-11-10 02:07:15 +00:00
/** FourCC with DNA read/write */
2016-03-04 23:04:53 +00:00
class DNAFourCC final : public BigYAML, public hecl::FourCC
2015-07-11 22:41:10 +00:00
{
public:
2016-03-04 23:04:53 +00:00
DNAFourCC() : hecl::FourCC() {}
DNAFourCC(const hecl::FourCC& other)
: hecl::FourCC() {num = other.toUint32();}
2015-08-23 06:42:29 +00:00
DNAFourCC(const char* name)
2016-03-04 23:04:53 +00:00
: hecl::FourCC(name) {}
2015-08-23 06:42:29 +00:00
DNAFourCC(uint32_t n)
2016-03-04 23:04:53 +00:00
: hecl::FourCC(n) {}
2015-07-11 22:41:10 +00:00
Delete expl;
2016-03-04 23:04:53 +00:00
void read(athena::io::IStreamReader& reader)
2015-07-11 22:41:10 +00:00
{reader.readUBytesToBuf(fcc, 4);}
2016-03-04 23:04:53 +00:00
void write(athena::io::IStreamWriter& writer) const
2015-07-11 22:41:10 +00:00
{writer.writeUBytes((atUint8*)fcc, 4);}
2016-03-04 23:04:53 +00:00
void read(athena::io::YAMLDocReader& reader)
2015-08-01 00:38:35 +00:00
{std::string rs = reader.readString(nullptr); strncpy(fcc, rs.c_str(), 4);}
2016-03-04 23:04:53 +00:00
void write(athena::io::YAMLDocWriter& writer) const
2015-08-01 00:38:35 +00:00
{writer.writeString(nullptr, std::string(fcc, 4));}
size_t binarySize(size_t __isz) const
{return __isz + 4;}
2015-07-11 22:41:10 +00:00
};
2016-09-16 20:18:03 +00:00
class DNAColor final : public BigYAML, public zeus::CColor
{
public:
DNAColor() = default;
DNAColor(const zeus::CColor& color) : zeus::CColor(color) {}
Delete expl;
void read(athena::io::IStreamReader& reader)
{zeus::CColor::readRGBABig(reader);}
void write(athena::io::IStreamWriter& writer) const
{zeus::CColor::writeRGBABig(writer);}
void read(athena::io::YAMLDocReader& reader)
{
size_t count;
reader.enterSubVector(nullptr, count);
r = (count >= 1) ? reader.readFloat(nullptr) : 0.f;
g = (count >= 2) ? reader.readFloat(nullptr) : 0.f;
b = (count >= 3) ? reader.readFloat(nullptr) : 0.f;
a = (count >= 4) ? reader.readFloat(nullptr) : 0.f;
reader.leaveSubVector();
}
void write(athena::io::YAMLDocWriter& writer) const
{
writer.enterSubVector(nullptr);
writer.writeFloat(nullptr, r);
writer.writeFloat(nullptr, g);
writer.writeFloat(nullptr, b);
writer.writeFloat(nullptr, a);
writer.leaveSubVector();
}
size_t binarySize(size_t __isz) const
{return __isz + 4;}
};
2016-03-04 23:04:53 +00:00
using FourCC = hecl::FourCC;
class UniqueID32;
class UniqueID64;
class UniqueID128;
/** Common virtual interface for runtime ambiguity resolution */
class PAKRouterBase
{
protected:
const SpecBase& m_dataSpec;
public:
PAKRouterBase(const SpecBase& dataSpec) : m_dataSpec(dataSpec) {}
2016-03-05 00:03:41 +00:00
hecl::Database::Project& getProject() const {return m_dataSpec.getProject();}
virtual hecl::ProjectPath getWorking(const UniqueID32&, bool silenceWarnings=false) const
{
2016-03-05 00:03:41 +00:00
LogDNACommon.report(logvisor::Fatal,
"PAKRouter IDType mismatch; expected UniqueID32 specialization");
2016-03-05 00:03:41 +00:00
return hecl::ProjectPath();
}
virtual hecl::ProjectPath getWorking(const UniqueID64&, bool silenceWarnings=false) const
{
2016-03-05 00:03:41 +00:00
LogDNACommon.report(logvisor::Fatal,
"PAKRouter IDType mismatch; expected UniqueID64 specialization");
2016-03-05 00:03:41 +00:00
return hecl::ProjectPath();
}
virtual hecl::ProjectPath getWorking(const UniqueID128&, bool silenceWarnings=false) const
{
2016-03-05 00:03:41 +00:00
LogDNACommon.report(logvisor::Fatal,
"PAKRouter IDType mismatch; expected UniqueID128 specialization");
2016-03-05 00:03:41 +00:00
return hecl::ProjectPath();
}
};
/** Globally-accessed manager allowing UniqueID* classes to directly
* lookup destination paths of resources */
class UniqueIDBridge
{
friend class UniqueID32;
friend class UniqueID64;
2016-04-10 04:49:02 +00:00
static ThreadLocalPtr<hecl::Database::Project> s_Project;
public:
template <class IDType>
static hecl::ProjectPath TranslatePakIdToPath(const IDType& id, bool silenceWarnings=false);
2016-10-02 22:41:36 +00:00
template <class IDType>
static hecl::ProjectPath MakePathFromString(const std::string& str);
template <class IDType>
static void TransformOldHashToNewHash(IDType& id);
static void setThreadProject(hecl::Database::Project& project);
};
2015-08-23 06:42:29 +00:00
2015-11-10 02:07:15 +00:00
/** PAK 32-bit Unique ID */
2015-08-01 00:38:35 +00:00
class UniqueID32 : public BigYAML
2015-06-24 20:56:23 +00:00
{
protected:
2015-08-11 23:32:02 +00:00
uint32_t m_id = 0xffffffff;
2015-06-24 20:56:23 +00:00
public:
static UniqueID32 kInvalidId;
2015-06-24 20:56:23 +00:00
Delete expl;
operator bool() const {return m_id != 0xffffffff && m_id != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
2015-07-06 01:33:06 +00:00
2016-03-04 23:04:53 +00:00
UniqueID32& operator=(const hecl::ProjectPath& path)
2015-11-10 02:07:15 +00:00
{m_id = path.hash().val32(); return *this;}
2015-09-22 01:58:26 +00:00
bool operator!=(const UniqueID32& other) const {return m_id != other.m_id;}
bool operator==(const UniqueID32& other) const {return m_id == other.m_id;}
uint32_t toUint32() const {return m_id;}
uint64_t toUint64() const {return m_id;}
std::string toString() const;
2015-11-10 02:07:15 +00:00
void clear() {m_id = 0xffffffff;}
2015-10-19 03:28:47 +00:00
UniqueID32() = default;
2016-10-02 22:41:36 +00:00
UniqueID32(uint32_t idin) : m_id(idin) {}
2016-03-04 23:04:53 +00:00
UniqueID32(athena::io::IStreamReader& reader) {read(reader);}
UniqueID32(const hecl::ProjectPath& path) {*this = path;}
2015-10-19 03:28:47 +00:00
UniqueID32(const char* hexStr)
{
char copy[9];
strncpy(copy, hexStr, 8);
copy[8] = '\0';
m_id = strtoul(copy, nullptr, 16);
}
2015-11-10 20:12:43 +00:00
UniqueID32(const wchar_t* hexStr)
{
wchar_t copy[9];
wcsncpy(copy, hexStr, 8);
copy[8] = L'\0';
m_id = wcstoul(copy, nullptr, 16);
}
2015-11-10 02:07:15 +00:00
static constexpr size_t BinarySize() {return 4;}
2015-06-24 20:56:23 +00:00
};
class AuxiliaryID32 : public UniqueID32
{
const hecl::SystemChar* m_auxStr;
const hecl::SystemChar* m_addExtension;
UniqueID32 m_baseId;
public:
AuxiliaryID32(const hecl::SystemChar* auxStr,
const hecl::SystemChar* addExtension=nullptr)
: m_auxStr(auxStr), m_addExtension(addExtension) {}
AuxiliaryID32& operator=(const hecl::ProjectPath& path);
AuxiliaryID32& operator=(const UniqueID32& id);
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
const UniqueID32& getBaseId() const {return m_baseId;}
};
2015-11-10 02:07:15 +00:00
/** PAK 64-bit Unique ID */
2015-09-23 06:35:07 +00:00
class UniqueID64 : public BigYAML
2015-06-24 20:56:23 +00:00
{
2015-08-11 23:32:02 +00:00
uint64_t m_id = 0xffffffffffffffff;
2015-06-24 20:56:23 +00:00
public:
Delete expl;
operator bool() const {return m_id != 0xffffffffffffffff && m_id != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
2015-07-06 01:33:06 +00:00
2016-03-04 23:04:53 +00:00
UniqueID64& operator=(const hecl::ProjectPath& path)
2015-11-10 02:07:15 +00:00
{m_id = path.hash().val64(); return *this;}
2015-09-22 01:58:26 +00:00
bool operator!=(const UniqueID64& other) const {return m_id != other.m_id;}
bool operator==(const UniqueID64& other) const {return m_id == other.m_id;}
uint64_t toUint64() const {return m_id;}
std::string toString() const;
2015-11-10 02:07:15 +00:00
void clear() {m_id = 0xffffffffffffffff;}
2015-10-19 03:28:47 +00:00
UniqueID64() = default;
2016-10-02 22:41:36 +00:00
UniqueID64(uint64_t idin) : m_id(idin) {}
2016-03-04 23:04:53 +00:00
UniqueID64(athena::io::IStreamReader& reader) {read(reader);}
UniqueID64(const hecl::ProjectPath& path) {*this = path;}
2015-10-19 03:28:47 +00:00
UniqueID64(const char* hexStr)
{
char copy[17];
strncpy(copy, hexStr, 16);
copy[16] = '\0';
2015-11-10 20:12:43 +00:00
#if _WIN32
m_id = _strtoui64(copy, nullptr, 16);
#else
2015-10-19 03:28:47 +00:00
m_id = strtouq(copy, nullptr, 16);
2015-11-10 20:12:43 +00:00
#endif
}
UniqueID64(const wchar_t* hexStr)
{
wchar_t copy[17];
wcsncpy(copy, hexStr, 16);
copy[16] = L'\0';
#if _WIN32
m_id = _wcstoui64(copy, nullptr, 16);
#else
2015-11-11 07:04:17 +00:00
m_id = wcstoull(copy, nullptr, 16);
2015-11-10 20:12:43 +00:00
#endif
2015-10-19 03:28:47 +00:00
}
2015-11-10 02:07:15 +00:00
static constexpr size_t BinarySize() {return 8;}
2015-06-24 20:56:23 +00:00
};
2015-11-10 02:07:15 +00:00
/** PAK 128-bit Unique ID */
2015-09-23 06:35:07 +00:00
class UniqueID128 : public BigYAML
2015-06-24 20:56:23 +00:00
{
2015-07-06 01:33:06 +00:00
union
{
uint64_t m_id[2];
#if __SSE__
__m128i m_id128;
#endif
};
2015-06-24 20:56:23 +00:00
public:
Delete expl;
2015-08-11 23:32:02 +00:00
UniqueID128() {m_id[0]=0xffffffffffffffff; m_id[1]=0xffffffffffffffff;}
2015-09-22 01:58:26 +00:00
operator bool() const
{return m_id[0] != 0xffffffffffffffff && m_id[0] != 0 && m_id[1] != 0xffffffffffffffff && m_id[1] != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
2015-07-06 01:33:06 +00:00
2016-03-05 00:03:41 +00:00
UniqueID128& operator=(const hecl::ProjectPath& path)
{
m_id[0] = path.hash().val64();
m_id[1] = 0;
return *this;
}
2016-10-02 22:41:36 +00:00
UniqueID128(const hecl::ProjectPath& path) {*this = path;}
2015-09-22 01:58:26 +00:00
bool operator!=(const UniqueID128& other) const
2015-07-06 01:33:06 +00:00
{
#if __SSE__
2015-07-06 02:07:57 +00:00
__m128i vcmp = _mm_cmpeq_epi32(m_id128, other.m_id128);
int vmask = _mm_movemask_epi8(vcmp);
return vmask != 0xffff;
2015-07-06 01:33:06 +00:00
#else
return (m_id[0] != other.m_id[0]) || (m_id[1] != other.m_id[1]);
#endif
}
2015-09-22 01:58:26 +00:00
bool operator==(const UniqueID128& other) const
2015-07-06 01:33:06 +00:00
{
#if __SSE__
2015-07-06 02:07:57 +00:00
__m128i vcmp = _mm_cmpeq_epi32(m_id128, other.m_id128);
int vmask = _mm_movemask_epi8(vcmp);
return vmask == 0xffff;
2015-07-06 01:33:06 +00:00
#else
return (m_id[0] == other.m_id[0]) && (m_id[1] == other.m_id[1]);
#endif
}
2015-11-10 02:07:15 +00:00
void clear() {m_id[0] = 0xffffffffffffffff; m_id[1] = 0xffffffffffffffff;}
2016-10-02 22:41:36 +00:00
uint64_t toUint64() const {return m_id[0];}
2015-09-22 01:58:26 +00:00
uint64_t toHighUint64() const {return m_id[0];}
uint64_t toLowUint64() const {return m_id[1];}
std::string toString() const;
2015-11-10 02:07:15 +00:00
static constexpr size_t BinarySize() {return 16;}
2015-06-24 20:56:23 +00:00
};
2015-11-10 02:07:15 +00:00
/** Word Bitmap reader/writer */
2015-08-31 03:44:42 +00:00
class WordBitmap
2015-08-11 23:32:02 +00:00
{
std::vector<atUint32> m_words;
size_t m_bitCount = 0;
2015-08-31 03:44:42 +00:00
public:
void read(athena::io::IStreamReader& reader, size_t bitCount);
void write(athena::io::IStreamWriter& writer) const;
2016-10-09 07:45:04 +00:00
void reserve(size_t bitCount) { m_words.reserve((bitCount + 31) / 32); }
size_t binarySize(size_t __isz) const;
2015-08-11 23:32:02 +00:00
size_t getBitCount() const {return m_bitCount;}
bool getBit(size_t idx) const
{
size_t wordIdx = idx / 32;
if (wordIdx >= m_words.size())
return false;
size_t wordCur = idx % 32;
return (m_words[wordIdx] >> wordCur) & 0x1;
}
void setBit(size_t idx)
{
size_t wordIdx = idx / 32;
while (wordIdx >= m_words.size())
m_words.push_back(0);
size_t wordCur = idx % 32;
m_words[wordIdx] |= (1 << wordCur);
2016-10-09 07:45:04 +00:00
m_bitCount = std::max(m_bitCount, idx + 1);
2015-08-11 23:32:02 +00:00
}
void unsetBit(size_t idx)
{
size_t wordIdx = idx / 32;
while (wordIdx >= m_words.size())
m_words.push_back(0);
size_t wordCur = idx % 32;
m_words[wordIdx] &= ~(1 << wordCur);
2016-10-09 07:45:04 +00:00
m_bitCount = std::max(m_bitCount, idx + 1);
2015-08-11 23:32:02 +00:00
}
2016-10-09 07:45:04 +00:00
void clear() { m_words.clear(); m_bitCount = 0; }
2015-08-11 23:32:02 +00:00
class Iterator : public std::iterator<std::forward_iterator_tag, bool>
{
friend class WordBitmap;
const WordBitmap& m_bmp;
size_t m_idx = 0;
Iterator(const WordBitmap& bmp, size_t idx) : m_bmp(bmp), m_idx(idx) {}
public:
Iterator& operator++() {++m_idx; return *this;}
bool operator*() {return m_bmp.getBit(m_idx);}
bool operator!=(const Iterator& other) const {return m_idx != other.m_idx;}
};
Iterator begin() const {return Iterator(*this, 0);}
Iterator end() const {return Iterator(*this, m_bitCount);}
};
2015-11-10 02:07:15 +00:00
/** Resource cooker function */
2016-03-04 23:04:53 +00:00
typedef std::function<bool(const hecl::ProjectPath&, const hecl::ProjectPath&)> ResCooker;
2015-07-10 05:28:08 +00:00
2015-07-06 01:33:06 +00:00
}
/* Hash template-specializations for UniqueID types */
namespace std
2015-06-24 20:56:23 +00:00
{
template<>
2016-02-13 09:02:47 +00:00
struct hash<DataSpec::DNAFourCC>
{
2016-02-13 09:02:47 +00:00
size_t operator()(const DataSpec::DNAFourCC& fcc) const
{return fcc.toUint32();}
};
2015-07-06 01:33:06 +00:00
template<>
2016-02-13 09:02:47 +00:00
struct hash<DataSpec::UniqueID32>
2015-07-06 01:33:06 +00:00
{
2016-02-13 09:02:47 +00:00
size_t operator()(const DataSpec::UniqueID32& id) const
2015-07-06 02:07:57 +00:00
{return id.toUint32();}
2015-07-06 01:33:06 +00:00
};
template<>
2016-02-13 09:02:47 +00:00
struct hash<DataSpec::UniqueID64>
2015-07-06 01:33:06 +00:00
{
2016-02-13 09:02:47 +00:00
size_t operator()(const DataSpec::UniqueID64& id) const
2015-07-06 02:07:57 +00:00
{return id.toUint64();}
2015-06-24 20:56:23 +00:00
};
2015-07-06 01:33:06 +00:00
template<>
2016-02-13 09:02:47 +00:00
struct hash<DataSpec::UniqueID128>
2015-07-06 01:33:06 +00:00
{
2016-02-13 09:02:47 +00:00
size_t operator()(const DataSpec::UniqueID128& id) const
2015-07-06 02:07:57 +00:00
{return id.toHighUint64() ^ id.toLowUint64();}
2015-07-06 01:33:06 +00:00
};
2015-07-01 23:50:39 +00:00
}
2015-06-24 20:56:23 +00:00
#endif // __DNA_COMMON_HPP__