metaforce/DataSpec/SpecMP1.cpp

424 lines
15 KiB
C++
Raw Normal View History

2015-07-07 03:22:44 +00:00
#include <utility>
2015-07-16 01:57:34 +00:00
#include <stdio.h>
2015-07-22 19:05:18 +00:00
#include <string.h>
2015-07-07 03:22:44 +00:00
2015-07-01 23:50:39 +00:00
#include "SpecBase.hpp"
2015-07-17 00:01:05 +00:00
#include "DNAMP1/DNAMP1.hpp"
2015-07-01 23:50:39 +00:00
2015-10-01 00:40:21 +00:00
#include "DNAMP1/MLVL.hpp"
#include "DNAMP1/STRG.hpp"
2015-10-07 01:17:17 +00:00
#include "DNAMP1/CMDL.hpp"
2015-10-23 00:45:26 +00:00
#include "DNAMP1/ANCS.hpp"
2016-03-28 21:38:48 +00:00
#include "DNACommon/PART.hpp"
#include "DNACommon/SWHC.hpp"
#include "DNACommon/ELSC.hpp"
#include "DNACommon/WPSC.hpp"
#include "DNACommon/CRSC.hpp"
#include "DNACommon/DPSC.hpp"
2015-10-01 00:40:21 +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
static logvisor::Module Log("urde::SpecMP1");
extern hecl::Database::DataSpecEntry SpecEntMP1;
2015-07-16 01:57:34 +00:00
2015-07-07 03:22:44 +00:00
struct SpecMP1 : SpecBase
2015-07-01 23:50:39 +00:00
{
2015-07-14 01:07:15 +00:00
bool checkStandaloneID(const char* id) const
{
if (!memcmp(id, "GM8", 3))
return true;
return false;
}
2016-03-04 23:04:53 +00:00
std::vector<const nod::Node*> m_nonPaks;
2015-07-17 00:01:05 +00:00
std::vector<DNAMP1::PAKBridge> m_paks;
2016-03-04 23:04:53 +00:00
std::map<std::string, DNAMP1::PAKBridge*, hecl::CaseInsensitiveCompare> m_orderedPaks;
2015-07-07 03:22:44 +00:00
2016-03-04 23:04:53 +00:00
hecl::ProjectPath m_workPath;
hecl::ProjectPath m_cookPath;
2015-07-28 23:53:57 +00:00
PAKRouter<DNAMP1::PAKBridge> m_pakRouter;
SpecMP1(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
: SpecBase(specEntry, project, pc),
2015-10-01 00:40:21 +00:00
m_workPath(project.getProjectWorkingPath(), _S("MP1")),
2015-07-28 23:53:57 +00:00
m_cookPath(project.getProjectCookedPath(SpecEntMP1), _S("MP1")),
2015-08-05 21:46:07 +00:00
m_pakRouter(*this, m_workPath, m_cookPath) {}
2015-07-28 23:53:57 +00:00
2016-03-04 23:04:53 +00:00
void buildPaks(nod::Node& root,
const std::vector<hecl::SystemString>& args,
2015-07-12 18:07:58 +00:00
ExtractReport& rep)
2015-07-01 23:50:39 +00:00
{
m_nonPaks.clear();
2015-07-12 18:07:58 +00:00
m_paks.clear();
2016-03-04 23:04:53 +00:00
for (const nod::Node& child : root)
2015-07-07 03:22:44 +00:00
{
bool isPak = false;
2015-07-10 05:28:08 +00:00
const std::string& name = child.getName();
std::string lowerName = name;
std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), tolower);
if (name.size() > 4)
2015-07-07 03:22:44 +00:00
{
2015-07-10 05:28:08 +00:00
std::string::iterator extit = lowerName.end() - 4;
if (!std::string(extit, lowerName.end()).compare(".pak"))
2015-07-07 03:22:44 +00:00
{
2015-07-10 05:28:08 +00:00
/* This is a pak */
isPak = true;
2015-07-10 05:28:08 +00:00
std::string lowerBase(lowerName.begin(), extit);
/* Needs filter */
bool good = true;
if (args.size())
{
good = false;
if (!lowerName.compare(0, 7, "metroid"))
{
2016-03-04 23:04:53 +00:00
hecl::SystemChar idxChar = lowerName[7];
for (const hecl::SystemString& arg : args)
2015-07-10 05:28:08 +00:00
{
if (arg.size() == 1 && iswdigit(arg[0]))
if (arg[0] == idxChar)
2015-07-10 05:28:08 +00:00
good = true;
}
}
2015-07-12 18:07:58 +00:00
else
good = true;
2015-07-10 05:28:08 +00:00
if (!good)
{
2016-03-04 23:04:53 +00:00
for (const hecl::SystemString& arg : args)
2015-07-10 05:28:08 +00:00
{
std::string lowerArg = hecl::SystemUTF8View(arg).str();
2015-07-10 05:28:08 +00:00
std::transform(lowerArg.begin(), lowerArg.end(), lowerArg.begin(), tolower);
if (!lowerArg.compare(0, lowerBase.size(), lowerBase))
good = true;
}
}
}
m_paks.emplace_back(m_project, child, good);
2015-07-17 00:01:05 +00:00
2015-07-07 03:22:44 +00:00
}
}
if (!isPak)
m_nonPaks.push_back(&child);
2015-07-10 05:28:08 +00:00
}
2015-07-12 04:26:26 +00:00
/* Sort PAKs alphabetically */
2015-07-12 18:07:58 +00:00
m_orderedPaks.clear();
2015-07-17 00:01:05 +00:00
for (DNAMP1::PAKBridge& dpak : m_paks)
m_orderedPaks[dpak.getName()] = &dpak;
2015-07-12 04:26:26 +00:00
2015-07-12 18:07:58 +00:00
/* Assemble extract report */
2015-10-04 05:08:56 +00:00
rep.childOpts.reserve(m_orderedPaks.size());
2015-07-17 00:01:05 +00:00
for (const std::pair<std::string, DNAMP1::PAKBridge*>& item : m_orderedPaks)
2015-07-10 05:28:08 +00:00
{
if (!item.second->m_doExtract)
continue;
2015-07-10 05:28:08 +00:00
rep.childOpts.emplace_back();
ExtractReport& childRep = rep.childOpts.back();
2016-03-04 23:04:53 +00:00
hecl::SystemStringView nameView(item.first);
2015-07-22 19:05:18 +00:00
childRep.name = nameView;
2015-07-17 00:01:05 +00:00
childRep.desc = item.second->getLevelString();
2015-07-07 03:22:44 +00:00
}
2015-07-01 23:50:39 +00:00
}
2015-07-12 18:07:58 +00:00
2016-03-04 23:04:53 +00:00
bool checkFromStandaloneDisc(nod::DiscBase& disc,
const hecl::SystemString& regstr,
const std::vector<hecl::SystemString>& args,
2015-10-04 05:08:56 +00:00
std::vector<ExtractReport>& reps)
2015-07-01 23:50:39 +00:00
{
2016-03-04 23:04:53 +00:00
nod::Partition* partition = disc.getDataPartition();
2015-07-12 18:07:58 +00:00
std::unique_ptr<uint8_t[]> dolBuf = partition->getDOLBuf();
const char* buildInfo = (char*)memmem(dolBuf.get(), partition->getDOLSize(), "MetroidBuildInfo", 16) + 19;
2015-07-07 03:22:44 +00:00
if (!buildInfo)
return false;
/* Root Report */
2015-07-12 18:07:58 +00:00
reps.emplace_back();
ExtractReport& rep = reps.back();
rep.name = _S("MP1");
rep.desc = _S("Metroid Prime ") + regstr;
2015-07-12 18:07:58 +00:00
if (buildInfo)
{
2015-07-14 01:07:15 +00:00
std::string buildStr(buildInfo);
2016-03-04 23:04:53 +00:00
hecl::SystemStringView buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")");
}
2015-07-12 18:07:58 +00:00
/* Iterate PAKs and build level options */
2016-03-04 23:04:53 +00:00
nod::Node& root = partition->getFSTRoot();
2015-08-15 22:56:55 +00:00
buildPaks(root, args, rep);
2015-07-12 18:07:58 +00:00
return true;
2015-07-01 23:50:39 +00:00
}
2016-03-04 23:04:53 +00:00
bool checkFromTrilogyDisc(nod::DiscBase& disc,
const hecl::SystemString& regstr,
const std::vector<hecl::SystemString>& args,
2015-10-04 05:08:56 +00:00
std::vector<ExtractReport>& reps)
2015-07-01 23:50:39 +00:00
{
2016-03-04 23:04:53 +00:00
std::vector<hecl::SystemString> mp1args;
bool doExtract = false;
if (args.size())
{
/* Needs filter */
2016-03-04 23:04:53 +00:00
for (const hecl::SystemString& arg : args)
{
2016-03-04 23:04:53 +00:00
hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg);
2015-07-22 19:05:18 +00:00
if (!lowerArg.compare(0, 3, _S("mp1")))
{
doExtract = true;
2015-10-04 05:08:56 +00:00
mp1args.reserve(args.size());
size_t slashPos = arg.find(_S('/'));
2016-03-04 23:04:53 +00:00
if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_S('\\'));
2016-03-04 23:04:53 +00:00
if (slashPos != hecl::SystemString::npos)
mp1args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
}
}
}
else
doExtract = true;
if (!doExtract)
return false;
2016-03-04 23:04:53 +00:00
nod::Partition* partition = disc.getDataPartition();
nod::Node& root = partition->getFSTRoot();
nod::Node::DirectoryIterator dolIt = root.find("rs5mp1_p.dol");
if (dolIt == root.end())
return false;
std::unique_ptr<uint8_t[]> dolBuf = dolIt->getBuf();
const char* buildInfo = (char*)memmem(dolBuf.get(), dolIt->size(), "MetroidBuildInfo", 16) + 19;
/* Root Report */
reps.emplace_back();
ExtractReport& rep = reps.back();
rep.name = _S("MP1");
rep.desc = _S("Metroid Prime ") + regstr;
if (buildInfo)
{
std::string buildStr(buildInfo);
2016-03-04 23:04:53 +00:00
hecl::SystemStringView buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")");
}
/* Iterate PAKs and build level options */
2016-03-04 23:04:53 +00:00
nod::Node::DirectoryIterator mp1It = root.find("MP1");
if (mp1It == root.end())
return false;
2015-08-15 22:56:55 +00:00
buildPaks(*mp1It, mp1args, rep);
2015-07-07 03:22:44 +00:00
return true;
2015-07-01 23:50:39 +00:00
}
2015-07-16 01:57:34 +00:00
2016-03-04 23:04:53 +00:00
bool extractFromDisc(nod::DiscBase&, bool force, FProgress progress)
2015-07-01 23:50:39 +00:00
{
2016-03-30 20:44:19 +00:00
m_project.enableDataSpecs({_S("MP1-PC")});
2016-03-04 23:04:53 +00:00
nod::ExtractionContext ctx = {true, force, nullptr};
2015-09-29 03:49:31 +00:00
m_workPath.makeDir();
2016-03-05 00:03:41 +00:00
const hecl::ProjectPath& cookPath = m_project.getProjectCookedPath(SpecEntMP1);
cookPath.makeDir();
m_cookPath.makeDir();
2015-09-02 22:00:40 +00:00
progress(_S("Indexing PAKs"), _S(""), 2, 0.0);
2015-07-28 23:53:57 +00:00
m_pakRouter.build(m_paks, [&progress](float factor)
{
2015-09-02 22:00:40 +00:00
progress(_S("Indexing PAKs"), _S(""), 2, factor);
2015-07-28 23:53:57 +00:00
});
2015-09-02 22:00:40 +00:00
progress(_S("Indexing PAKs"), _S(""), 2, 1.0);
2015-07-28 23:53:57 +00:00
2016-03-05 00:03:41 +00:00
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _S("out"));
outPath.makeDir();
2016-03-05 00:03:41 +00:00
hecl::ProjectPath mp1OutPath(outPath, _S("MP1"));
mp1OutPath.makeDir();
2015-09-02 22:00:40 +00:00
progress(_S("MP1 Root"), _S(""), 3, 0.0);
2015-07-20 23:25:16 +00:00
int prog = 0;
ctx.progressCB = [&](const std::string& name) {
2016-03-04 23:04:53 +00:00
hecl::SystemStringView nameView(name);
progress(_S("MP1 Root"), nameView.sys_str().c_str(), 3, prog / (float)m_nonPaks.size());
};
2016-03-04 23:04:53 +00:00
for (const nod::Node* node : m_nonPaks)
2015-07-20 23:25:16 +00:00
{
node->extractToDirectory(mp1OutPath.getAbsolutePath(), ctx);
prog++;
2015-07-20 23:25:16 +00:00
}
2015-09-02 22:00:40 +00:00
progress(_S("MP1 Root"), _S(""), 3, 1.0);
2015-07-28 23:53:57 +00:00
int compIdx = 4;
2015-07-20 23:25:16 +00:00
prog = 0;
2015-08-08 00:08:16 +00:00
for (std::pair<std::string, DNAMP1::PAKBridge*> pair : m_orderedPaks)
2015-07-16 01:57:34 +00:00
{
2015-08-08 00:08:16 +00:00
DNAMP1::PAKBridge& pak = *pair.second;
if (!pak.m_doExtract)
continue;
2015-07-17 00:01:05 +00:00
const std::string& name = pak.getName();
2016-03-04 23:04:53 +00:00
hecl::SystemStringView sysName(name);
2015-07-20 23:25:16 +00:00
2015-09-02 22:00:40 +00:00
progress(sysName.sys_str().c_str(), _S(""), compIdx, 0.0);
m_pakRouter.extractResources(pak, force,
2016-03-04 23:04:53 +00:00
[&progress, &sysName, &compIdx](const hecl::SystemChar* substr, float factor)
2015-07-20 23:25:16 +00:00
{
2015-09-02 22:00:40 +00:00
progress(sysName.sys_str().c_str(), substr, compIdx, factor);
2015-07-20 23:25:16 +00:00
});
2015-09-02 22:00:40 +00:00
progress(sysName.sys_str().c_str(), _S(""), compIdx++, 1.0);
2015-07-16 01:57:34 +00:00
}
return true;
2015-07-01 23:50:39 +00:00
}
2015-10-01 00:40:21 +00:00
const hecl::Database::DataSpecEntry* getOriginalSpec() const
{
return &SpecEntMP1;
}
hecl::ProjectPath getWorking(class UniqueID32& id)
2015-11-10 02:07:15 +00:00
{
return m_pakRouter.getWorking(id);
}
2016-03-04 23:04:53 +00:00
bool checkPathPrefix(const hecl::ProjectPath& path)
2015-10-04 05:08:56 +00:00
{
2015-10-12 04:41:28 +00:00
return path.getRelativePath().compare(0, 4, _S("MP1/")) == 0;
2015-10-04 05:08:56 +00:00
}
2015-10-01 00:40:21 +00:00
bool validateYAMLDNAType(FILE* fp) const
{
2016-03-28 21:38:48 +00:00
athena::io::YAMLDocReader reader;
yaml_parser_set_input_file(reader.getParser(), fp);
return reader.ClassTypeOperation([](const char* classType)
{
if (!strcmp(classType, DNAMP1::MLVL::DNAType()))
return true;
else if (!strcmp(classType, DNAMP1::STRG::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::GPSM<UniqueID32>::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::SWSH<UniqueID32>::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::ELSM<UniqueID32>::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::WPSM<UniqueID32>::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::CRSM<UniqueID32>::DNAType()))
return true;
else if (!strcmp(classType, DNAParticle::DPSM<UniqueID32>::DNAType()))
return true;
2016-03-28 21:38:48 +00:00
return false;
});
2015-10-01 00:40:21 +00:00
}
2015-10-04 05:08:56 +00:00
2016-03-04 23:04:53 +00:00
void cookMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, FCookProgress progress) const
2015-10-04 05:08:56 +00:00
{
2016-03-04 23:04:53 +00:00
Mesh mesh = ds.compileMesh(fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, -1,
[&progress](int surfCount)
{
2016-03-04 23:04:53 +00:00
progress(hecl::SysFormat(_S("%d"), surfCount).c_str());
});
2015-10-14 23:07:29 +00:00
DNAMP1::CMDL::Cook(out, in, mesh);
2015-10-04 05:08:56 +00:00
}
2016-03-04 23:04:53 +00:00
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, FCookProgress progress) const
2015-10-04 05:08:56 +00:00
{
2015-10-23 00:45:26 +00:00
Actor actor = ds.compileActor();
DNAMP1::ANCS::Cook(out, in, actor);
2015-10-04 05:08:56 +00:00
}
2016-03-04 23:04:53 +00:00
void cookArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, FCookProgress progress) const
2015-10-04 05:08:56 +00:00
{
}
2016-03-04 23:04:53 +00:00
void cookYAML(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
FILE* fin, FCookProgress progress) const
2015-10-04 05:08:56 +00:00
{
2016-03-28 21:38:48 +00:00
athena::io::YAMLDocReader reader;
yaml_parser_set_input_file(reader.getParser(), fin);
if (reader.parse())
{
std::string classStr = reader.readString("DNAType");
if (classStr.empty())
return;
if (!classStr.compare(DNAMP1::STRG::DNAType()))
{
DNAMP1::STRG strg;
strg.read(reader);
DNAMP1::STRG::Cook(strg, out);
}
else if (!classStr.compare(DNAParticle::GPSM<UniqueID32>::DNAType()))
{
DNAParticle::GPSM<UniqueID32> gpsm;
gpsm.read(reader);
DNAParticle::WriteGPSM(gpsm, out);
}
else if (!classStr.compare(DNAParticle::SWSH<UniqueID32>::DNAType()))
{
DNAParticle::SWSH<UniqueID32> swsh;
swsh.read(reader);
DNAParticle::WriteSWSH(swsh, out);
}
else if (!classStr.compare(DNAParticle::ELSM<UniqueID32>::DNAType()))
{
DNAParticle::ELSM<UniqueID32> elsm;
elsm.read(reader);
DNAParticle::WriteELSM(elsm, out);
}
else if (!classStr.compare(DNAParticle::WPSM<UniqueID32>::DNAType()))
{
DNAParticle::WPSM<UniqueID32> wpsm;
wpsm.read(reader);
DNAParticle::WriteWPSM(wpsm, out);
}
else if (!classStr.compare(DNAParticle::CRSM<UniqueID32>::DNAType()))
{
DNAParticle::CRSM<UniqueID32> crsm;
crsm.read(reader);
DNAParticle::WriteCRSM(crsm, out);
}
else if (!classStr.compare(DNAParticle::DPSM<UniqueID32>::DNAType()))
{
DNAParticle::DPSM<UniqueID32> dpsm;
dpsm.read(reader);
DNAParticle::WriteDPSM(dpsm, out);
}
2016-03-28 21:38:48 +00:00
}
progress(_S("Done"));
2015-10-04 05:08:56 +00:00
}
2015-07-01 23:50:39 +00:00
};
2016-03-04 23:04:53 +00:00
hecl::Database::DataSpecEntry SpecEntMP1 =
2015-07-06 01:33:06 +00:00
{
2015-07-01 23:50:39 +00:00
_S("MP1"),
_S("Data specification for original Metroid Prime engine"),
2016-03-04 23:04:53 +00:00
[](hecl::Database::Project& project, hecl::Database::DataSpecTool)
-> hecl::Database::IDataSpec* {return new struct SpecMP1(&SpecEntMP1, project, false);}
2015-07-06 01:33:06 +00:00
};
2015-07-01 23:50:39 +00:00
hecl::Database::DataSpecEntry SpecEntMP1PC =
{
_S("MP1-PC"),
_S("Data specification for PC-optimized Metroid Prime engine"),
[](hecl::Database::Project& project, hecl::Database::DataSpecTool tool)
-> hecl::Database::IDataSpec*
{
if (tool != hecl::Database::DataSpecTool::Extract)
return new struct SpecMP1(&SpecEntMP1PC, project, true);
return nullptr;
}
};
2015-07-01 23:50:39 +00:00
}