metaforce/DataSpec/DNAMP1/DNAMP1.cpp

400 lines
16 KiB
C++
Raw Normal View History

#include <stdio.h>
2015-07-17 00:01:05 +00:00
#define NOD_ATHENA 1
2015-07-16 01:57:34 +00:00
#include "DNAMP1.hpp"
2015-07-17 00:01:05 +00:00
#include "STRG.hpp"
#include "SCAN.hpp"
2015-07-17 00:01:05 +00:00
#include "MLVL.hpp"
2015-07-19 06:19:46 +00:00
#include "../DNACommon/TXTR.hpp"
#include "../DNACommon/PART.hpp"
2016-03-09 04:49:44 +00:00
#include "../DNACommon/ELSC.hpp"
2016-03-28 08:54:02 +00:00
#include "../DNACommon/SWHC.hpp"
#include "../DNACommon/CRSC.hpp"
2016-03-29 00:07:38 +00:00
#include "../DNACommon/WPSC.hpp"
#include "../DNACommon/DPSC.hpp"
2016-03-09 08:54:28 +00:00
#include "../DNACommon/FONT.hpp"
2016-04-12 10:52:40 +00:00
#include "../DNACommon/DGRP.hpp"
2016-09-18 23:47:48 +00:00
#include "../DNACommon/ATBL.hpp"
2016-09-08 02:01:29 +00:00
#include "HINT.hpp"
2015-07-28 02:24:36 +00:00
#include "CMDL.hpp"
2016-02-04 02:04:05 +00:00
#include "AFSM.hpp"
2016-07-24 01:51:15 +00:00
#include "SAVW.hpp"
2015-08-08 23:24:17 +00:00
#include "ANCS.hpp"
2015-09-07 04:05:44 +00:00
#include "MREA.hpp"
2015-10-26 02:31:09 +00:00
#include "MAPA.hpp"
2016-01-19 05:32:34 +00:00
#include "FRME.hpp"
2016-09-18 23:47:48 +00:00
#include "AGSC.hpp"
#include "CSNG.hpp"
2015-07-16 01:57:34 +00:00
#include "../DNACommon/Tweaks/TweakWriter.hpp"
#include "Tweaks/CTweakPlayerRes.hpp"
2016-08-31 21:00:06 +00:00
#include "Tweaks/CTweakGunRes.hpp"
#include "Tweaks/CTweakPlayer.hpp"
#include "Tweaks/CTweakCameraBob.hpp"
#include "Tweaks/CTweakSlideShow.hpp"
#include "Tweaks/CTweakGame.hpp"
2017-01-21 22:26:07 +00:00
#include "Tweaks/CTweakTargeting.hpp"
2016-02-13 09:02:47 +00:00
namespace DataSpec
2015-07-16 01:57:34 +00:00
{
namespace DNAMP1
{
2016-03-04 23:04:53 +00:00
logvisor::Module Log("urde::DNAMP1");
2015-07-17 00:01:05 +00:00
static bool GetNoShare(const std::string& name)
{
std::string lowerName = name;
std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), tolower);
2015-09-22 01:58:26 +00:00
if (!lowerName.compare(0, 7, "metroid"))
return false;
return true;
}
2016-03-04 23:04:53 +00:00
PAKBridge::PAKBridge(hecl::Database::Project& project,
const nod::Node& node,
bool doExtract)
: m_project(project), m_node(node), m_pak(false, GetNoShare(node.getName())), m_doExtract(doExtract)
2015-07-17 00:01:05 +00:00
{
2016-03-04 23:04:53 +00:00
nod::AthenaPartReadStream rs(node.beginReadStream());
2015-07-17 00:01:05 +00:00
m_pak.read(rs);
/* Append Level String */
for (PAK::Entry& entry : m_pak.m_entries)
2015-07-17 00:01:05 +00:00
{
2015-08-23 06:42:29 +00:00
if (entry.type == FOURCC('MLVL'))
2015-07-17 00:01:05 +00:00
{
PAKEntryReadStream rs = entry.beginReadStream(m_node);
MLVL mlvl;
mlvl.read(rs);
PAK::Entry* nameEnt = (PAK::Entry*)m_pak.lookupEntry(mlvl.worldNameId);
2015-07-17 00:01:05 +00:00
if (nameEnt)
{
nameEnt->name = entry.name + "_name";
2015-07-17 00:01:05 +00:00
PAKEntryReadStream rs = nameEnt->beginReadStream(m_node);
STRG mlvlName;
mlvlName.read(rs);
if (m_levelString.size())
m_levelString += _S(", ");
2015-08-10 20:49:19 +00:00
m_levelString += mlvlName.getSystemString(FOURCC('ENGL'), 0);
}
}
}
}
2016-03-04 23:04:53 +00:00
static hecl::SystemString LayerName(const std::string& name)
{
2016-09-11 01:25:59 +00:00
hecl::SystemString ret = hecl::SystemStringView(name).sys_str();
for (auto& ch : ret)
if (ch == _S('/') || ch == _S('\\'))
ch = _S('-');
return ret;
}
void PAKBridge::build()
{
/* First pass: build per-area/per-layer dependency map */
for (const PAK::Entry& entry : m_pak.m_entries)
{
2015-08-23 06:42:29 +00:00
if (entry.type == FOURCC('MLVL'))
{
Level& level = m_levelDeps[entry.id];
MLVL mlvl;
2015-10-26 02:31:09 +00:00
{
PAKEntryReadStream rs = entry.beginReadStream(m_node);
mlvl.read(rs);
}
bool named;
2016-09-11 01:25:59 +00:00
std::string bestName = m_pak.bestEntryName(entry, named);
level.name = hecl::SystemStringView(bestName).sys_str();
level.areas.reserve(mlvl.areaCount);
unsigned layerIdx = 0;
2015-09-17 19:50:43 +00:00
2015-10-26 02:31:09 +00:00
/* Make MAPW available to lookup MAPAs */
PAK::Entry* worldMapEnt = (PAK::Entry*)m_pak.lookupEntry(mlvl.worldMap);
2015-10-26 02:31:09 +00:00
std::vector<UniqueID32> mapw;
if (worldMapEnt)
{
worldMapEnt->name = entry.name + "_mapw";
2015-10-26 02:31:09 +00:00
PAKEntryReadStream rs = worldMapEnt->beginReadStream(m_node);
2016-03-04 23:04:53 +00:00
rs.seek(8, athena::Current);
2015-10-26 02:31:09 +00:00
atUint32 areaCount = rs.readUint32Big();
mapw.reserve(areaCount);
for (atUint32 i=0 ; i<areaCount ; ++i)
mapw.emplace_back(rs);
}
PAK::Entry* savwEnt = (PAK::Entry*)m_pak.lookupEntry(mlvl.saveWorldId);
if (savwEnt)
savwEnt->name = entry.name + "_savw";
PAK::Entry* skyEnt = (PAK::Entry*)m_pak.lookupEntry(mlvl.worldSkyboxId);
if (skyEnt)
skyEnt->name = entry.name + "_skybox";
2015-09-29 06:09:22 +00:00
/* Index areas */
unsigned ai = 0;
for (const MLVL::Area& area : mlvl.areas)
{
Level::Area& areaDeps = level.areas[area.areaMREAId];
2015-10-12 21:10:38 +00:00
MLVL::LayerFlags& layerFlags = mlvl.layerFlags[ai];
PAK::Entry* areaNameEnt = (PAK::Entry*)m_pak.lookupEntry(area.areaNameId);
if (areaNameEnt)
{
STRG areaName;
2015-10-26 02:31:09 +00:00
{
PAKEntryReadStream rs = areaNameEnt->beginReadStream(m_node);
areaName.read(rs);
}
2015-08-10 20:49:19 +00:00
areaDeps.name = areaName.getSystemString(FOURCC('ENGL'), 0);
2016-10-01 23:20:20 +00:00
areaDeps.name = hecl::StringUtils::TrimWhitespace(areaDeps.name);
}
2015-08-04 02:46:48 +00:00
if (areaDeps.name.empty())
{
2016-09-11 01:25:59 +00:00
std::string idStr = area.areaMREAId.toString();
areaDeps.name = _S("MREA_") + hecl::SystemStringView(idStr).sys_str();
2015-08-04 02:46:48 +00:00
}
2016-03-04 23:04:53 +00:00
hecl::SystemChar num[16];
hecl::SNPrintf(num, 16, _S("%02u "), ai);
2015-09-29 06:09:22 +00:00
areaDeps.name = num + areaDeps.name;
2016-09-11 01:25:59 +00:00
std::string lowerName = hecl::SystemUTF8View(areaDeps.name).str();
for (char& ch : lowerName)
{
ch = tolower(ch);
if (ch == ' ')
ch = '_';
}
if (areaNameEnt)
areaNameEnt->name = lowerName + "_name";
PAK::Entry* areaEnt = (PAK::Entry*)m_pak.lookupEntry(area.areaMREAId);
if (areaEnt)
areaEnt->name = lowerName;
areaDeps.layers.reserve(area.depLayerCount-1);
unsigned r=0;
for (unsigned l=1 ; l<area.depLayerCount ; ++l)
{
areaDeps.layers.emplace_back();
Level::Area::Layer& layer = areaDeps.layers.back();
layer.name = LayerName(mlvl.layerNames[layerIdx++]);
2015-10-12 21:10:38 +00:00
layer.active = layerFlags.flags >> (l-1) & 0x1;
2016-10-02 22:41:36 +00:00
layer.name = hecl::StringUtils::TrimWhitespace(layer.name);
2016-08-10 02:52:00 +00:00
hecl::SNPrintf(num, 16, _S("%02u "), l-1);
2015-10-12 21:10:38 +00:00
layer.name = num + layer.name;
2015-09-01 02:54:02 +00:00
layer.resources.reserve(area.depLayers[l] - r);
for (; r<area.depLayers[l] ; ++r)
layer.resources.emplace(area.deps[r].id);
}
2015-10-26 02:31:09 +00:00
areaDeps.resources.reserve(area.depCount - r + 2);
for (; r<area.depCount ; ++r)
areaDeps.resources.emplace(area.deps[r].id);
2015-08-04 02:46:48 +00:00
areaDeps.resources.emplace(area.areaMREAId);
2015-10-26 02:31:09 +00:00
if (mapw.size() > ai)
areaDeps.resources.emplace(mapw[ai]);
++ai;
}
}
}
/* Second pass: cross-compare uniqueness */
for (PAK::Entry& entry : m_pak.m_entries)
{
2015-09-24 03:57:45 +00:00
entry.unique.checkEntry(*this, entry);
}
}
void PAKBridge::addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,
2016-09-19 05:29:05 +00:00
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo,
2016-09-19 06:08:18 +00:00
std::unordered_map<UniqueID32, std::pair<UniqueID32, std::string>>& cskrCinfToAncs) const
{
for (const std::pair<UniqueID32, PAK::Entry*>& entry : m_pak.m_idMap)
{
if (entry.second->type == FOURCC('ANCS'))
{
PAKEntryReadStream rs = entry.second->beginReadStream(m_node);
2016-04-07 03:40:25 +00:00
ANCS ancs;
ancs.read(rs);
for (const ANCS::CharacterSet::CharacterInfo& ci : ancs.characterSet.characters)
2015-09-26 03:12:08 +00:00
{
2016-04-07 03:40:25 +00:00
addTo[ci.cmdl] = std::make_pair(ci.cskr, ci.cinf);
2016-09-19 06:08:18 +00:00
cskrCinfToAncs[ci.cskr] = std::make_pair(entry.second->id, hecl::Format("%s.CSKR", ci.name.c_str()));
cskrCinfToAncs[ci.cinf] = std::make_pair(entry.second->id, hecl::Format("CINF_%08X.CINF", ci.cinf.toUint32()));
PAK::Entry* cmdlEnt = (PAK::Entry*)m_pak.lookupEntry(ci.cmdl);
2016-04-07 03:40:25 +00:00
PAK::Entry* cskrEnt = (PAK::Entry*)m_pak.lookupEntry(ci.cskr);
PAK::Entry* cinfEnt = (PAK::Entry*)m_pak.lookupEntry(ci.cinf);
2016-03-04 23:04:53 +00:00
cmdlEnt->name = hecl::Format("ANCS_%08X_%s_model", entry.first.toUint32(), ci.name.c_str());
cskrEnt->name = hecl::Format("ANCS_%08X_%s_skin", entry.first.toUint32(), ci.name.c_str());
cinfEnt->name = hecl::Format("ANCS_%08X_%s_skel", entry.first.toUint32(), ci.name.c_str());
if (ci.cmdlOverlay && ci.cskrOverlay)
{
2016-04-07 03:40:25 +00:00
addTo[ci.cmdlOverlay] = std::make_pair(ci.cskrOverlay, ci.cinf);
2016-09-19 06:08:18 +00:00
cskrCinfToAncs[ci.cskrOverlay] = std::make_pair(entry.second->id, hecl::Format("%s.over.CSKR", ci.name.c_str()));
PAK::Entry* cmdlEnt = (PAK::Entry*)m_pak.lookupEntry(ci.cmdlOverlay);
2016-04-07 03:40:25 +00:00
PAK::Entry* cskrEnt = (PAK::Entry*)m_pak.lookupEntry(ci.cskrOverlay);
2016-03-04 23:04:53 +00:00
cmdlEnt->name = hecl::Format("ANCS_%08X_%s_overmodel", entry.first.toUint32(), ci.name.c_str());
cskrEnt->name = hecl::Format("ANCS_%08X_%s_overskin", entry.first.toUint32(), ci.name.c_str());
}
}
std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>> animInfo;
ancs.getAnimationResInfo(animInfo);
for (auto& ae : animInfo)
{
PAK::Entry* animEnt = (PAK::Entry*)m_pak.lookupEntry(ae.second.animId);
2016-03-04 23:04:53 +00:00
animEnt->name = hecl::Format("ANCS_%08X_%s", entry.first.toUint32(), ae.second.name.c_str());
2016-09-19 06:08:18 +00:00
cskrCinfToAncs[ae.second.animId] = std::make_pair(entry.second->id, hecl::Format("%s.ANIM", ae.second.name.c_str()));
2015-10-27 00:32:12 +00:00
if (ae.second.evntId)
{
PAK::Entry* evntEnt = (PAK::Entry*)m_pak.lookupEntry(ae.second.evntId);
2016-03-04 23:04:53 +00:00
evntEnt->name = hecl::Format("ANCS_%08X_%s_evnt", entry.first.toUint32(), ae.second.name.c_str());
2016-09-19 06:08:18 +00:00
cskrCinfToAncs[ae.second.evntId] = std::make_pair(entry.second->id, hecl::Format("%s.evnt.yaml", ae.second.name.c_str()));
2015-10-27 00:32:12 +00:00
}
2015-09-26 03:12:08 +00:00
}
}
else if (entry.second->type == FOURCC('MREA'))
{
PAKEntryReadStream rs = entry.second->beginReadStream(m_node);
MREA::AddCMDLRigPairs(rs, pakRouter, addTo);
}
}
}
2016-10-01 23:20:20 +00:00
static const atVec4f BottomRow = {0.f, 0.f, 0.f, 1.f};
void PAKBridge::addMAPATransforms(PAKRouter<PAKBridge>& pakRouter,
std::unordered_map<UniqueID32, zeus::CMatrix4f>& addTo,
std::unordered_map<UniqueID32, hecl::ProjectPath>& pathOverrides) const
{
for (const std::pair<UniqueID32, PAK::Entry*>& entry : m_pak.m_idMap)
{
if (entry.second->type == FOURCC('MLVL'))
{
MLVL mlvl;
{
PAKEntryReadStream rs = entry.second->beginReadStream(m_node);
mlvl.read(rs);
}
hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(entry.second).getParentPath();
if (mlvl.worldNameId)
pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _S("!name.yaml"));
for (const MLVL::Area& area : mlvl.areas)
{
hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath();
if (area.areaNameId)
pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _S("!name.yaml"));
}
if (mlvl.worldMap)
{
const nod::Node* mapNode;
const PAK::Entry* mapEntry = pakRouter.lookupEntry(mlvl.worldMap, &mapNode);
if (mapEntry)
{
PAKEntryReadStream rs = mapEntry->beginReadStream(*mapNode);
u32 magic = rs.readUint32Big();
if (magic == 0xDEADF00D)
{
rs.readUint32Big();
u32 count = rs.readUint32Big();
for (u32 i=0 ; i<count && i<mlvl.areas.size() ; ++i)
{
MLVL::Area& areaData = mlvl.areas[i];
UniqueID32 mapaId;
mapaId.read(rs);
addTo[mapaId] = zeus::CMatrix4f(
areaData.transformMtx[0],
areaData.transformMtx[1],
areaData.transformMtx[2],
BottomRow).transposed();
}
}
}
}
}
}
}
ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const PAK& pak, const PAK::Entry& entry)
2015-07-17 00:01:05 +00:00
{
2015-08-13 07:29:00 +00:00
switch (entry.type)
2015-07-19 06:19:46 +00:00
{
case SBIG('STRG'):
2016-09-18 23:47:48 +00:00
return {STRG::Extract, {_S(".yaml")}};
case SBIG('SCAN'):
2016-09-18 23:47:48 +00:00
return {SCAN::Extract, {_S(".yaml")}, 0, SCAN::Name};
2016-09-08 02:01:29 +00:00
case SBIG('HINT'):
2016-09-18 23:47:48 +00:00
return {HINT::Extract, {_S(".yaml")}};
2016-07-24 01:51:15 +00:00
case SBIG('SAVW'):
2016-09-18 23:47:48 +00:00
return {SAVWCommon::ExtractSAVW<SAVW>, {_S(".yaml")}};
2015-07-19 06:19:46 +00:00
case SBIG('TXTR'):
2016-09-18 23:47:48 +00:00
return {TXTR::Extract, {_S(".png")}};
2016-02-04 02:04:05 +00:00
case SBIG('AFSM'):
2016-09-18 23:47:48 +00:00
return {AFSM::Extract, {_S(".yaml")}};
2016-01-19 05:32:34 +00:00
case SBIG('FRME'):
2016-09-18 23:47:48 +00:00
return {FRME::Extract, {_S(".blend")}, 2};
2015-07-28 02:24:36 +00:00
case SBIG('CMDL'):
2016-09-18 23:47:48 +00:00
return {CMDL::Extract, {_S(".blend")}, 1, CMDL::Name};
2015-08-08 23:24:17 +00:00
case SBIG('ANCS'):
2016-09-18 23:47:48 +00:00
return {ANCS::Extract, {_S(".yaml"), _S(".blend")}, 2};
2015-08-02 04:25:38 +00:00
case SBIG('MLVL'):
return {MLVL::Extract, {_S(".yaml"), _S(".blend")}, 3};
case SBIG('MREA'):
2016-09-18 23:47:48 +00:00
return {MREA::Extract, {_S(".blend")}, 4, MREA::Name};
2015-10-26 02:31:09 +00:00
case SBIG('MAPA'):
2016-09-18 23:47:48 +00:00
return {MAPA::Extract, {_S(".blend")}, 4};
2016-02-04 00:55:39 +00:00
case SBIG('PART'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractGPSM<UniqueID32>, {_S(".gpsm.yaml")}};
2016-03-09 04:49:44 +00:00
case SBIG('ELSC'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractELSM<UniqueID32>, {_S(".elsm.yaml")}};
2016-03-28 08:54:02 +00:00
case SBIG('SWHC'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractSWSH<UniqueID32>, {_S(".swsh.yaml")}};
2016-03-28 08:54:02 +00:00
case SBIG('CRSC'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractCRSM<UniqueID32>, {_S(".crsm.yaml")}};
2016-03-29 00:07:38 +00:00
case SBIG('WPSC'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractWPSM<UniqueID32>, {_S(".wpsm.yaml")}};
2016-03-29 00:07:38 +00:00
case SBIG('DPSC'):
2016-09-18 23:47:48 +00:00
return {DNAParticle::ExtractDPSM<UniqueID32>, {_S(".dpsm.yaml")}};
2016-03-09 08:54:28 +00:00
case SBIG('FONT'):
2016-09-18 23:47:48 +00:00
return {DNAFont::ExtractFONT<UniqueID32>, {_S(".yaml")}};
2016-04-12 10:52:40 +00:00
case SBIG('DGRP'):
2016-09-18 23:47:48 +00:00
return {DNADGRP::ExtractDGRP<UniqueID32>, {_S(".yaml")}};
case SBIG('AGSC'):
return {AGSC::Extract, {_S(".pool"), _S(".proj"), _S(".samp"), _S(".sdir")}};
case SBIG('CSNG'):
return {CSNG::Extract, {_S(".mid"), _S(".yaml")}};
case SBIG('ATBL'):
return {DNAAudio::ATBL::Extract, {_S(".yaml")}};
case SBIG('CTWK'):
{
bool named;
std::string name = pak.bestEntryName(entry, named);
if (named)
{
if (!name.compare("PlayerRes"))
2016-09-18 23:47:48 +00:00
return {ExtractTweak<CTweakPlayerRes>, {_S(".yaml")}};
2016-08-31 21:00:06 +00:00
if (!name.compare("GunRes"))
2016-09-18 23:47:48 +00:00
return {ExtractTweak<CTweakGunRes>, {_S(".yaml")}};
if (!name.compare("Player"))
2016-09-18 23:47:48 +00:00
return {ExtractTweak<CTweakPlayer>, {_S(".yaml")}};
if (!name.compare("CameraBob"))
2016-09-18 23:47:48 +00:00
return {ExtractTweak<CTweakCameraBob>, {_S(".yaml")}};
if (!name.compare("SlideShow"))
2016-09-18 23:47:48 +00:00
return {ExtractTweak<CTweakSlideShow>, {_S(".yaml")}};
if (!name.compare("Game"))
return {ExtractTweak<CTweakGame>, {_S(".yaml")}};
2017-01-21 22:26:07 +00:00
if (!name.compare("Targeting"))
return {ExtractTweak<CTweakTargeting>, {_S(".yaml")}};
}
break;
}
2015-07-19 06:19:46 +00:00
}
2015-07-17 00:01:05 +00:00
return {};
}
2015-07-16 01:57:34 +00:00
}
}