mirror of https://github.com/AxioDL/metaforce.git
1280 lines
49 KiB
C++
1280 lines
49 KiB
C++
#include <utility>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
|
|
#include "SpecBase.hpp"
|
|
#include "DNAMP1/DNAMP1.hpp"
|
|
|
|
#include "DNAMP1/HINT.hpp"
|
|
#include "DNAMP1/MLVL.hpp"
|
|
#include "DNAMP1/STRG.hpp"
|
|
#include "DNAMP1/SCAN.hpp"
|
|
#include "DNAMP1/CMDL.hpp"
|
|
#include "DNAMP1/DCLN.hpp"
|
|
#include "DNAMP1/MREA.hpp"
|
|
#include "DNAMP1/ANCS.hpp"
|
|
#include "DNAMP1/AGSC.hpp"
|
|
#include "DNAMP1/CSNG.hpp"
|
|
#include "DNAMP1/MAPA.hpp"
|
|
#include "DNAMP1/PATH.hpp"
|
|
#include "DNAMP1/FRME.hpp"
|
|
#include "DNAMP1/AFSM.hpp"
|
|
#include "DNACommon/ATBL.hpp"
|
|
#include "DNACommon/FONT.hpp"
|
|
#include "DNACommon/PART.hpp"
|
|
#include "DNACommon/SWHC.hpp"
|
|
#include "DNACommon/ELSC.hpp"
|
|
#include "DNACommon/WPSC.hpp"
|
|
#include "DNACommon/CRSC.hpp"
|
|
#include "DNACommon/DPSC.hpp"
|
|
#include "DNACommon/DGRP.hpp"
|
|
#include "DNACommon/MAPU.hpp"
|
|
#include "DNACommon/MetaforceVersionInfo.hpp"
|
|
#include "DNACommon/Tweaks/TweakWriter.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakPlayerRes.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakGunRes.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakSlideShow.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakPlayer.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakCameraBob.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakGame.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakTargeting.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakAutoMapper.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakGui.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakPlayerControl.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakBall.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakParticle.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakGuiColors.hpp"
|
|
#include "DNAMP1/Tweaks/CTweakPlayerGun.hpp"
|
|
#include "DNAMP1/MazeSeeds.hpp"
|
|
#include "DNAMP1/SnowForces.hpp"
|
|
#include "hecl/ClientProcess.hpp"
|
|
#include "hecl/MultiProgressPrinter.hpp"
|
|
#include "hecl/Blender/Connection.hpp"
|
|
#include "hecl/Blender/SDNARead.hpp"
|
|
#include "nod/nod.hpp"
|
|
|
|
namespace DataSpec {
|
|
|
|
using namespace std::literals;
|
|
|
|
static logvisor::Module Log("DataSpec::SpecMP1");
|
|
extern hecl::Database::DataSpecEntry SpecEntMP1;
|
|
extern hecl::Database::DataSpecEntry SpecEntMP1PC;
|
|
extern hecl::Database::DataSpecEntry SpecEntMP1ORIG;
|
|
|
|
struct TextureCache {
|
|
static void Generate(PAKRouter<DNAMP1::PAKBridge>& pakRouter, hecl::Database::Project& project,
|
|
const hecl::ProjectPath& pakPath) {
|
|
hecl::ProjectPath texturePath(pakPath, _SYS_STR("texture_cache.yaml"));
|
|
hecl::ProjectPath catalogPath(pakPath, _SYS_STR("!catalog.yaml"));
|
|
texturePath.makeDirChain(false);
|
|
|
|
if (const auto fp = hecl::FopenUnique(catalogPath.getAbsolutePath().data(), _SYS_STR("a"))) {
|
|
fmt::print(fp.get(), FMT_STRING("TextureCache: {}\n"), texturePath.getRelativePathUTF8());
|
|
}
|
|
|
|
Log.report(logvisor::Level::Info, FMT_STRING("Gathering Texture metadata (this can take up to 10 seconds)..."));
|
|
std::unordered_map<UniqueID32, TXTR::Meta> metaMap;
|
|
|
|
pakRouter.enumerateResources([&](const DNAMP1::PAK::Entry* ent) {
|
|
if (ent->type == FOURCC('TXTR') && metaMap.find(ent->id) == metaMap.end()) {
|
|
PAKEntryReadStream rs = pakRouter.beginReadStreamForId(ent->id);
|
|
metaMap[ent->id] = TXTR::GetMetaData(rs);
|
|
}
|
|
return true;
|
|
});
|
|
|
|
athena::io::YAMLDocWriter yamlW("MP1TextureCache");
|
|
for (const auto& pair : metaMap) {
|
|
hecl::ProjectPath path = pakRouter.getWorking(pair.first);
|
|
auto rec = yamlW.enterSubRecord(path.getRelativePathUTF8());
|
|
pair.second.write(yamlW);
|
|
}
|
|
|
|
athena::io::FileWriter fileW(texturePath.getAbsolutePath());
|
|
yamlW.finish(&fileW);
|
|
Log.report(logvisor::Level::Info, FMT_STRING("Done..."));
|
|
}
|
|
|
|
static void Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) {
|
|
hecl::Database::Project& project = inPath.getProject();
|
|
athena::io::YAMLDocReader r;
|
|
athena::io::FileReader fr(inPath.getAbsolutePath());
|
|
if (!fr.isOpen() || !r.parse(&fr))
|
|
return;
|
|
|
|
std::vector<std::pair<UniqueID32, TXTR::Meta>> metaPairs;
|
|
metaPairs.reserve(r.getRootNode()->m_mapChildren.size());
|
|
for (const auto& node : r.getRootNode()->m_mapChildren) {
|
|
hecl::ProjectPath projectPath(project, node.first);
|
|
auto rec = r.enterSubRecord(node.first.c_str());
|
|
TXTR::Meta meta;
|
|
meta.read(r);
|
|
metaPairs.emplace_back(projectPath.parsedHash32(), meta);
|
|
}
|
|
|
|
std::sort(metaPairs.begin(), metaPairs.end(),
|
|
[](const auto& a, const auto& b) -> bool { return a.first < b.first; });
|
|
|
|
athena::io::FileWriter w(outPath.getAbsolutePath());
|
|
w.writeUint32Big(metaPairs.size());
|
|
for (const auto& pair : metaPairs) {
|
|
pair.first.write(w);
|
|
pair.second.write(w);
|
|
}
|
|
}
|
|
};
|
|
|
|
struct SpecMP1 : SpecBase {
|
|
bool checkStandaloneID(const char* id) const override { return !memcmp(id, "GM8", 3); }
|
|
|
|
std::vector<const nod::Node*> m_nonPaks;
|
|
std::vector<DNAMP1::PAKBridge> m_paks;
|
|
std::map<std::string, DNAMP1::PAKBridge*, hecl::CaseInsensitiveCompare> m_orderedPaks;
|
|
|
|
hecl::ProjectPath m_workPath;
|
|
hecl::ProjectPath m_cookPath;
|
|
PAKRouter<DNAMP1::PAKBridge> m_pakRouter;
|
|
|
|
std::unique_ptr<uint8_t[]> m_dolBuf;
|
|
|
|
std::unordered_map<hecl::Hash, hecl::blender::Matrix4f> m_mreaPathToXF;
|
|
|
|
SpecMP1(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
|
|
: SpecBase(specEntry, project, pc)
|
|
, m_workPath(project.getProjectWorkingPath(), _SYS_STR("MP1"))
|
|
, m_cookPath(project.getProjectCookedPath(SpecEntMP1), _SYS_STR("MP1"))
|
|
, m_pakRouter(*this, m_workPath, m_cookPath) {
|
|
m_game = EGame::MetroidPrime1;
|
|
SpecBase::setThreadProject();
|
|
}
|
|
|
|
void buildPaks(nod::Node& root, const std::vector<hecl::SystemString>& args, ExtractReport& rep) {
|
|
m_nonPaks.clear();
|
|
m_paks.clear();
|
|
for (const nod::Node& child : root) {
|
|
bool isPak = false;
|
|
auto name = child.getName();
|
|
std::string lowerName(name);
|
|
std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), tolower);
|
|
if (name.size() > 4) {
|
|
std::string::iterator extit = lowerName.end() - 4;
|
|
if (std::string(extit, lowerName.end()) == ".pak") {
|
|
/* This is a pak */
|
|
isPak = true;
|
|
std::string lowerBase(lowerName.begin(), extit);
|
|
|
|
/* Needs filter */
|
|
bool good = true;
|
|
if (args.size()) {
|
|
good = false;
|
|
if (!lowerName.compare(0, 7, "metroid")) {
|
|
hecl::SystemChar idxChar = lowerName[7];
|
|
for (const hecl::SystemString& arg : args) {
|
|
if (arg.size() == 1 && iswdigit(arg[0]))
|
|
if (arg[0] == idxChar)
|
|
good = true;
|
|
}
|
|
} else
|
|
good = true;
|
|
|
|
if (!good) {
|
|
for (const hecl::SystemString& arg : args) {
|
|
std::string lowerArg(hecl::SystemUTF8Conv(arg).str());
|
|
std::transform(lowerArg.begin(), lowerArg.end(), lowerArg.begin(), tolower);
|
|
if (!lowerArg.compare(0, lowerBase.size(), lowerBase))
|
|
good = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_paks.emplace_back(child, good);
|
|
}
|
|
}
|
|
|
|
if (!isPak)
|
|
m_nonPaks.push_back(&child);
|
|
}
|
|
|
|
/* Sort PAKs alphabetically */
|
|
m_orderedPaks.clear();
|
|
for (DNAMP1::PAKBridge& dpak : m_paks) {
|
|
m_orderedPaks[std::string(dpak.getName())] = &dpak;
|
|
}
|
|
|
|
/* Assemble extract report */
|
|
rep.childOpts.reserve(m_orderedPaks.size());
|
|
for (const auto& item : m_orderedPaks) {
|
|
if (!item.second->m_doExtract) {
|
|
continue;
|
|
}
|
|
|
|
ExtractReport& childRep = rep.childOpts.emplace_back();
|
|
hecl::SystemStringConv nameView(item.first);
|
|
childRep.name = nameView.sys_str();
|
|
childRep.desc = item.second->getLevelString();
|
|
}
|
|
}
|
|
|
|
bool checkFromStandaloneDisc(nod::DiscBase& disc, const hecl::SystemString& regstr,
|
|
const std::vector<hecl::SystemString>& args, std::vector<ExtractReport>& reps) override {
|
|
nod::IPartition* partition = disc.getDataPartition();
|
|
m_dolBuf = partition->getDOLBuf();
|
|
const char* buildInfo =
|
|
static_cast<char*>(memmem(m_dolBuf.get(), partition->getDOLSize(), "MetroidBuildInfo", 16)) + 19;
|
|
|
|
if (buildInfo == nullptr)
|
|
return false;
|
|
|
|
m_version = std::string(buildInfo);
|
|
/* Root Report */
|
|
ExtractReport& rep = reps.emplace_back();
|
|
rep.name = _SYS_STR("MP1");
|
|
rep.desc = _SYS_STR("Metroid Prime ") + regstr;
|
|
if (buildInfo) {
|
|
hecl::SystemStringConv buildView(m_version);
|
|
rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
|
|
}
|
|
|
|
/* Iterate PAKs and build level options */
|
|
nod::Node& root = partition->getFSTRoot();
|
|
buildPaks(root, args, rep);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool checkFromTrilogyDisc(nod::DiscBase& disc, const hecl::SystemString& regstr,
|
|
const std::vector<hecl::SystemString>& args, std::vector<ExtractReport>& reps) override {
|
|
std::vector<hecl::SystemString> mp1args;
|
|
bool doExtract = false;
|
|
if (args.size()) {
|
|
/* Needs filter */
|
|
for (const hecl::SystemString& arg : args) {
|
|
hecl::SystemString lowerArg = arg;
|
|
hecl::ToLower(lowerArg);
|
|
if (!lowerArg.compare(0, 3, _SYS_STR("mp1"))) {
|
|
doExtract = true;
|
|
mp1args.reserve(args.size());
|
|
size_t slashPos = arg.find(_SYS_STR('/'));
|
|
if (slashPos == hecl::SystemString::npos)
|
|
slashPos = arg.find(_SYS_STR('\\'));
|
|
if (slashPos != hecl::SystemString::npos)
|
|
mp1args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
|
|
}
|
|
}
|
|
} else
|
|
doExtract = true;
|
|
|
|
if (!doExtract)
|
|
return false;
|
|
|
|
nod::IPartition* partition = disc.getDataPartition();
|
|
nod::Node& root = partition->getFSTRoot();
|
|
nod::Node::DirectoryIterator dolIt = root.find("rs5mp1_p.dol");
|
|
if (dolIt == root.end()) {
|
|
dolIt = root.find("rs5mp1jpn_p.dol");
|
|
if (dolIt == root.end())
|
|
return false;
|
|
}
|
|
|
|
m_dolBuf = dolIt->getBuf();
|
|
const char* buildInfo = static_cast<char*>(memmem(m_dolBuf.get(), dolIt->size(), "MetroidBuildInfo", 16)) + 19;
|
|
|
|
/* Root Report */
|
|
ExtractReport& rep = reps.emplace_back();
|
|
rep.name = _SYS_STR("MP1");
|
|
rep.desc = _SYS_STR("Metroid Prime ") + regstr;
|
|
if (buildInfo != nullptr) {
|
|
m_version = std::string(buildInfo);
|
|
hecl::SystemStringConv buildView(m_version);
|
|
rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
|
|
}
|
|
|
|
/* Iterate PAKs and build level options */
|
|
nod::Node::DirectoryIterator mp1It = root.find("MP1");
|
|
if (mp1It == root.end()) {
|
|
mp1It = root.find("MP1JPN");
|
|
if (mp1It == root.end())
|
|
return false;
|
|
}
|
|
buildPaks(*mp1It, mp1args, rep);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress) override {
|
|
m_project.enableDataSpecs({_SYS_STR("MP1-PC")});
|
|
|
|
nod::ExtractionContext ctx = {force, nullptr};
|
|
|
|
m_workPath.makeDir();
|
|
|
|
progress.startNewLine();
|
|
progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
|
|
m_pakRouter.build(m_paks,
|
|
[&progress](float factor) { progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor); });
|
|
progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
|
|
|
|
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
|
|
outPath.makeDir();
|
|
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
|
|
hecl::ProjectPath mp1OutPath(outPath, _SYS_STR("files/MP1"));
|
|
mp1OutPath.makeDirChain(true);
|
|
|
|
/* Extract non-pak files */
|
|
progress.startNewLine();
|
|
progress.print(_SYS_STR("MP1 Root"), _SYS_STR(""), 0.0);
|
|
int prog = 0;
|
|
ctx.progressCB = [&](std::string_view name, float) {
|
|
hecl::SystemStringConv nameView(name);
|
|
progress.print(_SYS_STR("MP1 Root"), nameView.c_str(), prog / (float)m_nonPaks.size());
|
|
};
|
|
for (const nod::Node* node : m_nonPaks) {
|
|
node->extractToDirectory(mp1OutPath.getAbsolutePath(), ctx);
|
|
prog++;
|
|
}
|
|
progress.print(_SYS_STR("MP1 Root"), _SYS_STR(""), 1.0);
|
|
|
|
/* Extract unique resources */
|
|
hecl::ClientProcess process;
|
|
progress.startNewLine();
|
|
for (std::pair<const std::string, DNAMP1::PAKBridge*>& pair : m_orderedPaks) {
|
|
#if 0
|
|
const DNAMP1::PAK::Entry* ent = pair.second->getPAK().lookupEntry(UniqueID32(0xE39FC9A1));
|
|
if (ent) {
|
|
PAKEntryReadStream rs = ent->beginReadStream(pair.second->getNode());
|
|
DNAMP1::CMDL::Extract(*this, rs, hecl::ProjectPath(m_project.getProjectWorkingPath(), "MP1/Metroid1/!1IntroLevel1027/CMDL_E39FC9A1.blend"), m_pakRouter, *ent, true, hecl::blender::SharedBlenderToken, {});
|
|
|
|
ent = pair.second->getPAK().lookupEntry(UniqueID32(0xC1AE2B4A));
|
|
rs = ent->beginReadStream(pair.second->getNode());
|
|
DNAMP1::CMDL::Extract(*this, rs, hecl::ProjectPath(m_project.getProjectWorkingPath(), "MP1/Metroid1/!1IntroLevel1027/CMDL_C1AE2B4A.blend"), m_pakRouter, *ent, true, hecl::blender::SharedBlenderToken, {});
|
|
|
|
exit(0);
|
|
}
|
|
else
|
|
continue;
|
|
#endif
|
|
|
|
DNAMP1::PAKBridge& pak = *pair.second;
|
|
if (!pak.m_doExtract)
|
|
continue;
|
|
|
|
auto name = pak.getName();
|
|
hecl::SystemStringConv sysName(name);
|
|
|
|
auto pakName = hecl::SystemString(sysName.sys_str());
|
|
process.addLambdaTransaction([this, &progress, &pak, pakName, force](hecl::blender::Token& btok) {
|
|
int threadIdx = hecl::ClientProcess::GetThreadWorkerIdx();
|
|
m_pakRouter.extractResources(pak, force, btok,
|
|
[&progress, &pakName, threadIdx](const hecl::SystemChar* substr, float factor) {
|
|
progress.print(pakName.c_str(), substr, factor, threadIdx);
|
|
});
|
|
});
|
|
}
|
|
|
|
process.waitUntilComplete();
|
|
|
|
/* Extract part of .dol for RandomStatic entropy */
|
|
hecl::ProjectPath noAramPath(m_project.getProjectWorkingPath(), _SYS_STR("MP1/URDE"));
|
|
extractRandomStaticEntropy(m_dolBuf.get() + 0x4f60, noAramPath);
|
|
|
|
/* Generate Texture Cache containing meta data for every texture file */
|
|
TextureCache::Generate(m_pakRouter, m_project, noAramPath);
|
|
|
|
/* Write version data */
|
|
hecl::ProjectPath versionPath = hecl::ProjectPath(m_project.getProjectWorkingPath(), _SYS_STR("out/files/MP1"));
|
|
WriteVersionInfo(m_project, versionPath);
|
|
return true;
|
|
}
|
|
|
|
const hecl::Database::DataSpecEntry& getOriginalSpec() const override { return SpecEntMP1; }
|
|
|
|
const hecl::Database::DataSpecEntry& getUnmodifiedSpec() const override { return SpecEntMP1ORIG; }
|
|
|
|
hecl::ProjectPath getWorking(class UniqueID32& id) override { return m_pakRouter.getWorking(id); }
|
|
|
|
bool checkPathPrefix(const hecl::ProjectPath& path) const override {
|
|
return path.getRelativePath().compare(0, 4, _SYS_STR("MP1/")) == 0;
|
|
}
|
|
|
|
bool validateYAMLDNAType(athena::io::IStreamReader& fp) const override {
|
|
athena::io::YAMLDocReader reader;
|
|
yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)athena::io::YAMLAthenaReader, &fp);
|
|
return reader.ClassTypeOperation([](std::string_view classType) {
|
|
if (classType == DNAMP1::MLVL::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::STRG::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::SCAN::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::GPSM<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::SWSH<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::ELSM<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::WPSM<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::CRSM<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAParticle::DPSM<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNADGRP::DGRP<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAFont::FONT<UniqueID32>::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakPlayerRes<true>::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakPlayerRes<false>::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakGunRes::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakSlideShow::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakPlayer::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakCameraBob::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakGame::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakAutoMapper::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakTargeting<true>::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakTargeting<false>::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakGui::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakPlayerControl::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakBall::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakParticle::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakGuiColors::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::CTweakPlayerGun::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::HINT::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::EVNT::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::MazeSeeds::DNAType())
|
|
return true;
|
|
else if (classType == DNAMP1::SnowForces::DNAType())
|
|
return true;
|
|
else if (classType == "ATBL")
|
|
return true;
|
|
else if (classType == DNAMP1::AFSM::DNAType())
|
|
return true;
|
|
else if (classType == "MP1TextureCache")
|
|
return true;
|
|
return false;
|
|
});
|
|
}
|
|
|
|
metaforce::SObjectTag buildTagFromPath(const hecl::ProjectPath& path) const override {
|
|
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CSKR")))
|
|
return {SBIG('CSKR'), path.parsedHash32()};
|
|
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".ANIM")))
|
|
return {SBIG('ANIM'), path.parsedHash32()};
|
|
else if (const hecl::SystemChar* ext = path.getLastComponentExt().data()) {
|
|
if (ext[0] == _SYS_STR('*') || !hecl::StrCmp(ext, _SYS_STR("mid"))) {
|
|
if (path.getWithExtension(_SYS_STR(".mid"), true).isFile() &&
|
|
path.getWithExtension(_SYS_STR(".yaml"), true).isFile()) {
|
|
hecl::ProjectPath glob = path.getWithExtension(_SYS_STR(".*"), true);
|
|
return {SBIG('CSNG'), glob.parsedHash32()};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Directory) {
|
|
if (hecl::ProjectPath(path, _SYS_STR("!project.yaml")).isFile() &&
|
|
hecl::ProjectPath(path, _SYS_STR("!pool.yaml")).isFile())
|
|
return {SBIG('AGSC'), path.parsedHash32()};
|
|
}
|
|
|
|
hecl::ProjectPath asBlend;
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Glob)
|
|
asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
|
|
else
|
|
asBlend = path;
|
|
|
|
if (hecl::IsPathBlend(asBlend)) {
|
|
switch (hecl::blender::GetBlendType(asBlend.getAbsolutePath())) {
|
|
case hecl::blender::BlendType::Mesh:
|
|
return {SBIG('CMDL'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::ColMesh:
|
|
return {SBIG('DCLN'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::Armature:
|
|
return {SBIG('CINF'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::PathMesh:
|
|
return {SBIG('PATH'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::Actor:
|
|
if (path.getAuxInfo().size()) {
|
|
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CSKR")))
|
|
return {SBIG('CSKR'), path.getWithExtension(_SYS_STR(".*"), true).parsedHash32()};
|
|
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".ANIM")))
|
|
return {SBIG('ANIM'), path.getWithExtension(_SYS_STR(".*"), true).parsedHash32()};
|
|
}
|
|
return {SBIG('ANCS'), path.getWithExtension(_SYS_STR(".*"), true).parsedHash32()};
|
|
case hecl::blender::BlendType::Area:
|
|
return {SBIG('MREA'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::World:
|
|
return {SBIG('MLVL'), path.getWithExtension(_SYS_STR(".*"), true).parsedHash32()};
|
|
case hecl::blender::BlendType::MapArea:
|
|
return {SBIG('MAPA'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::MapUniverse:
|
|
return {SBIG('MAPU'), path.parsedHash32()};
|
|
case hecl::blender::BlendType::Frame:
|
|
return {SBIG('FRME'), path.parsedHash32()};
|
|
default:
|
|
return {};
|
|
}
|
|
} else if (hecl::IsPathPNG(path)) {
|
|
return {SBIG('TXTR'), path.parsedHash32()};
|
|
} else if (hecl::IsPathYAML(path)) {
|
|
auto fp = hecl::FopenUnique(path.getAbsolutePath().data(), _SYS_STR("r"));
|
|
if (fp == nullptr) {
|
|
return {};
|
|
}
|
|
|
|
athena::io::YAMLDocReader reader;
|
|
yaml_parser_set_input_file(reader.getParser(), fp.get());
|
|
|
|
metaforce::SObjectTag resTag;
|
|
if (reader.ClassTypeOperation([&](std::string_view className) {
|
|
if (className == DNAParticle::GPSM<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('PART');
|
|
return true;
|
|
}
|
|
if (className == DNAParticle::SWSH<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('SWHC');
|
|
return true;
|
|
}
|
|
if (className == DNAParticle::ELSM<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('ELSC');
|
|
return true;
|
|
}
|
|
if (className == DNAParticle::WPSM<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('WPSC');
|
|
return true;
|
|
}
|
|
if (className == DNAParticle::CRSM<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('CRSC');
|
|
return true;
|
|
}
|
|
if (className == DNAParticle::DPSM<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('DPSC');
|
|
return true;
|
|
} else if (className == DNAFont::FONT<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('FONT');
|
|
return true;
|
|
} else if (className == DNAMP1::EVNT::DNAType()) {
|
|
resTag.type = SBIG('EVNT');
|
|
return true;
|
|
} else if (className == DNADGRP::DGRP<UniqueID32>::DNAType()) {
|
|
resTag.type = SBIG('DGRP');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::STRG::DNAType()) {
|
|
resTag.type = SBIG('STRG');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::SCAN::DNAType()) {
|
|
resTag.type = SBIG('SCAN');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::CTweakPlayerRes<true>::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakPlayerRes<false>::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakGunRes::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakSlideShow::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakPlayer::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakCameraBob::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakGame::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakTargeting<true>::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakTargeting<false>::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakAutoMapper::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakGui::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakPlayerControl::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakBall::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakParticle::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakGuiColors::DNAType() ||
|
|
className == DataSpec::DNAMP1::CTweakPlayerGun::DNAType()) {
|
|
resTag.type = SBIG('CTWK');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::MazeSeeds::DNAType() ||
|
|
className == DataSpec::DNAMP1::SnowForces::DNAType()) {
|
|
resTag.type = SBIG('DUMB');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::HINT::DNAType()) {
|
|
resTag.type = SBIG('HINT');
|
|
return true;
|
|
} else if (className == "ATBL") {
|
|
resTag.type = SBIG('ATBL');
|
|
return true;
|
|
} else if (className == DataSpec::DNAMP1::AFSM::DNAType()) {
|
|
resTag.type = SBIG('AFSM');
|
|
return true;
|
|
} else if (className == "MP1TextureCache") {
|
|
resTag.type = SBIG('TMET');
|
|
return true;
|
|
} else if (className == "DataSpec::DNAMP1::SAVW") {
|
|
resTag.type = SBIG('SAVW');
|
|
return true;
|
|
} else if (className == "DataSpec::DNAMP1::MAPW") {
|
|
resTag.type = SBIG('MAPW');
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
})) {
|
|
resTag.id = path.parsedHash32();
|
|
fp.reset();
|
|
return resTag;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void getTagListForFile(const char* pakName, std::vector<metaforce::SObjectTag>& out) const override {
|
|
std::string pathPrefix("MP1/");
|
|
pathPrefix += pakName;
|
|
pathPrefix += '/';
|
|
|
|
std::unique_lock lk(m_backgroundIndexMutex);
|
|
for (const auto& tag : m_tagToPath)
|
|
if (!tag.second.getRelativePathUTF8().compare(0, pathPrefix.size(), pathPrefix))
|
|
out.push_back(tag.first);
|
|
}
|
|
|
|
void cookMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
Mesh mesh = ds.compileMesh(fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, m_pc ? 16 : -1);
|
|
|
|
if (m_pc)
|
|
DNAMP1::CMDL::HMDLCook(out, in, mesh);
|
|
else
|
|
DNAMP1::CMDL::Cook(out, in, mesh);
|
|
}
|
|
|
|
void cookColMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
std::vector<ColMesh> mesh = ds.compileColMeshes();
|
|
ds.close();
|
|
DNAMP1::DCLN::Cook(out, mesh);
|
|
}
|
|
|
|
void cookArmature(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
Armature armature = ds.compileArmature();
|
|
ds.close();
|
|
DNAMP1::CINF::Cook(out, in, armature);
|
|
}
|
|
|
|
void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
PathMesh mesh = ds.compilePathMesh();
|
|
ds.close();
|
|
DNAMP1::PATH::Cook(out, in, mesh, btok);
|
|
}
|
|
|
|
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR(".CSKR"))) {
|
|
Actor actor = ds.compileActorCharacterOnly();
|
|
ds.close();
|
|
if (m_pc) {
|
|
DNAMP1::ANCS::CookCSKRPC(out, in, actor, [&](const hecl::ProjectPath& modelPath) {
|
|
hecl::ProjectPath cooked = modelPath.getCookedPath(SpecEntMP1PC);
|
|
doCook(modelPath, cooked, fast, btok, progress);
|
|
return true;
|
|
});
|
|
} else {
|
|
DNAMP1::ANCS::CookCSKR(out, in, actor, [&](const hecl::ProjectPath& modelPath) {
|
|
hecl::ProjectPath cooked = modelPath.getCookedPath(SpecEntMP1);
|
|
doCook(modelPath, cooked, fast, btok, progress);
|
|
return true;
|
|
});
|
|
}
|
|
} else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR(".ANIM"))) {
|
|
Actor actor = ds.compileActorCharacterOnly();
|
|
DNAMP1::ANCS::CookANIM(out, in, actor, ds, m_pc);
|
|
} else {
|
|
Actor actor = ds.compileActor();
|
|
DNAMP1::ANCS::Cook(out, in, actor);
|
|
}
|
|
}
|
|
|
|
void buildAreaXFs(hecl::blender::Token& btok) {
|
|
hecl::blender::Connection& conn = btok.getBlenderConnection();
|
|
for (const auto& ent : m_workPath.enumerateDir()) {
|
|
if (ent.m_isDir) {
|
|
hecl::ProjectPath pakPath(m_workPath, ent.m_name);
|
|
for (const auto& ent2 : pakPath.enumerateDir()) {
|
|
if (ent2.m_isDir) {
|
|
hecl::ProjectPath wldDir(pakPath, ent2.m_name);
|
|
for (const auto& ent3 : wldDir.enumerateDir()) {
|
|
if (hecl::StringUtils::BeginsWith(ent3.m_name, _SYS_STR("!world")) &&
|
|
hecl::StringUtils::EndsWith(ent3.m_name, _SYS_STR(".blend"))) {
|
|
hecl::ProjectPath wldPath(wldDir, ent3.m_name);
|
|
if (wldPath.isFile()) {
|
|
if (!conn.openBlend(wldPath))
|
|
continue;
|
|
hecl::blender::DataStream ds = conn.beginData();
|
|
hecl::blender::World world = ds.compileWorld();
|
|
for (const auto& area : world.areas)
|
|
m_mreaPathToXF[area.path.hash()] = area.transform;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cookArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
std::vector<std::string> meshes = ds.getMeshList();
|
|
std::vector<Mesh> meshCompiles;
|
|
meshCompiles.reserve(meshes.size());
|
|
|
|
std::optional<ColMesh> colMesh;
|
|
|
|
for (const std::string& mesh : meshes) {
|
|
hecl::SystemStringConv meshSys(mesh);
|
|
if (mesh == "CMESH") {
|
|
colMesh = ds.compileColMesh(mesh);
|
|
progress(_SYS_STR("Collision Mesh"));
|
|
continue;
|
|
}
|
|
meshCompiles.push_back(
|
|
ds.compileMesh(mesh, fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, -1, !m_pc));
|
|
}
|
|
|
|
if (!colMesh)
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to find mesh named 'CMESH' in {}")),
|
|
in.getAbsolutePath());
|
|
|
|
std::vector<Light> lights = ds.compileLights();
|
|
|
|
ds.close();
|
|
|
|
if (m_mreaPathToXF.empty())
|
|
buildAreaXFs(btok);
|
|
|
|
const hecl::blender::Matrix4f* xf = nullptr;
|
|
auto xfSearch = m_mreaPathToXF.find(in.getParentPath().hash());
|
|
if (xfSearch != m_mreaPathToXF.cend())
|
|
xf = &xfSearch->second;
|
|
DNAMP1::MREA::Cook(out, in, meshCompiles, *colMesh, lights, btok, xf, m_pc);
|
|
}
|
|
|
|
void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
hecl::blender::World world = ds.compileWorld();
|
|
ds.close();
|
|
DNAMP1::MLVL::Cook(out, in, world, btok);
|
|
}
|
|
|
|
void cookGuiFrame(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
auto data = ds.compileGuiFrame(0);
|
|
athena::io::MemoryReader r(data.data(), data.size());
|
|
DNAMP1::FRME frme;
|
|
frme.read(r);
|
|
athena::io::FileWriter w(out.getAbsolutePath());
|
|
frme.write(w);
|
|
}
|
|
|
|
void cookYAML(const hecl::ProjectPath& out, const hecl::ProjectPath& in, athena::io::IStreamReader& fin,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
athena::io::YAMLDocReader reader;
|
|
if (reader.parse(&fin)) {
|
|
std::string classStr = reader.readString("DNAType");
|
|
if (classStr.empty())
|
|
return;
|
|
|
|
if (classStr == DNAMP1::STRG::DNAType()) {
|
|
DNAMP1::STRG strg;
|
|
strg.read(reader);
|
|
DNAMP1::STRG::Cook(strg, out);
|
|
} else if (classStr == DNAMP1::SCAN::DNAType()) {
|
|
DNAMP1::SCAN scan;
|
|
scan.read(reader);
|
|
DNAMP1::SCAN::Cook(scan, out);
|
|
} else if (classStr == DNAParticle::GPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::GPSM<UniqueID32> gpsm;
|
|
gpsm.read(reader);
|
|
DNAParticle::WriteGPSM(gpsm, out);
|
|
} else if (classStr == DNAParticle::SWSH<UniqueID32>::DNAType()) {
|
|
DNAParticle::SWSH<UniqueID32> swsh;
|
|
swsh.read(reader);
|
|
DNAParticle::WriteSWSH(swsh, out);
|
|
} else if (classStr == DNAParticle::ELSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::ELSM<UniqueID32> elsm;
|
|
elsm.read(reader);
|
|
DNAParticle::WriteELSM(elsm, out);
|
|
} else if (classStr == DNAParticle::WPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::WPSM<UniqueID32> wpsm;
|
|
wpsm.read(reader);
|
|
DNAParticle::WriteWPSM(wpsm, out);
|
|
} else if (classStr == DNAParticle::CRSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::CRSM<UniqueID32> crsm;
|
|
crsm.read(reader);
|
|
DNAParticle::WriteCRSM(crsm, out);
|
|
} else if (classStr == DNAParticle::DPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::DPSM<UniqueID32> dpsm;
|
|
dpsm.read(reader);
|
|
DNAParticle::WriteDPSM(dpsm, out);
|
|
} else if (classStr == DNADGRP::DGRP<UniqueID32>::DNAType()) {
|
|
DNADGRP::DGRP<UniqueID32> dgrp;
|
|
dgrp.read(reader);
|
|
dgrp.validateDeps();
|
|
DNADGRP::WriteDGRP(dgrp, out);
|
|
} else if (classStr == DNAFont::FONT<UniqueID32>::DNAType()) {
|
|
DNAFont::FONT<UniqueID32> font;
|
|
font.read(reader);
|
|
DNAFont::WriteFONT(font, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayerRes<true>::DNAType()) {
|
|
DNAMP1::CTweakPlayerRes<true> playerRes;
|
|
playerRes.read(reader);
|
|
WriteTweak(playerRes, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayerRes<false>::DNAType()) {
|
|
DNAMP1::CTweakPlayerRes<false> playerRes;
|
|
playerRes.read(reader);
|
|
WriteTweak(playerRes, out);
|
|
} else if (classStr == DNAMP1::CTweakGunRes::DNAType()) {
|
|
DNAMP1::CTweakGunRes gunRes;
|
|
gunRes.read(reader);
|
|
WriteTweak(gunRes, out);
|
|
} else if (classStr == DNAMP1::CTweakSlideShow::DNAType()) {
|
|
DNAMP1::CTweakSlideShow slideShow;
|
|
slideShow.read(reader);
|
|
WriteTweak(slideShow, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayer::DNAType()) {
|
|
DNAMP1::CTweakPlayer player;
|
|
player.read(reader);
|
|
WriteTweak(player, out);
|
|
} else if (classStr == DNAMP1::CTweakCameraBob::DNAType()) {
|
|
DNAMP1::CTweakCameraBob cBob;
|
|
cBob.read(reader);
|
|
WriteTweak(cBob, out);
|
|
} else if (classStr == DNAMP1::CTweakGame::DNAType()) {
|
|
DNAMP1::CTweakGame cGame;
|
|
cGame.read(reader);
|
|
WriteTweak(cGame, out);
|
|
} else if (classStr == DNAMP1::CTweakAutoMapper::DNAType()) {
|
|
DNAMP1::CTweakAutoMapper autoMapper;
|
|
autoMapper.read(reader);
|
|
WriteTweak(autoMapper, out);
|
|
} else if (classStr == DNAMP1::CTweakTargeting<true>::DNAType()) {
|
|
DNAMP1::CTweakTargeting<false> targeting;
|
|
targeting.read(reader);
|
|
WriteTweak(targeting, out);
|
|
} else if (classStr == DNAMP1::CTweakTargeting<false>::DNAType()) {
|
|
DNAMP1::CTweakTargeting<false> targeting;
|
|
targeting.read(reader);
|
|
WriteTweak(targeting, out);
|
|
} else if (classStr == DNAMP1::CTweakGui::DNAType()) {
|
|
DNAMP1::CTweakGui gui;
|
|
gui.read(reader);
|
|
WriteTweak(gui, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayerControl::DNAType()) {
|
|
DNAMP1::CTweakPlayerControl pc;
|
|
pc.read(reader);
|
|
WriteTweak(pc, out);
|
|
} else if (classStr == DNAMP1::CTweakBall::DNAType()) {
|
|
DNAMP1::CTweakBall ball;
|
|
ball.read(reader);
|
|
WriteTweak(ball, out);
|
|
} else if (classStr == DNAMP1::CTweakParticle::DNAType()) {
|
|
DNAMP1::CTweakParticle part;
|
|
part.read(reader);
|
|
WriteTweak(part, out);
|
|
} else if (classStr == DNAMP1::CTweakGuiColors::DNAType()) {
|
|
DNAMP1::CTweakGuiColors gColors;
|
|
gColors.read(reader);
|
|
WriteTweak(gColors, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayerGun::DNAType()) {
|
|
DNAMP1::CTweakPlayerGun pGun;
|
|
pGun.read(reader);
|
|
WriteTweak(pGun, out);
|
|
} else if (classStr == DNAMP1::CTweakPlayerControl::DNAType()) {
|
|
DNAMP1::CTweakPlayerControl pControl;
|
|
pControl.read(reader);
|
|
WriteTweak(pControl, out);
|
|
} else if (classStr == DNAMP1::MazeSeeds::DNAType()) {
|
|
DNAMP1::MazeSeeds mSeeds;
|
|
mSeeds.read(reader);
|
|
WriteTweak(mSeeds, out);
|
|
} else if (classStr == DNAMP1::SnowForces::DNAType()) {
|
|
DNAMP1::SnowForces sForces;
|
|
sForces.read(reader);
|
|
WriteTweak(sForces, out);
|
|
} else if (classStr == DNAMP1::HINT::DNAType()) {
|
|
DNAMP1::HINT::Cook(in, out);
|
|
} else if (classStr == DNAMP1::EVNT::DNAType()) {
|
|
DNAMP1::EVNT::Cook(in, out);
|
|
} else if (classStr == "ATBL") {
|
|
DNAAudio::ATBL::Cook(in, out);
|
|
} else if (classStr == DNAMP1::AFSM::DNAType()) {
|
|
DNAMP1::AFSM::Cook(in, out);
|
|
} else if (classStr == "MP1TextureCache") {
|
|
TextureCache::Cook(in, out);
|
|
}
|
|
}
|
|
progress(_SYS_STR("Done"));
|
|
}
|
|
|
|
void flattenDependenciesYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut) override {
|
|
athena::io::YAMLDocReader reader;
|
|
if (reader.parse(&fin)) {
|
|
std::string classStr = reader.readString("DNAType"sv);
|
|
if (classStr.empty())
|
|
return;
|
|
|
|
if (classStr == DNAMP1::STRG::DNAType()) {
|
|
DNAMP1::STRG strg;
|
|
strg.read(reader);
|
|
strg.gatherDependencies(pathsOut);
|
|
}
|
|
if (classStr == DNAMP1::SCAN::DNAType()) {
|
|
DNAMP1::SCAN scan;
|
|
scan.read(reader);
|
|
scan.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::GPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::GPSM<UniqueID32> gpsm;
|
|
gpsm.read(reader);
|
|
gpsm.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::SWSH<UniqueID32>::DNAType()) {
|
|
DNAParticle::SWSH<UniqueID32> swsh;
|
|
swsh.read(reader);
|
|
swsh.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::ELSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::ELSM<UniqueID32> elsm;
|
|
elsm.read(reader);
|
|
elsm.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::WPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::WPSM<UniqueID32> wpsm;
|
|
wpsm.read(reader);
|
|
wpsm.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::CRSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::CRSM<UniqueID32> crsm;
|
|
crsm.read(reader);
|
|
crsm.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAParticle::DPSM<UniqueID32>::DNAType()) {
|
|
DNAParticle::DPSM<UniqueID32> dpsm;
|
|
dpsm.read(reader);
|
|
dpsm.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAFont::FONT<UniqueID32>::DNAType()) {
|
|
DNAFont::FONT<UniqueID32> font;
|
|
font.read(reader);
|
|
font.gatherDependencies(pathsOut);
|
|
} else if (classStr == DNAMP1::EVNT::DNAType()) {
|
|
DNAMP1::EVNT evnt;
|
|
evnt.read(reader);
|
|
evnt.gatherDependencies(pathsOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
void flattenDependenciesANCSYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut,
|
|
int charIdx) override {
|
|
athena::io::YAMLDocReader reader;
|
|
if (reader.parse(&fin)) {
|
|
std::string classStr = reader.readString("DNAType");
|
|
if (classStr == DNAMP1::ANCS::DNAType()) {
|
|
DNAMP1::ANCS ancs;
|
|
ancs.read(reader);
|
|
ancs.gatherDependencies(pathsOut, charIdx);
|
|
}
|
|
}
|
|
}
|
|
|
|
void buildWorldPakList(const hecl::ProjectPath& worldPath, const hecl::ProjectPath& worldPathCooked,
|
|
hecl::blender::Token& btok, athena::io::FileWriter& w,
|
|
std::vector<metaforce::SObjectTag>& listOut, atUint64& resTableOffset,
|
|
std::unordered_map<metaforce::CAssetId, std::vector<uint8_t>>& mlvlData) override {
|
|
DNAMP1::MLVL mlvl;
|
|
{
|
|
athena::io::FileReader r(worldPathCooked.getAbsolutePath());
|
|
if (r.hasError())
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to open world {}")), worldPathCooked.getRelativePath());
|
|
mlvl.read(r);
|
|
}
|
|
|
|
size_t count = 5;
|
|
for (const auto& area : mlvl.areas) {
|
|
auto lazyIt = area.lazyDeps.cbegin();
|
|
auto it = area.deps.cbegin();
|
|
while (it != area.deps.cend()) {
|
|
if (it->id != lazyIt->id)
|
|
++count;
|
|
++lazyIt;
|
|
++it;
|
|
}
|
|
}
|
|
listOut.reserve(count);
|
|
|
|
metaforce::SObjectTag worldTag = tagFromPath(worldPath.getWithExtension(_SYS_STR(".*"), true));
|
|
|
|
w.writeUint32Big(m_pc ? 0x80030005 : 0x00030005);
|
|
w.writeUint32Big(0);
|
|
|
|
w.writeUint32Big(1);
|
|
DNAMP1::PAK::NameEntry nameEnt;
|
|
hecl::ProjectPath parentDir = worldPath.getParentPath();
|
|
nameEnt.type = worldTag.type;
|
|
nameEnt.id = worldTag.id.Value();
|
|
nameEnt.nameLen = atUint32(parentDir.getLastComponent().size());
|
|
nameEnt.name = parentDir.getLastComponentUTF8();
|
|
nameEnt.write(w);
|
|
|
|
std::unordered_set<metaforce::CAssetId> addedTags;
|
|
for (auto& area : mlvl.areas) {
|
|
metaforce::SObjectTag areaTag(FOURCC('MREA'), area.areaMREAId.toUint64());
|
|
|
|
bool dupeRes = false;
|
|
if (hecl::ProjectPath areaDir = pathFromTag(areaTag).getParentPath())
|
|
dupeRes = hecl::ProjectPath(areaDir, _SYS_STR("!duperes")).isFile();
|
|
|
|
metaforce::SObjectTag nameTag(FOURCC('STRG'), area.areaNameId.toUint64());
|
|
if (nameTag)
|
|
listOut.push_back(nameTag);
|
|
for (const auto& dep : area.deps) {
|
|
metaforce::CAssetId newId = dep.id.toUint64();
|
|
if (dupeRes || addedTags.find(newId) == addedTags.end()) {
|
|
listOut.emplace_back(dep.type, newId);
|
|
addedTags.insert(newId);
|
|
}
|
|
}
|
|
if (areaTag)
|
|
listOut.push_back(areaTag);
|
|
|
|
std::vector<DNAMP1::MLVL::Area::Dependency> strippedDeps;
|
|
strippedDeps.reserve(area.deps.size());
|
|
std::vector<atUint32> strippedDepLayers;
|
|
strippedDepLayers.reserve(area.depLayers.size());
|
|
auto lazyIt = area.lazyDeps.cbegin();
|
|
auto it = area.deps.cbegin();
|
|
auto layerIt = area.depLayers.cbegin();
|
|
while (it != area.deps.cend()) {
|
|
while (layerIt != area.depLayers.cend() && it - area.deps.cbegin() == *layerIt) {
|
|
strippedDepLayers.push_back(atUint32(strippedDeps.size()));
|
|
++layerIt;
|
|
}
|
|
if (it->id != lazyIt->id)
|
|
strippedDeps.push_back(*it);
|
|
++lazyIt;
|
|
++it;
|
|
}
|
|
|
|
area.lazyDepCount = 0;
|
|
area.lazyDeps.clear();
|
|
area.depCount = strippedDeps.size();
|
|
area.deps = std::move(strippedDeps);
|
|
area.depLayerCount = strippedDepLayers.size();
|
|
area.depLayers = std::move(strippedDepLayers);
|
|
}
|
|
|
|
metaforce::SObjectTag nameTag(FOURCC('STRG'), mlvl.worldNameId.toUint64());
|
|
if (nameTag)
|
|
listOut.push_back(nameTag);
|
|
|
|
metaforce::SObjectTag savwTag(FOURCC('SAVW'), mlvl.saveWorldId.toUint64());
|
|
if (savwTag) {
|
|
if (hecl::ProjectPath savwPath = pathFromTag(savwTag))
|
|
m_project.cookPath(savwPath, {}, false, true);
|
|
listOut.push_back(savwTag);
|
|
}
|
|
|
|
metaforce::SObjectTag mapTag(FOURCC('MAPW'), mlvl.worldMap.toUint64());
|
|
if (mapTag) {
|
|
if (hecl::ProjectPath mapPath = pathFromTag(mapTag)) {
|
|
m_project.cookPath(mapPath, {}, false, true);
|
|
if (hecl::ProjectPath mapCookedPath = getCookedPath(mapPath, true)) {
|
|
athena::io::FileReader r(mapCookedPath.getAbsolutePath());
|
|
if (r.hasError())
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to open {}")), mapCookedPath.getRelativePath());
|
|
|
|
if (r.readUint32Big() != 0xDEADF00D)
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Corrupt MAPW {}")), mapCookedPath.getRelativePath());
|
|
r.readUint32Big();
|
|
atUint32 mapaCount = r.readUint32Big();
|
|
for (atUint32 i = 0; i < mapaCount; ++i) {
|
|
UniqueID32 id;
|
|
id.read(r);
|
|
listOut.emplace_back(FOURCC('MAPA'), id.toUint64());
|
|
}
|
|
}
|
|
}
|
|
listOut.push_back(mapTag);
|
|
}
|
|
|
|
metaforce::SObjectTag skyboxTag(FOURCC('CMDL'), mlvl.worldSkyboxId.toUint64());
|
|
if (skyboxTag) {
|
|
listOut.push_back(skyboxTag);
|
|
hecl::ProjectPath skyboxPath = pathFromTag(skyboxTag);
|
|
if (btok.getBlenderConnection().openBlend(skyboxPath)) {
|
|
auto data = btok.getBlenderConnection().beginData();
|
|
std::vector<hecl::ProjectPath> textures = data.getTextures();
|
|
for (const auto& tex : textures) {
|
|
metaforce::SObjectTag texTag = tagFromPath(tex);
|
|
if (!texTag)
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to resolve {}")), tex.getRelativePath());
|
|
listOut.push_back(texTag);
|
|
}
|
|
}
|
|
}
|
|
|
|
listOut.push_back(worldTag);
|
|
|
|
w.writeUint32Big(atUint32(listOut.size()));
|
|
resTableOffset = w.position();
|
|
for (const auto& item : listOut) {
|
|
DNAMP1::PAK::Entry ent;
|
|
ent.compressed = 0;
|
|
ent.type = item.type;
|
|
ent.id = item.id.Value();
|
|
ent.size = 0;
|
|
ent.offset = 0;
|
|
ent.write(w);
|
|
}
|
|
|
|
{
|
|
std::vector<uint8_t>& mlvlOut = mlvlData[worldTag.id];
|
|
size_t mlvlSize = 0;
|
|
mlvl.binarySize(mlvlSize);
|
|
mlvlOut.resize(mlvlSize);
|
|
athena::io::MemoryWriter mw(&mlvlOut[0], mlvlSize);
|
|
mlvl.write(mw);
|
|
}
|
|
}
|
|
|
|
void buildPakList(hecl::blender::Token& btok, athena::io::FileWriter& w,
|
|
const std::vector<metaforce::SObjectTag>& list,
|
|
const std::vector<std::pair<metaforce::SObjectTag, std::string>>& nameList,
|
|
atUint64& resTableOffset) override {
|
|
w.writeUint32Big(m_pc ? 0x80030005 : 0x00030005);
|
|
w.writeUint32Big(0);
|
|
|
|
w.writeUint32Big(atUint32(nameList.size()));
|
|
for (const auto& item : nameList) {
|
|
DNAMP1::PAK::NameEntry nameEnt;
|
|
nameEnt.type = item.first.type;
|
|
nameEnt.id = item.first.id.Value();
|
|
nameEnt.nameLen = atUint32(item.second.size());
|
|
nameEnt.name = item.second;
|
|
nameEnt.write(w);
|
|
}
|
|
|
|
w.writeUint32Big(atUint32(list.size()));
|
|
resTableOffset = w.position();
|
|
for (const auto& item : list) {
|
|
DNAMP1::PAK::Entry ent;
|
|
ent.compressed = 0;
|
|
ent.type = item.type;
|
|
ent.id = item.id.Value();
|
|
ent.size = 0;
|
|
ent.offset = 0;
|
|
ent.write(w);
|
|
}
|
|
}
|
|
|
|
void writePakFileIndex(athena::io::FileWriter& w, const std::vector<metaforce::SObjectTag>& tags,
|
|
const std::vector<std::tuple<size_t, size_t, bool>>& index, atUint64 resTableOffset) override {
|
|
w.seek(resTableOffset, athena::SeekOrigin::Begin);
|
|
|
|
auto it = tags.begin();
|
|
for (const auto& item : index) {
|
|
const metaforce::SObjectTag& tag = *it++;
|
|
DNAMP1::PAK::Entry ent;
|
|
ent.compressed = atUint32(std::get<2>(item));
|
|
ent.type = tag.type;
|
|
ent.id = tag.id.Value();
|
|
ent.size = atUint32(std::get<1>(item));
|
|
ent.offset = atUint32(std::get<0>(item));
|
|
ent.write(w);
|
|
}
|
|
}
|
|
|
|
std::pair<std::unique_ptr<uint8_t[]>, size_t> compressPakData(const metaforce::SObjectTag& tag, const uint8_t* data,
|
|
size_t len) override {
|
|
bool doCompress = false;
|
|
switch (tag.type.toUint32()) {
|
|
case SBIG('TXTR'):
|
|
case SBIG('CMDL'):
|
|
case SBIG('CSKR'):
|
|
case SBIG('ANCS'):
|
|
case SBIG('ANIM'):
|
|
case SBIG('FONT'):
|
|
doCompress = true;
|
|
break;
|
|
case SBIG('PART'):
|
|
case SBIG('ELSC'):
|
|
case SBIG('SWHC'):
|
|
case SBIG('WPSC'):
|
|
case SBIG('DPSC'):
|
|
case SBIG('CRSC'):
|
|
doCompress = len >= 0x400;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!doCompress)
|
|
return {};
|
|
|
|
uLong destLen = compressBound(len);
|
|
std::pair<std::unique_ptr<uint8_t[]>, size_t> ret;
|
|
ret.first.reset(new uint8_t[destLen]);
|
|
compress2(ret.first.get(), &destLen, data, len, Z_BEST_COMPRESSION);
|
|
ret.second = destLen;
|
|
return ret;
|
|
};
|
|
|
|
void cookAudioGroup(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) override {
|
|
DNAMP1::AGSC::Cook(in, out);
|
|
progress(_SYS_STR("Done"));
|
|
}
|
|
|
|
void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) override {
|
|
DNAMP1::CSNG::Cook(in, out);
|
|
progress(_SYS_STR("Done"));
|
|
}
|
|
|
|
void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
hecl::blender::MapArea mapa = ds.compileMapArea();
|
|
ds.close();
|
|
DNAMP1::MAPA::Cook(mapa, out);
|
|
progress(_SYS_STR("Done"));
|
|
}
|
|
|
|
void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
|
|
hecl::blender::Token& btok, FCookProgress progress) override {
|
|
hecl::blender::MapUniverse mapu = ds.compileMapUniverse();
|
|
ds.close();
|
|
DNAMAPU::MAPU::Cook(mapu, out);
|
|
progress(_SYS_STR("Done"));
|
|
}
|
|
};
|
|
|
|
hecl::Database::DataSpecEntry SpecEntMP1 = {
|
|
_SYS_STR("MP1"sv), _SYS_STR("Data specification for original Metroid Prime engine"sv), _SYS_STR(".pak"sv),
|
|
[](hecl::Database::Project& project, hecl::Database::DataSpecTool) -> std::unique_ptr<hecl::Database::IDataSpec> {
|
|
return std::make_unique<SpecMP1>(&SpecEntMP1, project, false);
|
|
}};
|
|
|
|
hecl::Database::DataSpecEntry SpecEntMP1PC = {
|
|
_SYS_STR("MP1-PC"sv), _SYS_STR("Data specification for PC-optimized Metroid Prime engine"sv), _SYS_STR(".upak"sv),
|
|
[](hecl::Database::Project& project,
|
|
hecl::Database::DataSpecTool tool) -> std::unique_ptr<hecl::Database::IDataSpec> {
|
|
if (tool != hecl::Database::DataSpecTool::Extract)
|
|
return std::make_unique<SpecMP1>(&SpecEntMP1PC, project, true);
|
|
return {};
|
|
}};
|
|
|
|
hecl::Database::DataSpecEntry SpecEntMP1ORIG = {
|
|
_SYS_STR("MP1-ORIG"sv), _SYS_STR("Data specification for unmodified Metroid Prime resources"sv), {}, {}};
|
|
} // namespace DataSpec
|