AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-12-10 01:47:43 +00:00
Code Issues Projects Releases Wiki Activity

initial MLVL and STRG trilogy integration

Browse Source
This commit is contained in:
Jack Andersen
2015-07-12 20:29:12 -10:00
parent abb9d4c000
commit 7876d4c209
26 changed files with 1333 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
DataSpec/DNAMP3/CMakeLists.txt
View File

@@ -1,4 +1,7 @@
make_dnalist(liblist
PAK)
PAK
MLVL
STRG)
add_library(DNAMP3 ${liblist}
PAK.cpp)
PAK.cpp
STRG.cpp)

82
DataSpec/DNAMP3/MLVL.hpp Normal file
View File

@@ -0,0 +1,82 @@
#ifndef __DNAMP3_MLVL_HPP__
#define __DNAMP3_MLVL_HPP__
#include "../DNACommon/DNACommon.hpp"
namespace Retro
{
namespace DNAMP3
{
struct MLVL : BigDNA
{
DECL_DNA
Value<atUint32> magic;
Value<atUint32> version;
UniqueID64 worldNameId;
Value<atUint32> unk;
UniqueID64 saveWorldId;
UniqueID64 worldSkyboxId;
Value<atUint32> areaCount;
struct Area : BigDNA
{
DECL_DNA
UniqueID64 areaNameId;
Value<atVec4f> transformMtx[3];
Value<atVec3f> aabb[2];
UniqueID64 areaMREAId;
Value<atUint32> areaId;
Value<atUint32> attachedAreaCount;
Vector<atUint16, DNA_COUNT(attachedAreaCount)> attachedAreas;
Value<atUint32> dockCount;
struct Dock : BigDNA
{
DECL_DNA
Value<atUint32> endpointCount;
struct Endpoint : BigDNA
{
DECL_DNA
Value<atUint32> areaIdx;
Value<atUint32> dockIdx;
};
FourCC type;
Vector<Endpoint, DNA_COUNT(endpointCount)> endpoints;
Value<atUint32> planeVertCount;
Vector<atVec3f, DNA_COUNT(planeVertCount)> planeVerts;
};
Vector<Dock, DNA_COUNT(dockCount)> docks;
String<-1> internalAreaName;
};
UniqueID64 worldMap;
Value<atUint8> unknown2;
Value<atUint32> unknown3;
Value<atUint32> layerFlagCount;
struct LayerFlags : BigDNA
{
DECL_DNA
Value<atUint32> layerCount;
Value<atUint64> flags;
};
Vector<LayerFlags, DNA_COUNT(layerFlagCount)> layerFlags;
Value<atUint32> layerNameCount;
Vector<String<-1>, DNA_COUNT(layerNameCount)> layerNames;
Value<atUint32> layerIDCount;
Vector<UniqueID128, DNA_COUNT(layerIDCount)> layerIDs;
Value<atUint32> layerNameOffsetCount;
Vector<atUint32, DNA_COUNT(layerNameOffsetCount)> layerNameOffsets;
};
}
}
#endif // __DNAMP3_MLVL_HPP__

15
DataSpec/DNAMP3/PAK.cpp
View File

@@ -19,6 +19,7 @@ void PAK::read(Athena::io::IStreamReader& reader)
reader.seek(44, Athena::Current);
m_dataOffset = 128 + strgSz + rshdSz;
atUint64 strgBase = reader.position();
atUint32 nameCount = reader.readUint32();
m_nameEntries.clear();
m_nameEntries.reserve(nameCount);
@@ -27,7 +28,10 @@ void PAK::read(Athena::io::IStreamReader& reader)
m_nameEntries.emplace_back();
m_nameEntries.back().read(reader);
}
reader.seek((reader.position() + 63) & ~63, Athena::Begin);
atUint64 start = reader.position();
reader.seek(strgBase + strgSz, Athena::Begin);
atUint64 end = reader.position();
atUint64 diff = end - start;
atUint32 count = reader.readUint32();
m_entries.clear();
@@ -38,16 +42,17 @@ void PAK::read(Athena::io::IStreamReader& reader)
{
m_entries.emplace_back();
m_entries.back().read(reader);
m_idMap[m_entries.back().id] = &m_entries.back();
}
for (Entry& entry : m_entries)
m_idMap[entry.id] = &entry;
m_nameMap.clear();
m_nameMap.reserve(nameCount);
for (NameEntry& entry : m_nameEntries)
{
std::unordered_map<UniqueID64, Entry*>::iterator found = m_idMap.find(entry.id);
if (found != m_idMap.end())
m_nameMap[entry.name] = found->second;
auto search = m_idMap.find(entry.id);
if (search != m_idMap.end())
m_nameMap[entry.name] = search->second;
}
}
void PAK::write(Athena::io::IStreamWriter& writer) const

9
DataSpec/DNAMP3/PAK.hpp
View File

