mirror of
https://github.com/AxioDL/metaforce.git
synced 2025-05-31 15:21:21 +00:00
377 lines
11 KiB
C++
377 lines
11 KiB
C++
#ifndef __DNA_COMMON_HPP__
|
|
#define __DNA_COMMON_HPP__
|
|
|
|
#include <Athena/DNA.hpp>
|
|
#include "HECL/HECL.hpp"
|
|
#include "HECL/Database.hpp"
|
|
|
|
namespace Retro
|
|
{
|
|
|
|
extern LogVisor::LogModule LogDNACommon;
|
|
|
|
/* This comes up a great deal */
|
|
typedef Athena::io::DNA<Athena::BigEndian> BigDNA;
|
|
|
|
/* FourCC with DNA read/write */
|
|
class FourCC final : public BigDNA, public HECL::FourCC
|
|
{
|
|
public:
|
|
FourCC() : HECL::FourCC() {}
|
|
FourCC(const HECL::FourCC& other)
|
|
: HECL::FourCC() {num = other.toUint32();}
|
|
FourCC(const char* name)
|
|
: HECL::FourCC(name) {}
|
|
|
|
Delete expl;
|
|
inline void read(Athena::io::IStreamReader& reader)
|
|
{reader.readUBytesToBuf(fcc, 4);}
|
|
inline void write(Athena::io::IStreamWriter& writer) const
|
|
{writer.writeUBytes((atUint8*)fcc, 4);}
|
|
};
|
|
|
|
/* PAK 32-bit Unique ID */
|
|
class UniqueID32 : public BigDNA
|
|
{
|
|
uint32_t m_id;
|
|
public:
|
|
Delete expl;
|
|
inline void read(Athena::io::IStreamReader& reader)
|
|
{m_id = reader.readUint32();}
|
|
inline void write(Athena::io::IStreamWriter& writer) const
|
|
{writer.writeUint32(m_id);}
|
|
|
|
inline bool operator!=(const UniqueID32& other) const {return m_id != other.m_id;}
|
|
inline bool operator==(const UniqueID32& other) const {return m_id == other.m_id;}
|
|
inline uint32_t toUint32() const {return m_id;}
|
|
inline std::string toString() const
|
|
{
|
|
char buf[9];
|
|
snprintf(buf, 9, "%08X", m_id);
|
|
return std::string(buf);
|
|
}
|
|
};
|
|
|
|
/* PAK 64-bit Unique ID */
|
|
class UniqueID64 : public BigDNA
|
|
{
|
|
uint64_t m_id;
|
|
public:
|
|
Delete expl;
|
|
inline void read(Athena::io::IStreamReader& reader)
|
|
{m_id = reader.readUint64();}
|
|
inline void write(Athena::io::IStreamWriter& writer) const
|
|
{writer.writeUint64(m_id);}
|
|
|
|
inline bool operator!=(const UniqueID64& other) const {return m_id != other.m_id;}
|
|
inline bool operator==(const UniqueID64& other) const {return m_id == other.m_id;}
|
|
inline uint64_t toUint64() const {return m_id;}
|
|
inline std::string toString() const
|
|
{
|
|
char buf[17];
|
|
snprintf(buf, 17, "%016lX", m_id);
|
|
return std::string(buf);
|
|
}
|
|
};
|
|
|
|
/* PAK 128-bit Unique ID */
|
|
class UniqueID128 : public BigDNA
|
|
{
|
|
union
|
|
{
|
|
uint64_t m_id[2];
|
|
#if __SSE__
|
|
__m128i m_id128;
|
|
#endif
|
|
};
|
|
public:
|
|
Delete expl;
|
|
inline void read(Athena::io::IStreamReader& reader)
|
|
{
|
|
m_id[0] = reader.readUint64();
|
|
m_id[1] = reader.readUint64();
|
|
}
|
|
inline void write(Athena::io::IStreamWriter& writer) const
|
|
{
|
|
writer.writeUint64(m_id[0]);
|
|
writer.writeUint64(m_id[1]);
|
|
}
|
|
|
|
inline bool operator!=(const UniqueID128& other) const
|
|
{
|
|
#if __SSE__
|
|
__m128i vcmp = _mm_cmpeq_epi32(m_id128, other.m_id128);
|
|
int vmask = _mm_movemask_epi8(vcmp);
|
|
return vmask != 0xffff;
|
|
#else
|
|
return (m_id[0] != other.m_id[0]) || (m_id[1] != other.m_id[1]);
|
|
#endif
|
|
}
|
|
inline bool operator==(const UniqueID128& other) const
|
|
{
|
|
#if __SSE__
|
|
__m128i vcmp = _mm_cmpeq_epi32(m_id128, other.m_id128);
|
|
int vmask = _mm_movemask_epi8(vcmp);
|
|
return vmask == 0xffff;
|
|
#else
|
|
return (m_id[0] == other.m_id[0]) && (m_id[1] == other.m_id[1]);
|
|
#endif
|
|
}
|
|
inline uint64_t toHighUint64() const {return m_id[0];}
|
|
inline uint64_t toLowUint64() const {return m_id[1];}
|
|
inline std::string toString() const
|
|
{
|
|
char buf[33];
|
|
snprintf(buf, 33, "%016lX%016lX", m_id[0], m_id[1]);
|
|
return std::string(buf);
|
|
}
|
|
};
|
|
|
|
/* RGBA8 structure (GXColor) */
|
|
struct GXColor : BigDNA
|
|
{
|
|
Value<atUint8> r;
|
|
Value<atUint8> g;
|
|
Value<atUint8> b;
|
|
Value<atUint8> a;
|
|
Delete expl;
|
|
void read(Athena::io::IStreamReader& reader)
|
|
{reader.readUBytesToBuf(&r, 4);}
|
|
void write(Athena::io::IStreamWriter& writer) const
|
|
{writer.writeUBytes(&r, 4);}
|
|
};
|
|
|
|
/* More GX structures */
|
|
|
|
enum GXAttrType
|
|
{
|
|
GX_NONE,
|
|
GX_DIRECT,
|
|
GX_INDEX8,
|
|
GX_INDEX16
|
|
};
|
|
|
|
enum GXTevColorArg {
|
|
GX_CC_CPREV = 0, /*!< Use the color value from previous TEV stage */
|
|
GX_CC_APREV = 1, /*!< Use the alpha value from previous TEV stage */
|
|
GX_CC_C0 = 2, /*!< Use the color value from the color/output register 0 */
|
|
GX_CC_A0 = 3, /*!< Use the alpha value from the color/output register 0 */
|
|
GX_CC_C1 = 4, /*!< Use the color value from the color/output register 1 */
|
|
GX_CC_A1 = 5, /*!< Use the alpha value from the color/output register 1 */
|
|
GX_CC_C2 = 6, /*!< Use the color value from the color/output register 2 */
|
|
GX_CC_A2 = 7, /*!< Use the alpha value from the color/output register 2 */
|
|
GX_CC_TEXC = 8, /*!< Use the color value from texture */
|
|
GX_CC_TEXA = 9, /*!< Use the alpha value from texture */
|
|
GX_CC_RASC = 10, /*!< Use the color value from rasterizer */
|
|
GX_CC_RASA = 11, /*!< Use the alpha value from rasterizer */
|
|
GX_CC_ONE = 12,
|
|
GX_CC_HALF = 13,
|
|
GX_CC_KONST = 14,
|
|
GX_CC_ZERO = 15 /*!< Use to pass zero value */
|
|
};
|
|
|
|
enum GXTevAlphaArg {
|
|
GX_CA_APREV = 0, /*!< Use the alpha value from previous TEV stage */
|
|
GX_CA_A0 = 1, /*!< Use the alpha value from the color/output register 0 */
|
|
GX_CA_A1 = 2, /*!< Use the alpha value from the color/output register 1 */
|
|
GX_CA_A2 = 3, /*!< Use the alpha value from the color/output register 2 */
|
|
GX_CA_TEXA = 4, /*!< Use the alpha value from texture */
|
|
GX_CA_RASA = 5, /*!< Use the alpha value from rasterizer */
|
|
GX_CA_KONST = 6,
|
|
GX_CA_ZERO = 7 /*!< Use to pass zero value */
|
|
};
|
|
|
|
enum GXTevOp {
|
|
GX_TEV_ADD = 0,
|
|
GX_TEV_SUB = 1,
|
|
GX_TEV_COMP_R8_GT = 8,
|
|
GX_TEV_COMP_R8_EQ = 9,
|
|
GX_TEV_COMP_GR16_GT = 10,
|
|
GX_TEV_COMP_GR16_EQ = 11,
|
|
GX_TEV_COMP_BGR24_GT = 12,
|
|
GX_TEV_COMP_BGR24_EQ = 13,
|
|
GX_TEV_COMP_RGB8_GT = 14,
|
|
GX_TEV_COMP_RGB8_EQ = 15,
|
|
GX_TEV_COMP_A8_GT = GX_TEV_COMP_RGB8_GT, // for alpha channel
|
|
GX_TEV_COMP_A8_EQ = GX_TEV_COMP_RGB8_EQ // for alpha channel
|
|
};
|
|
|
|
enum GXTevBias {
|
|
GX_TB_ZERO = 0,
|
|
GX_TB_ADDHALF = 1,
|
|
GX_TB_SUBHALF = 2,
|
|
};
|
|
|
|
enum GXTevScale {
|
|
GX_CS_SCALE_1 = 0,
|
|
GX_CS_SCALE_2 = 1,
|
|
GX_CS_SCALE_4 = 2,
|
|
GX_CS_DIVIDE_2 = 3
|
|
};
|
|
|
|
enum GXTevRegID {
|
|
GX_TEVPREV = 0,
|
|
GX_TEVREG0 = 1,
|
|
GX_TEVREG1 = 2,
|
|
GX_TEVREG2 = 3
|
|
};
|
|
|
|
/* Case-insensitive comparator for std::map sorting */
|
|
struct CaseInsensitiveCompare
|
|
{
|
|
inline bool operator()(const std::string& lhs, const std::string& rhs) const
|
|
{
|
|
#if _WIN32
|
|
if (_stricmp(lhs.c_str(), rhs.c_str()) < 0)
|
|
#else
|
|
if (strcasecmp(lhs.c_str(), rhs.c_str()) < 0)
|
|
#endif
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
#if _WIN32
|
|
inline bool operator()(const std::wstring& lhs, const std::wstring& rhs) const
|
|
{
|
|
if (_wcsicmp(lhs.c_str(), rhs.c_str()) < 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
/* PAK entry stream reader */
|
|
class PAKEntryReadStream : public Athena::io::IStreamReader
|
|
{
|
|
std::unique_ptr<atUint8[]> m_buf;
|
|
atUint64 m_sz;
|
|
atUint64 m_pos;
|
|
public:
|
|
PAKEntryReadStream() {}
|
|
operator bool() const {return m_buf.operator bool();}
|
|
PAKEntryReadStream(const PAKEntryReadStream& other) = delete;
|
|
PAKEntryReadStream(PAKEntryReadStream&& other) = default;
|
|
PAKEntryReadStream& operator=(const PAKEntryReadStream& other) = delete;
|
|
PAKEntryReadStream& operator=(PAKEntryReadStream&& other) = default;
|
|
PAKEntryReadStream(std::unique_ptr<atUint8[]>&& buf, atUint64 sz, atUint64 pos)
|
|
: m_buf(std::move(buf)), m_sz(sz), m_pos(pos)
|
|
{
|
|
if (m_pos >= m_sz)
|
|
LogDNACommon.report(LogVisor::FatalError, "PAK stream cursor overrun");
|
|
}
|
|
inline void seek(atInt64 pos, Athena::SeekOrigin origin)
|
|
{
|
|
if (origin == Athena::Begin)
|
|
m_pos = pos;
|
|
else if (origin == Athena::Current)
|
|
m_pos += pos;
|
|
else if (origin == Athena::End)
|
|
m_pos = m_sz + pos;
|
|
if (m_pos >= m_sz)
|
|
LogDNACommon.report(LogVisor::FatalError, "PAK stream cursor overrun");
|
|
}
|
|
inline atUint64 position() const {return m_pos;}
|
|
inline atUint64 length() const {return m_sz;}
|
|
inline const atUint8* data() const {return m_buf.get();}
|
|
inline atUint64 readUBytesToBuf(void* buf, atUint64 len)
|
|
{
|
|
atUint64 bufEnd = m_pos + len;
|
|
if (bufEnd > m_sz)
|
|
len -= bufEnd - m_sz;
|
|
memcpy(buf, m_buf.get() + m_pos, len);
|
|
m_pos += len;
|
|
return len;
|
|
}
|
|
};
|
|
|
|
/* Resource extractor type */
|
|
typedef struct
|
|
{
|
|
std::function<bool(PAKEntryReadStream&, const HECL::ProjectPath&)> func;
|
|
const char* fileExt;
|
|
} ResExtractor;
|
|
|
|
/* Resource cooker function */
|
|
typedef std::function<bool(const HECL::ProjectPath&, const HECL::ProjectPath&)> ResCooker;
|
|
|
|
/* Language-identifiers */
|
|
extern const HECL::FourCC ENGL;
|
|
extern const HECL::FourCC FREN;
|
|
extern const HECL::FourCC GERM;
|
|
extern const HECL::FourCC SPAN;
|
|
extern const HECL::FourCC ITAL;
|
|
extern const HECL::FourCC JAPN;
|
|
|
|
/* Resource types */
|
|
extern const HECL::FourCC AFSM;
|
|
extern const HECL::FourCC AGSC;
|
|
extern const HECL::FourCC ANCS;
|
|
extern const HECL::FourCC ANIM;
|
|
extern const HECL::FourCC ATBL;
|
|
extern const HECL::FourCC CINF;
|
|
extern const HECL::FourCC CMDL;
|
|
extern const HECL::FourCC CRSC;
|
|
extern const HECL::FourCC CSKR;
|
|
extern const HECL::FourCC CSMP;
|
|
extern const HECL::FourCC CSNG;
|
|
extern const HECL::FourCC CTWK;
|
|
extern const HECL::FourCC DGRP;
|
|
extern const HECL::FourCC DPSC;
|
|
extern const HECL::FourCC DUMB;
|
|
extern const HECL::FourCC ELSC;
|
|
extern const HECL::FourCC EVNT;
|
|
extern const HECL::FourCC FONT;
|
|
extern const HECL::FourCC FRME;
|
|
extern const HECL::FourCC HINT;
|
|
extern const HECL::FourCC MAPA;
|
|
extern const HECL::FourCC MAPU;
|
|
extern const HECL::FourCC MAPW;
|
|
extern const HECL::FourCC MLVL;
|
|
extern const HECL::FourCC MREA;
|
|
extern const HECL::FourCC PART;
|
|
extern const HECL::FourCC PATH;
|
|
extern const HECL::FourCC RFRM;
|
|
extern const HECL::FourCC ROOM;
|
|
extern const HECL::FourCC SAVW;
|
|
extern const HECL::FourCC SCAN;
|
|
extern const HECL::FourCC STRG;
|
|
extern const HECL::FourCC SWHC;
|
|
extern const HECL::FourCC TXTR;
|
|
extern const HECL::FourCC WPSC;
|
|
|
|
}
|
|
|
|
/* Hash template-specializations for UniqueID types */
|
|
namespace std
|
|
{
|
|
template<>
|
|
struct hash<Retro::FourCC>
|
|
{
|
|
inline size_t operator()(const Retro::FourCC& fcc) const
|
|
{return fcc.toUint32();}
|
|
};
|
|
|
|
template<>
|
|
struct hash<Retro::UniqueID32>
|
|
{
|
|
inline size_t operator()(const Retro::UniqueID32& id) const
|
|
{return id.toUint32();}
|
|
};
|
|
|
|
template<>
|
|
struct hash<Retro::UniqueID64>
|
|
{
|
|
inline size_t operator()(const Retro::UniqueID64& id) const
|
|
{return id.toUint64();}
|
|
};
|
|
|
|
template<>
|
|
struct hash<Retro::UniqueID128>
|
|
{
|
|
inline size_t operator()(const Retro::UniqueID128& id) const
|
|
{return id.toHighUint64() ^ id.toLowUint64();}
|
|
};
|
|
}
|
|
|
|
#endif // __DNA_COMMON_HPP__
|