mirror of https://github.com/AxioDL/metaforce.git
680 lines
25 KiB
C++
680 lines
25 KiB
C++
#include "DataSpec/DNACommon/PAK.hpp"
|
|
|
|
#include "DataSpec/DNAMP1/DNAMP1.hpp"
|
|
#include "DataSpec/DNAMP2/DNAMP2.hpp"
|
|
#include "DataSpec/DNAMP3/DNAMP3.hpp"
|
|
|
|
namespace DataSpec {
|
|
|
|
template <class PAKBRIDGE>
|
|
void UniqueResult::checkEntry(const PAKBRIDGE& pakBridge, const typename PAKBRIDGE::PAKType::Entry& entry) {
|
|
UniqueResult::Type resultType = UniqueResult::Type::NotFound;
|
|
bool foundOneLayer = false;
|
|
const std::string* levelName = nullptr;
|
|
typename PAKBRIDGE::PAKType::IDType useLevelId;
|
|
typename PAKBRIDGE::PAKType::IDType useAreaId;
|
|
unsigned layerIdx = 0;
|
|
for (const auto& [levelId, level] : pakBridge.m_levelDeps) {
|
|
if (entry.id == levelId || level.resources.find(entry.id) != level.resources.end()) {
|
|
levelName = &level.name;
|
|
resultType = UniqueResult::Type::Level;
|
|
break;
|
|
}
|
|
|
|
for (const auto& [areaId, area] : level.areas) {
|
|
unsigned l = 0;
|
|
for (const auto& layer : area.layers) {
|
|
if (layer.resources.find(entry.id) != layer.resources.end()) {
|
|
if (foundOneLayer) {
|
|
if (useAreaId == areaId) {
|
|
resultType = UniqueResult::Type::Area;
|
|
} else if (useLevelId == levelId) {
|
|
resultType = UniqueResult::Type::Level;
|
|
break;
|
|
} else {
|
|
m_type = UniqueResult::Type::Pak;
|
|
return;
|
|
}
|
|
continue;
|
|
} else
|
|
resultType = UniqueResult::Type::Layer;
|
|
levelName = &level.name;
|
|
useLevelId = levelId;
|
|
useAreaId = areaId;
|
|
layerIdx = l;
|
|
foundOneLayer = true;
|
|
}
|
|
++l;
|
|
}
|
|
if (area.resources.find(entry.id) != area.resources.end()) {
|
|
if (foundOneLayer) {
|
|
if (useAreaId == areaId) {
|
|
resultType = UniqueResult::Type::Area;
|
|
} else if (useLevelId == levelId) {
|
|
resultType = UniqueResult::Type::Level;
|
|
break;
|
|
} else {
|
|
m_type = UniqueResult::Type::Pak;
|
|
return;
|
|
}
|
|
continue;
|
|
} else
|
|
resultType = UniqueResult::Type::Area;
|
|
levelName = &level.name;
|
|
useLevelId = levelId;
|
|
useAreaId = areaId;
|
|
foundOneLayer = true;
|
|
}
|
|
}
|
|
}
|
|
m_type = resultType;
|
|
m_levelName = levelName;
|
|
if (resultType == UniqueResult::Type::Layer || resultType == UniqueResult::Type::Area) {
|
|
const typename PAKBRIDGE::Level::Area& area = pakBridge.m_levelDeps.at(useLevelId).areas.at(useAreaId);
|
|
m_areaName = &area.name;
|
|
if (resultType == UniqueResult::Type::Layer) {
|
|
const typename PAKBRIDGE::Level::Area::Layer& layer = area.layers[layerIdx];
|
|
m_layerName = &layer.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
template void UniqueResult::checkEntry(const DNAMP1::PAKBridge& pakBridge,
|
|
const DNAMP1::PAKBridge::PAKType::Entry& entry);
|
|
template void UniqueResult::checkEntry(const DNAMP2::PAKBridge& pakBridge,
|
|
const DNAMP2::PAKBridge::PAKType::Entry& entry);
|
|
template void UniqueResult::checkEntry(const DNAMP3::PAKBridge& pakBridge,
|
|
const DNAMP3::PAKBridge::PAKType::Entry& entry);
|
|
|
|
hecl::ProjectPath UniqueResult::uniquePath(const hecl::ProjectPath& pakPath) const {
|
|
if (m_type == Type::Pak)
|
|
return pakPath;
|
|
|
|
hecl::ProjectPath levelDir;
|
|
if (m_levelName)
|
|
levelDir.assign(pakPath, *m_levelName);
|
|
else
|
|
levelDir = pakPath;
|
|
|
|
if (m_type == Type::Area) {
|
|
hecl::ProjectPath areaDir(levelDir, *m_areaName);
|
|
return areaDir;
|
|
} else if (m_type == Type::Layer) {
|
|
hecl::ProjectPath areaDir(levelDir, *m_areaName);
|
|
hecl::ProjectPath layerDir(areaDir, *m_layerName);
|
|
return layerDir;
|
|
}
|
|
|
|
return levelDir;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
void PAKRouter<BRIDGETYPE>::build(std::vector<BRIDGETYPE>& bridges, std::function<void(float)> progress) {
|
|
m_bridges = &bridges;
|
|
m_bridgePaths.clear();
|
|
|
|
m_uniqueEntries.clear();
|
|
m_sharedEntries.clear();
|
|
m_charAssoc.m_cmdlRigs.clear();
|
|
size_t count = 0;
|
|
float bridgesSz = bridges.size();
|
|
|
|
/* Route entries unique/shared per-pak */
|
|
size_t bridgeIdx = 0;
|
|
for (BRIDGETYPE& bridge : bridges) {
|
|
const auto& name = bridge.getName();
|
|
|
|
std::string_view::const_iterator extit = name.end() - 4;
|
|
std::string baseName(name.begin(), extit);
|
|
|
|
m_bridgePaths.emplace_back(
|
|
std::make_pair(hecl::ProjectPath(m_gameWorking, baseName), hecl::ProjectPath(m_gameCooked, baseName)));
|
|
|
|
/* Index this PAK */
|
|
bridge.build();
|
|
|
|
/* Add to global entry lookup */
|
|
const typename BRIDGETYPE::PAKType& pak = bridge.getPAK();
|
|
for (const auto& entry : pak.m_entries) {
|
|
if (!pak.m_noShare) {
|
|
auto sSearch = m_sharedEntries.find(entry.first);
|
|
if (sSearch != m_sharedEntries.end())
|
|
continue;
|
|
auto uSearch = m_uniqueEntries.find(entry.first);
|
|
if (uSearch != m_uniqueEntries.end()) {
|
|
m_uniqueEntries.erase(uSearch);
|
|
m_sharedEntries[entry.first] = std::make_pair(bridgeIdx, &entry.second);
|
|
} else
|
|
m_uniqueEntries[entry.first] = std::make_pair(bridgeIdx, &entry.second);
|
|
} else
|
|
m_uniqueEntries[entry.first] = std::make_pair(bridgeIdx, &entry.second);
|
|
}
|
|
|
|
/* Add RigPairs to global map */
|
|
bridge.addCMDLRigPairs(*this, m_charAssoc);
|
|
|
|
progress(++count / bridgesSz);
|
|
++bridgeIdx;
|
|
}
|
|
|
|
/* Add named resources to catalog YAML files */
|
|
for (BRIDGETYPE& bridge : bridges) {
|
|
athena::io::YAMLDocWriter catalogWriter;
|
|
|
|
enterPAKBridge(bridge);
|
|
|
|
/* Add MAPA transforms to global map */
|
|
bridge.addMAPATransforms(*this, m_mapaTransforms, m_overrideEntries);
|
|
|
|
const typename BRIDGETYPE::PAKType& pak = bridge.getPAK();
|
|
for (const auto& namedEntry : pak.m_nameEntries) {
|
|
if (namedEntry.name == "holo_cinf")
|
|
continue; /* Problematic corner case */
|
|
if (auto rec = catalogWriter.enterSubRecord(namedEntry.name)) {
|
|
hecl::ProjectPath working = getWorking(namedEntry.id);
|
|
if (working.getAuxInfo().size()) {
|
|
if (auto v = catalogWriter.enterSubVector()) {
|
|
catalogWriter.writeString(working.getRelativePath());
|
|
catalogWriter.writeString(working.getAuxInfo());
|
|
}
|
|
} else
|
|
catalogWriter.writeString(working.getRelativePath());
|
|
}
|
|
}
|
|
|
|
/* Write catalog */
|
|
intptr_t curBridgeIdx = reinterpret_cast<intptr_t>(m_curBridgeIdx.get());
|
|
const hecl::ProjectPath& pakPath = m_bridgePaths[curBridgeIdx].first;
|
|
pakPath.makeDirChain(true);
|
|
athena::io::FileWriter writer(hecl::ProjectPath(pakPath, "!catalog.yaml").getAbsolutePath());
|
|
catalogWriter.finish(&writer);
|
|
}
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
void PAKRouter<BRIDGETYPE>::enterPAKBridge(const BRIDGETYPE& pakBridge) {
|
|
g_PakRouter.reset(this);
|
|
auto pit = m_bridgePaths.begin();
|
|
size_t bridgeIdx = 0;
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
if (&bridge == &pakBridge) {
|
|
m_pak.reset(&pakBridge.getPAK());
|
|
m_node.reset(&pakBridge.getNode());
|
|
m_curBridgeIdx.reset(reinterpret_cast<void*>(bridgeIdx));
|
|
return;
|
|
}
|
|
++pit;
|
|
++bridgeIdx;
|
|
}
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKBridge provided to PAKRouter::enterPAKBridge() was not part of build()"));
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getCharacterWorking(const EntryType* entry) const {
|
|
auto characterSearch = m_charAssoc.m_cskrToCharacter.find(entry->id);
|
|
if (characterSearch != m_charAssoc.m_cskrToCharacter.cend()) {
|
|
hecl::ProjectPath characterPath = getWorking(characterSearch->second.first);
|
|
if (entry->type == FOURCC('EVNT')) {
|
|
std::string extension(characterSearch->second.second);
|
|
return characterPath.getWithExtension((std::string(".") + extension.c_str()).c_str(), true);
|
|
}
|
|
return characterPath.ensureAuxInfo(characterSearch->second.second);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const EntryType* entry,
|
|
const ResExtractor<BRIDGETYPE>& extractor) const {
|
|
if (!entry)
|
|
return hecl::ProjectPath();
|
|
|
|
auto overrideSearch = m_overrideEntries.find(entry->id);
|
|
if (overrideSearch != m_overrideEntries.end())
|
|
return overrideSearch->second;
|
|
|
|
const PAKType* pak = m_pak.get();
|
|
intptr_t curBridgeIdx = reinterpret_cast<intptr_t>(m_curBridgeIdx.get());
|
|
if (pak && pak->m_noShare) {
|
|
const EntryType* singleSearch = pak->lookupEntry(entry->id);
|
|
if (singleSearch) {
|
|
const hecl::ProjectPath& pakPath = m_bridgePaths[curBridgeIdx].first;
|
|
std::string entName = getBestEntryName(*entry);
|
|
std::string auxInfo;
|
|
if (extractor.fileExts[0] && !extractor.fileExts[1])
|
|
entName += extractor.fileExts[0];
|
|
else if (extractor.fileExts[0])
|
|
entName += ".*";
|
|
else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
|
|
return chWork;
|
|
return hecl::ProjectPath(pakPath, entName).ensureAuxInfo(auxInfo);
|
|
}
|
|
}
|
|
|
|
auto uniqueSearch = m_uniqueEntries.find(entry->id);
|
|
if (uniqueSearch != m_uniqueEntries.end()) {
|
|
const BRIDGETYPE& bridge = m_bridges->at(uniqueSearch->second.first);
|
|
const hecl::ProjectPath& pakPath = m_bridgePaths[uniqueSearch->second.first].first;
|
|
std::string entName = getBestEntryName(*entry);
|
|
std::string auxInfo;
|
|
if (extractor.fileExts[0] && !extractor.fileExts[1])
|
|
entName += extractor.fileExts[0];
|
|
else if (extractor.fileExts[0])
|
|
entName += ".*";
|
|
else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
|
|
return chWork;
|
|
if (bridge.getPAK().m_noShare) {
|
|
return hecl::ProjectPath(pakPath, entName).ensureAuxInfo(auxInfo);
|
|
} else {
|
|
hecl::ProjectPath uniquePath = entry->unique.uniquePath(pakPath);
|
|
return hecl::ProjectPath(uniquePath, entName).ensureAuxInfo(auxInfo);
|
|
}
|
|
}
|
|
|
|
auto sharedSearch = m_sharedEntries.find(entry->id);
|
|
if (sharedSearch != m_sharedEntries.end()) {
|
|
std::string entBase = getBestEntryName(*entry);
|
|
std::string auxInfo;
|
|
std::string entName = entBase;
|
|
if (extractor.fileExts[0] && !extractor.fileExts[1])
|
|
entName += extractor.fileExts[0];
|
|
else if (extractor.fileExts[0])
|
|
entName += ".*";
|
|
else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
|
|
return chWork;
|
|
hecl::ProjectPath sharedPath(m_sharedWorking, entName);
|
|
return sharedPath.ensureAuxInfo(auxInfo);
|
|
}
|
|
|
|
LogDNACommon.report(logvisor::Fatal, FMT_STRING("Unable to find entry {}"), entry->id);
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const EntryType* entry) const {
|
|
if (!entry)
|
|
return hecl::ProjectPath();
|
|
return getWorking(entry, BRIDGETYPE::LookupExtractor(*m_node.get(), *m_pak.get(), *entry));
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const IDType& id, bool silenceWarnings) const {
|
|
return getWorking(lookupEntry(id, nullptr, silenceWarnings, false));
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getCooked(const EntryType* entry) const {
|
|
if (!entry)
|
|
return hecl::ProjectPath();
|
|
|
|
auto overrideSearch = m_overrideEntries.find(entry->id);
|
|
if (overrideSearch != m_overrideEntries.end()) {
|
|
return overrideSearch->second.getCookedPath(
|
|
*m_dataSpec.overrideDataSpec(overrideSearch->second, m_dataSpec.getDataSpecEntry()));
|
|
}
|
|
|
|
const PAKType* pak = m_pak.get();
|
|
intptr_t curBridgeIdx = reinterpret_cast<intptr_t>(m_curBridgeIdx.get());
|
|
if (pak && pak->m_noShare) {
|
|
const EntryType* singleSearch = pak->lookupEntry(entry->id);
|
|
if (singleSearch) {
|
|
const hecl::ProjectPath& pakPath = m_bridgePaths[curBridgeIdx].second;
|
|
return hecl::ProjectPath(pakPath, getBestEntryName(*entry));
|
|
}
|
|
}
|
|
auto uniqueSearch = m_uniqueEntries.find(entry->id);
|
|
if (uniqueSearch != m_uniqueEntries.end()) {
|
|
const BRIDGETYPE& bridge = m_bridges->at(uniqueSearch->second.first);
|
|
const hecl::ProjectPath& pakPath = m_bridgePaths[uniqueSearch->second.first].second;
|
|
if (bridge.getPAK().m_noShare) {
|
|
return hecl::ProjectPath(pakPath, getBestEntryName(*entry));
|
|
} else {
|
|
hecl::ProjectPath uniquePath = entry->unique.uniquePath(pakPath);
|
|
return hecl::ProjectPath(uniquePath, getBestEntryName(*entry));
|
|
}
|
|
}
|
|
auto sharedSearch = m_sharedEntries.find(entry->id);
|
|
if (sharedSearch != m_sharedEntries.end()) {
|
|
return hecl::ProjectPath(m_sharedCooked, getBestEntryName(*entry));
|
|
}
|
|
LogDNACommon.report(logvisor::Fatal, FMT_STRING("Unable to find entry {}"), entry->id);
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getCooked(const IDType& id, bool silenceWarnings) const {
|
|
return getCooked(lookupEntry(id, nullptr, silenceWarnings, false));
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
std::string PAKRouter<BRIDGETYPE>::getResourceRelativePath(const EntryType& a, const IDType& b) const {
|
|
const nod::Node* node = m_node.get();
|
|
const PAKType* pak = m_pak.get();
|
|
if (!pak)
|
|
LogDNACommon.report(
|
|
logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::enterPAKBridge() must be called before PAKRouter::getResourceRelativePath()"));
|
|
const typename BRIDGETYPE::PAKType::Entry* be = lookupEntry(b);
|
|
if (!be)
|
|
return std::string();
|
|
hecl::ProjectPath aPath = getWorking(&a, BRIDGETYPE::LookupExtractor(*node, *pak, a));
|
|
std::string ret;
|
|
for (size_t i = 0; i < aPath.levelCount(); ++i)
|
|
ret += "../";
|
|
hecl::ProjectPath bPath = getWorking(be, BRIDGETYPE::LookupExtractor(*node, *pak, *be));
|
|
ret += bPath.getRelativePath();
|
|
return ret;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
std::string PAKRouter<BRIDGETYPE>::getBestEntryName(const EntryType& entry, bool stdOverride) const {
|
|
std::string name;
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
const typename BRIDGETYPE::PAKType& pak = bridge.getPAK();
|
|
const typename BRIDGETYPE::PAKType::Entry* e = pak.lookupEntry(entry.id);
|
|
if (!e)
|
|
continue;
|
|
|
|
if (stdOverride && !pak.m_noShare) {
|
|
if (entry.type == FOURCC('MLVL'))
|
|
return fmt::format(FMT_STRING("!world_{}"), entry.id);
|
|
else if (entry.type == FOURCC('MREA'))
|
|
return fmt::format(FMT_STRING("!area_{}"), entry.id);
|
|
else if (entry.type == FOURCC('MAPA'))
|
|
return fmt::format(FMT_STRING("!map_{}"), entry.id);
|
|
else if (entry.type == FOURCC('PATH'))
|
|
return fmt::format(FMT_STRING("!path_{}"), entry.id);
|
|
else if (entry.type == FOURCC('MAPW'))
|
|
return fmt::format(FMT_STRING("!mapw_{}"), entry.id);
|
|
else if (entry.type == FOURCC('SAVW'))
|
|
return fmt::format(FMT_STRING("!savw_{}"), entry.id);
|
|
}
|
|
|
|
std::string catalogueName;
|
|
name = pak.bestEntryName(bridge.getNode(), entry, catalogueName);
|
|
if (!catalogueName.empty())
|
|
return name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
std::string PAKRouter<BRIDGETYPE>::getBestEntryName(const IDType& entry, bool stdOverride) const {
|
|
std::string name;
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
const typename BRIDGETYPE::PAKType& pak = bridge.getPAK();
|
|
const typename BRIDGETYPE::PAKType::Entry* e = pak.lookupEntry(entry);
|
|
if (!e)
|
|
continue;
|
|
|
|
if (stdOverride && !pak.m_noShare) {
|
|
if (e->type == FOURCC('MLVL'))
|
|
return fmt::format(FMT_STRING("!world_{}"), e->id);
|
|
else if (e->type == FOURCC('MREA'))
|
|
return fmt::format(FMT_STRING("!area_{}"), e->id);
|
|
else if (e->type == FOURCC('MAPA'))
|
|
return fmt::format(FMT_STRING("!map_{}"), e->id);
|
|
else if (e->type == FOURCC('PATH'))
|
|
return fmt::format(FMT_STRING("!path_{}"), e->id);
|
|
else if (e->type == FOURCC('MAPW'))
|
|
return fmt::format(FMT_STRING("!mapw_{}"), e->id);
|
|
else if (e->type == FOURCC('SAVW'))
|
|
return fmt::format(FMT_STRING("!savw_{}"), e->id);
|
|
}
|
|
|
|
std::string catalogueName;
|
|
name = pak.bestEntryName(bridge.getNode(), *e, catalogueName);
|
|
if (!catalogueName.empty())
|
|
return name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
bool PAKRouter<BRIDGETYPE>::extractResources(const BRIDGETYPE& pakBridge, bool force, hecl::blender::Token& btok,
|
|
std::function<void(const char*, float)> progress) {
|
|
enterPAKBridge(pakBridge);
|
|
size_t count = 0;
|
|
size_t sz = m_pak->m_entries.size();
|
|
float fsz = sz;
|
|
for (unsigned w = 0; count < sz; ++w) {
|
|
for (const auto& item : m_pak->m_firstEntries) {
|
|
const auto* entryPtr = m_pak->lookupEntry(item);
|
|
ResExtractor<BRIDGETYPE> extractor = BRIDGETYPE::LookupExtractor(*m_node.get(), *m_pak.get(), *entryPtr);
|
|
if (extractor.weight != w)
|
|
continue;
|
|
|
|
std::string bestName = getBestEntryName(*entryPtr, false);
|
|
float thisFac = ++count / fsz;
|
|
progress(bestName.c_str(), thisFac);
|
|
|
|
const nod::Node* node = m_node.get();
|
|
|
|
hecl::ProjectPath working = getWorking(entryPtr, extractor);
|
|
working.makeDirChain(false);
|
|
hecl::ResourceLock resLk(working);
|
|
if (!resLk)
|
|
continue;
|
|
|
|
/* Extract to unmodified directory */
|
|
hecl::ProjectPath cooked = working.getCookedPath(m_dataSpec.getUnmodifiedSpec());
|
|
if (force || cooked.isNone()) {
|
|
cooked.makeDirChain(false);
|
|
PAKEntryReadStream s = entryPtr->beginReadStream(*node);
|
|
const auto fout = hecl::FopenUnique(cooked.getAbsolutePath().data(), "wb");
|
|
std::fwrite(s.data(), 1, s.length(), fout.get());
|
|
}
|
|
|
|
if (extractor.func_a) /* Doesn't need PAKRouter access */
|
|
{
|
|
if (force || !extractor.IsFullyExtracted(working)) {
|
|
PAKEntryReadStream s = entryPtr->beginReadStream(*node);
|
|
extractor.func_a(s, working);
|
|
}
|
|
} else if (extractor.func_b) /* Needs PAKRouter access */
|
|
{
|
|
if (force || !extractor.IsFullyExtracted(working)) {
|
|
PAKEntryReadStream s = entryPtr->beginReadStream(*node);
|
|
extractor.func_b(m_dataSpec, s, working, *this, *entryPtr, force, btok,
|
|
[&progress, thisFac](const char* update) { progress(update, thisFac); });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
const typename BRIDGETYPE::PAKType::Entry*
|
|
PAKRouter<BRIDGETYPE>::lookupEntry(const IDType& entry, const nod::Node** nodeOut, bool silenceWarnings,
|
|
bool currentPAK) const {
|
|
if (!entry.isValid())
|
|
return nullptr;
|
|
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::lookupEntry()"));
|
|
|
|
const PAKType* pak = m_pak.get();
|
|
const nod::Node* node = m_node.get();
|
|
if (pak) {
|
|
const EntryType* ent = pak->lookupEntry(entry);
|
|
if (ent) {
|
|
if (nodeOut)
|
|
*nodeOut = node;
|
|
return ent;
|
|
}
|
|
}
|
|
|
|
if (currentPAK) {
|
|
#ifndef NDEBUG
|
|
if (!silenceWarnings)
|
|
LogDNACommon.report(logvisor::Warning, FMT_STRING("unable to find PAK entry {} in current PAK"), entry);
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
const PAKType& pak = bridge.getPAK();
|
|
const EntryType* ent = pak.lookupEntry(entry);
|
|
if (ent) {
|
|
if (nodeOut)
|
|
*nodeOut = &bridge.getNode();
|
|
return ent;
|
|
}
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
if (!silenceWarnings)
|
|
LogDNACommon.report(logvisor::Warning, FMT_STRING("unable to find PAK entry {}"), entry);
|
|
#endif
|
|
if (nodeOut)
|
|
*nodeOut = nullptr;
|
|
return nullptr;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
const typename CharacterAssociations<typename PAKRouter<BRIDGETYPE>::IDType>::RigPair*
|
|
PAKRouter<BRIDGETYPE>::lookupCMDLRigPair(const IDType& id) const {
|
|
auto search = m_charAssoc.m_cmdlRigs.find(id);
|
|
if (search == m_charAssoc.m_cmdlRigs.end())
|
|
return nullptr;
|
|
return &search->second;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
const typename CharacterAssociations<typename PAKRouter<BRIDGETYPE>::IDType>::MultimapIteratorPair
|
|
PAKRouter<BRIDGETYPE>::lookupCharacterAttachmentRigs(const IDType& id) const {
|
|
return m_charAssoc.m_characterToAttachmentRigs.equal_range(id);
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
const zeus::CMatrix4f* PAKRouter<BRIDGETYPE>::lookupMAPATransform(const IDType& id) const {
|
|
auto search = m_mapaTransforms.find(id);
|
|
if (search == m_mapaTransforms.end())
|
|
return nullptr;
|
|
return &search->second;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getAreaLayerWorking(const IDType& areaId, int layerIdx) const {
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::getAreaLayerWorking()"));
|
|
auto bridgePathIt = m_bridgePaths.cbegin();
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
for (const auto& level : bridge.m_levelDeps)
|
|
for (const auto& area : level.second.areas)
|
|
if (area.first == areaId) {
|
|
hecl::ProjectPath levelPath(bridgePathIt->first, level.second.name);
|
|
hecl::ProjectPath areaPath(levelPath, area.second.name);
|
|
if (layerIdx < 0)
|
|
return areaPath;
|
|
return hecl::ProjectPath(areaPath, area.second.layers.at(layerIdx).name);
|
|
}
|
|
++bridgePathIt;
|
|
}
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getAreaLayerWorking(const IDType& areaId, int layerIdx,
|
|
bool& activeOut) const {
|
|
activeOut = false;
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::getAreaLayerWorking()"));
|
|
auto bridgePathIt = m_bridgePaths.cbegin();
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
for (const auto& level : bridge.m_levelDeps)
|
|
for (const auto& area : level.second.areas)
|
|
if (area.first == areaId) {
|
|
hecl::ProjectPath levelPath(bridgePathIt->first, level.second.name);
|
|
hecl::ProjectPath areaPath(levelPath, area.second.name);
|
|
if (layerIdx < 0)
|
|
return areaPath;
|
|
const typename Level<IDType>::Area::Layer& layer = area.second.layers.at(layerIdx);
|
|
activeOut = layer.active;
|
|
return hecl::ProjectPath(areaPath, layer.name);
|
|
}
|
|
++bridgePathIt;
|
|
}
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getAreaLayerCooked(const IDType& areaId, int layerIdx) const {
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::getAreaLayerCooked()"));
|
|
auto bridgePathIt = m_bridgePaths.cbegin();
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
for (const auto& level : bridge.m_levelDeps)
|
|
for (const auto& area : level.second.areas)
|
|
if (area.first == areaId) {
|
|
hecl::ProjectPath levelPath(bridgePathIt->second, level.second.name);
|
|
hecl::ProjectPath areaPath(levelPath, area.second.name);
|
|
if (layerIdx < 0)
|
|
return areaPath;
|
|
return hecl::ProjectPath(areaPath, area.second.layers.at(layerIdx).name);
|
|
}
|
|
++bridgePathIt;
|
|
}
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
hecl::ProjectPath PAKRouter<BRIDGETYPE>::getAreaLayerCooked(const IDType& areaId, int layerIdx, bool& activeOut) const {
|
|
activeOut = false;
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::getAreaLayerCooked()"));
|
|
auto bridgePathIt = m_bridgePaths.cbegin();
|
|
for (const BRIDGETYPE& bridge : *m_bridges) {
|
|
for (const auto& level : bridge.m_levelDeps)
|
|
for (const auto& area : level.second.areas)
|
|
if (area.first == areaId) {
|
|
hecl::ProjectPath levelPath(bridgePathIt->second, level.second.name);
|
|
hecl::ProjectPath areaPath(levelPath, area.second.name);
|
|
if (layerIdx < 0)
|
|
return areaPath;
|
|
const typename Level<IDType>::Area::Layer& layer = area.second.layers.at(layerIdx);
|
|
activeOut = layer.active;
|
|
return hecl::ProjectPath(areaPath, layer.name);
|
|
}
|
|
++bridgePathIt;
|
|
}
|
|
return hecl::ProjectPath();
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
void PAKRouter<BRIDGETYPE>::enumerateResources(const std::function<bool(const EntryType*)>& func) {
|
|
if (!m_bridges)
|
|
LogDNACommon.report(logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::build() must be called before PAKRouter::enumerateResources()"));
|
|
for (const auto& entryPair : m_uniqueEntries)
|
|
if (!func(entryPair.second.second))
|
|
return;
|
|
for (const auto& entryPair : m_sharedEntries)
|
|
if (!func(entryPair.second.second))
|
|
return;
|
|
}
|
|
|
|
template <class BRIDGETYPE>
|
|
bool PAKRouter<BRIDGETYPE>::mreaHasDupeResources(const IDType& id) const {
|
|
const PAKType* pak = m_pak.get();
|
|
if (!pak)
|
|
LogDNACommon.report(
|
|
logvisor::Fatal,
|
|
FMT_STRING("PAKRouter::enterPAKBridge() must be called before PAKRouter::mreaHasDupeResources()"));
|
|
return pak->mreaHasDupeResources(id);
|
|
}
|
|
|
|
template class PAKRouter<DNAMP1::PAKBridge>;
|
|
template class PAKRouter<DNAMP2::PAKBridge>;
|
|
template class PAKRouter<DNAMP3::PAKBridge>;
|
|
|
|
} // namespace DataSpec
|