@@ -11,9 +11,8 @@ namespace Retro
namespace DNAMP3
{
class PAK : public BigDNA
struct PAK : BigDNA
{
public:
struct Header : BigDNA
{
DECL_DNA
@@ -35,20 +34,18 @@ public:
{
DECL_DNA
Value<atUint32> compressed;
HECL::FourCC type;
FourCC type;
UniqueID64 id;
Value<atUint32> size;
Value<atUint32> offset;
};
private:
std::vector<NameEntry> m_nameEntries;
std::vector<Entry> m_entries;
std::unordered_map<UniqueID64, Entry*> m_idMap;
std::unordered_map<std::string, Entry*> m_nameMap;
size_t m_dataOffset = 0;
public:
DECL_EXPLICIT_DNA
inline const Entry* lookupEntry(const UniqueID64& id) const
@@ -67,8 +64,6 @@ public:
return nullptr;
}
inline std::vector<Entry>::iterator begin() {return m_entries.begin();}
inline std::vector<Entry>::iterator end() {return m_entries.end();}
inline size_t getDataOffset() const {return m_dataOffset;}
};

119
DataSpec/DNAMP3/STRG.cpp Normal file
View File

@@ -0,0 +1,119 @@
#include "STRG.hpp"
#include "../Logging.hpp"
namespace Retro
{
namespace DNAMP3
{
void STRG::_read(Athena::io::IStreamReader& reader)
{
atUint32 langCount = reader.readUint32();
atUint32 strCount = reader.readUint32();
atUint32 nameCount = reader.readUint32();
atUint32 nameTableSz = reader.readUint32();
std::unique_ptr<uint8_t[]> nameTableBuf(new uint8_t[nameTableSz]);
reader.readUBytesToBuf(nameTableBuf.get(), nameTableSz);
struct NameIdxEntry
{
atUint32 nameOff;
atUint32 strIdx;
}* nameIndex = (NameIdxEntry*)nameTableBuf.get();
for (atUint32 n=0 ; n<nameCount ; ++n)
{
const char* name = (char*)(nameTableBuf.get() + HECL::SBig(nameIndex[n].nameOff));
names[name] = HECL::SBig(nameIndex[n].strIdx);
}
std::vector<FourCC> readLangs;
readLangs.reserve(langCount);
for (atUint32 l=0 ; l<langCount ; ++l)
{
FourCC lang;
lang.read(reader);
readLangs.emplace_back(lang);
reader.seek(strCount * 4 + 4);
}
langs.clear();
langs.reserve(langCount);
for (FourCC& lang : readLangs)
{
std::vector<std::string> strs;
for (atUint32 s=0 ; s<strCount ; ++s)
{
atUint32 len = reader.readUint32();
strs.emplace_back(reader.readString(len));
}
langs.emplace(lang, strs);
}
}
void STRG::read(Athena::io::IStreamReader& reader)
{
reader.setEndian(Athena::BigEndian);
atUint32 magic = reader.readUint32();
if (magic != 0x87654321)
LogModule.report(LogVisor::Error, "invalid STRG magic");
atUint32 version = reader.readUint32();
if (version != 3)
LogModule.report(LogVisor::Error, "invalid STRG version");
_read(reader);
}
void STRG::write(Athena::io::IStreamWriter& writer) const
{
writer.setEndian(Athena::BigEndian);
writer.writeUint32(0x87654321);
writer.writeUint32(3);
writer.writeUint32(langs.size());
atUint32 strCount = STRG::count();
writer.writeUint32(strCount);
atUint32 nameTableSz = names.size() * 8;
for (const std::pair<std::string, int32_t>& name : names)
nameTableSz += name.first.size() + 1;
writer.writeUint32(names.size());
writer.writeUint32(nameTableSz);
atUint32 offset = names.size() * 8;
for (const std::pair<std::string, int32_t>& name : names)
{
writer.writeUint32(offset);
writer.writeInt32(name.second);
offset += name.first.size() + 1;
}
for (const std::pair<std::string, int32_t>& name : names)
writer.writeString(name.first);
offset = 0;
for (const std::pair<FourCC, std::vector<std::string>>& lang : langs)
{
lang.first.write(writer);
atUint32 langSz = 0;
for (const std::string& str : lang.second)
langSz += str.size() + 4;
writer.writeUint32(langSz);
for (const std::string& str : lang.second)
{
writer.writeUint32(offset);
offset += str.size() + 4;
}
}
for (const std::pair<FourCC, std::vector<std::string>>& lang : langs)
{
for (const std::string& str : lang.second)
{
writer.writeUint32(str.size());
writer.writeString(str, str.size());
}
}
}
}
}

69
DataSpec/DNAMP3/STRG.hpp Normal file
View File

@@ -0,0 +1,69 @@
#ifndef __DNAMP3_STRG_HPP__
#define __DNAMP3_STRG_HPP__
#include <unordered_map>
#include "../DNACommon/DNACommon.hpp"
#include "../DNACommon/STRG.hpp"
namespace Retro
{
namespace DNAMP3
{
struct STRG : ISTRG, BigDNA
{
DECL_EXPLICIT_DNA
void _read(Athena::io::IStreamReader& reader);
std::unordered_map<FourCC, std::vector<std::string>> langs;
std::map<std::string, int32_t> names;
inline int32_t lookupIdx(const std::string& name) const
{
auto search = names.find(name);
if (search == names.end())
return -1;
return search->second;
}
inline size_t count() const
{
size_t retval = 0;
for (auto item : langs)
{
size_t sz = item.second.size();
if (sz > retval)
retval = sz;
}
return retval;
}
inline std::string getUTF8(const FourCC& lang, size_t idx) const
{
auto search = langs.find(lang);
if (search != langs.end())
return search->second.at(idx);
return std::string();
}
inline std::wstring getUTF16(const FourCC& lang, size_t idx) const
{
auto search = langs.find(lang);
if (search != langs.end())
return HECL::UTF8ToWide(search->second.at(idx));
return std::wstring();
}
inline HECL::SystemString getSystemString(const FourCC& lang, size_t idx) const
{
auto search = langs.find(lang);
if (search != langs.end())
#if HECL_UCS2
return HECL::UTF8ToWide(search->second.at(idx));
#else
return search->second.at(idx);
#endif
return std::string();
}
};
}
}
#endif // __DNAMP2_STRG_HPP__