Rename everything

.gitignore

@@ -5,7 +5,7 @@ version.h
 *.autosave
 docs/*
 .idea/
-Editor/platforms/win/urde.rc
+Editor/platforms/win/metaforce.rc
 .vs/
 out/
 cmake-build-*/

DataSpec/DNACommon/CMakeLists.txt

@@ -9,7 +9,7 @@ make_dnalist(CMDL
              EGMC
              SAVWCommon
              ParticleCommon
-             URDEVersionInfo
+             MetaforceVersionInfo
              Tweaks/ITweakPlayerGun)
 
 set(DNACOMMON_SOURCES
@@ -41,7 +41,7 @@ set(DNACOMMON_SOURCES
     RigInverter.hpp RigInverter.cpp
     AROTBuilder.hpp AROTBuilder.cpp
     OBBTreeBuilder.hpp OBBTreeBuilder.cpp
-    URDEVersionInfo.hpp
+    MetaforceVersionInfo.hpp
     Tweaks/ITweak.hpp
     Tweaks/TweakWriter.hpp
     Tweaks/ITweakGame.hpp

DataSpec/DNACommon/CRSC.cpp

@@ -11,12 +11,12 @@ AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_CRSM<UniqueID64>>)
 
 template <>
 std::string_view PPImpl<_CRSM<UniqueID32>>::DNAType() {
-  return "urde::CRSM<UniqueID32>"sv;
+  return "CRSM<UniqueID32>"sv;
 }
 
 template <>
 std::string_view PPImpl<_CRSM<UniqueID64>>::DNAType() {
-  return "urde::CRSM<UniqueID64>"sv;
+  return "CRSM<UniqueID64>"sv;
 }
 
 template <class IDType>

DataSpec/DNACommon/DNACommon.cpp

@@ -4,7 +4,7 @@
 
 namespace DataSpec {
 
-logvisor::Module LogDNACommon("urde::DNACommon");
+logvisor::Module LogDNACommon("DataSpec::DNACommon");
 ThreadLocalPtr<SpecBase> g_curSpec;
 ThreadLocalPtr<PAKRouterBase> g_PakRouter;
 ThreadLocalPtr<hecl::blender::Token> g_ThreadBlenderToken;

DataSpec/DNACommon/ELSC.cpp

@@ -11,12 +11,12 @@ AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_ELSM<UniqueID64>>)
 
 template <>
 std::string_view ELSM<UniqueID32>::DNAType() {
-  return "urde::ELSM<UniqueID32>"sv;
+  return "ELSM<UniqueID32>"sv;
 }
 
 template <>
 std::string_view ELSM<UniqueID64>::DNAType() {
-  return "urde::ELSM<UniqueID64>"sv;
+  return "ELSM<UniqueID64>"sv;
 }
 
 template <class IDType>

DataSpec/DNACommon/FONT.cpp

@@ -5,7 +5,7 @@
 #include <logvisor/logvisor.hpp>
 
 namespace DataSpec::DNAFont {
-logvisor::Module LogModule("urde::DNAFont");
+logvisor::Module LogModule("DataSpec::DNAFont");
 
 template <class IDType>
 void FONT<IDType>::_read(athena::io::IStreamReader& __dna_reader) {

DataSpec/DNACommon/FSM2.cpp

@@ -9,7 +9,7 @@
 #include <logvisor/logvisor.hpp>
 
 namespace DataSpec::DNAFSM2 {
-logvisor::Module LogDNAFSM2("urde::DNAFSM2");
+logvisor::Module LogDNAFSM2("DataSpec::DNAFSM2");
 
 template <class IDType>
 template <class Op>
@@ -39,12 +39,12 @@ AT_SPECIALIZE_DNA(FSM2<UniqueID64>)
 
 template <>
 std::string_view FSM2<UniqueID32>::DNAType() {
-  return "urde::FSM2<UniqueID32>"sv;
+  return "FSM2<UniqueID32>"sv;
 }
 
 template <>
 std::string_view FSM2<UniqueID64>::DNAType() {
-  return "urde::FSM2<UniqueID64>"sv;
+  return "FSM2<UniqueID64>"sv;
 }
 
 template struct FSM2<UniqueID32>;

DataSpec/DNACommon/MetaforceVersionInfo.hpp

@@ -13,7 +13,7 @@ enum class EGame {
   MetroidPrime3,
 };
 
-struct URDEVersionInfo : BigDNA {
+struct MetaforceVersionInfo : BigDNA {
   AT_DECL_DNA_YAML
 
   String<-1> version;

DataSpec/DNACommon/ParticleCommon.cpp

@@ -1,7 +1,7 @@
 #include "ParticleCommon.hpp"
 
 namespace DataSpec::DNAParticle {
-logvisor::Module LogModule("urde::DNAParticle");
+logvisor::Module LogModule("DataSpec::DNAParticle");
 
 template struct PEImpl<_RealElementFactory>;
 template struct PEImpl<_IntElementFactory>;

DataSpec/DNACommon/TXTR.cpp

@@ -846,7 +846,7 @@ bool TXTR::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) {
   png_infop info = png_create_info_struct(png);
 
   png_text textStruct = {};
-  textStruct.key = png_charp("urde_nomip");
+  textStruct.key = png_charp("metaforce_nomip");
   if (numMips == 1)
     png_set_text(png, info, &textStruct, 1);
 
@@ -1088,13 +1088,13 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
     return false;
   }
 
-  /* Disable mipmapping if urde_nomip embedded */
+  /* Disable mipmapping if metaforce_nomip embedded */
   bool mipmap = true;
   png_text* textStruct;
   int numText;
   png_get_text(pngRead, info, &textStruct, &numText);
   for (int i = 0; i < numText; ++i) {
-    if (std::strcmp(textStruct[i].key, "urde_nomip") == 0) {
+    if (std::strcmp(textStruct[i].key, "metaforce_nomip") == 0) {
       mipmap = false;
     }
   }
@@ -1401,13 +1401,13 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
   const png_byte colorType = png_get_color_type(pngRead, info);
   const png_byte bitDepth = png_get_bit_depth(pngRead, info);
 
-  /* Disable mipmapping if urde_nomip embedded */
+  /* Disable mipmapping if metaforce_nomip embedded */
   bool mipmap = true;
   png_text* textStruct;
   int numText;
   png_get_text(pngRead, info, &textStruct, &numText);
   for (int i = 0; i < numText; ++i) {
-    if (std::strcmp(textStruct[i].key, "urde_nomip") == 0) {
+    if (std::strcmp(textStruct[i].key, "metaforce_nomip") == 0) {
       mipmap = false;
     }
   }

DataSpec/DNACommon/Tweaks/ITweakGunRes.hpp

@@ -9,8 +9,8 @@
 namespace DataSpec {
 
 struct ITweakGunRes : ITweak {
-  using ResId = urde::CAssetId;
-  using EBeamId = urde::CPlayerState::EBeamId;
+  using ResId = metaforce::CAssetId;
+  using EBeamId = metaforce::CPlayerState::EBeamId;
 
   ResId x4_gunMotion;
   ResId x8_grappleArm;
@@ -68,7 +68,7 @@ struct ITweakGunRes : ITweak {
     return x34_weapons[b];
   }
 
-  void ResolveResources(const urde::IFactory& factory) {
+  void ResolveResources(const metaforce::IFactory& factory) {
     x4_gunMotion = factory.GetResourceIdByName(GetGunMotion())->id;
     x8_grappleArm = factory.GetResourceIdByName(GetGrappleArm())->id;
     xc_rightHand = factory.GetResourceIdByName(GetRightHand())->id;

DataSpec/DNACommon/Tweaks/ITweakPlayerRes.hpp

@@ -9,8 +9,8 @@
 namespace DataSpec {
 
 struct ITweakPlayerRes : ITweak {
-  using ResId = urde::CAssetId;
-  using EBeamId = urde::CPlayerState::EBeamId;
+  using ResId = metaforce::CAssetId;
+  using EBeamId = metaforce::CPlayerState::EBeamId;
 
   ResId x4_saveStationIcon;
   ResId x8_missileStationIcon;
@@ -85,7 +85,7 @@ struct ITweakPlayerRes : ITweak {
     }
   }
 
-  void ResolveResources(const urde::IFactory& factory) {
+  void ResolveResources(const metaforce::IFactory& factory) {
     x4_saveStationIcon = factory.GetResourceIdByName(_GetSaveStationIcon())->id;
     x8_missileStationIcon = factory.GetResourceIdByName(_GetMissileStationIcon())->id;
     xc_elevatorIcon = factory.GetResourceIdByName(_GetElevatorIcon())->id;

DataSpec/DNAMP1/AFSM.cpp

@@ -43,7 +43,7 @@ void AFSM::State::Transition::Enumerate<BigDNA::BinarySize>(typename BinarySize:
     trig.binarySize(s);
 }
 
-std::string_view AFSM::State::Transition::DNAType() { return "urde::DNAMP1::AFSM::Transition"sv; }
+std::string_view AFSM::State::Transition::DNAType() { return "DNAMP1::AFSM::Transition"sv; }
 
 template <>
 void AFSM::State::Transition::Trigger::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader) {
@@ -100,7 +100,7 @@ void AFSM::State::Transition::Trigger::Enumerate<BigDNA::BinarySize>(size_t& __i
 }
 
 std::string_view AFSM::State::Transition::Trigger::DNAType() {
-  return "urde::DNAMP1::AFSM::State::Transition::Trigger"sv;
+  return "DNAMP1::AFSM::State::Transition::Trigger"sv;
 }
 
 } // namespace DataSpec::DNAMP1

DataSpec/DNAMP1/ANCS.cpp

@@ -139,7 +139,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumer
 }
 
 std::string_view ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::DNAType() {
-  return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo"sv;
+  return "DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo"sv;
 }
 
 template <>
@@ -315,7 +315,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA
 }
 
 std::string_view ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::DNAType() {
-  return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState"sv;
+  return "DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState"sv;
 }
 
 template <>
@@ -606,7 +606,7 @@ void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::WriteYaml>(athena::io:
 }
 
 std::string_view ANCS::CharacterSet::CharacterInfo::DNAType() {
-  return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo"sv;
+  return "DNAMP1::ANCS::CharacterSet::CharacterInfo"sv;
 }
 
 template <>
@@ -688,7 +688,7 @@ void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::WriteYaml>(athena::i
 }
 
 std::string_view ANCS::AnimationSet::MetaAnimFactory::DNAType() {
-  return "urde::DNAMP1::ANCS::AnimationSet::MetaAnimFactory"sv;
+  return "DNAMP1::ANCS::AnimationSet::MetaAnimFactory"sv;
 }
 
 template <>
@@ -761,7 +761,7 @@ void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::WriteYaml>(athena::
 }
 
 std::string_view ANCS::AnimationSet::MetaTransFactory::DNAType() {
-  return "urde::DNAMP1::ANCS::AnimationSet::MetaTransFactory"sv;
+  return "DNAMP1::ANCS::AnimationSet::MetaTransFactory"sv;
 }
 
 template <>
@@ -955,7 +955,7 @@ void ANCS::AnimationSet::MetaAnimPrimitive::gatherPrimitives(
   out[animIdx] = {animName, animId, ANIM::GetEVNTId(rs), false};
 }
 
-std::string_view ANCS::AnimationSet::DNAType() { return "urde::DNAMP1::ANCS::AnimationSet"sv; }
+std::string_view ANCS::AnimationSet::DNAType() { return "DNAMP1::ANCS::AnimationSet"sv; }
 
 bool ANCS::Extract(const SpecBase& dataSpec, PAKEntryReadStream& rs, const hecl::ProjectPath& outPath,
                    PAKRouter<PAKBridge>& pakRouter, const PAK::Entry& entry, bool force, hecl::blender::Token& btok,
@@ -994,7 +994,7 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
     Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("can't open '{}' for reading")), yamlPath.getRelativePath());
 
   if (!athena::io::ValidateFromYAMLStream<ANCS>(reader)) {
-    Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("'{}' is not urde::DNAMP1::ANCS type")), yamlPath.getRelativePath());
+    Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("'{}' is not DNAMP1::ANCS type")), yamlPath.getRelativePath());
   }
 
   athena::io::YAMLDocReader yamlReader;

DataSpec/DNAMP1/DNAMP1.cpp

@@ -30,7 +30,7 @@
 #include "PATH.hpp"
 
 #include "DataSpec/DNACommon/Tweaks/TweakWriter.hpp"
-#include "DataSpec/DNACommon/URDEVersionInfo.hpp"
+#include "DataSpec/DNACommon/MetaforceVersionInfo.hpp"
 #include "Tweaks/CTweakPlayerRes.hpp"
 #include "Tweaks/CTweakGunRes.hpp"
 #include "Tweaks/CTweakPlayer.hpp"
@@ -49,7 +49,7 @@
 #include "SnowForces.hpp"
 
 namespace DataSpec::DNAMP1 {
-logvisor::Module Log("urde::DNAMP1");
+logvisor::Module Log("DataSpec::DNAMP1");
 
 static bool GetNoShare(std::string_view name) {
   std::string lowerName(name);

DataSpec/DNAMP1/EVNT.cpp

@@ -23,6 +23,6 @@ void EVNT::Enumerate(typename Op::StreamT& s) {
 
 AT_SPECIALIZE_DNA_YAML(EVNT)
 
-std::string_view EVNT::DNAType() { return "urde::DNAMP1::EVNT"sv; }
+std::string_view EVNT::DNAType() { return "DNAMP1::EVNT"sv; }
 
 } // namespace DataSpec::DNAMP1

DataSpec/DNAMP1/MLVL.cpp

@@ -269,7 +269,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
         std::vector<hecl::ProjectPath> depPaths;
         std::vector<hecl::ProjectPath> lazyPaths;
         for (std::unique_ptr<IScriptObject>& obj : layer.objects) {
-          if (obj->type == int(urde::EScriptObjectType::MemoryRelay)) {
+          if (obj->type == int(metaforce::EScriptObjectType::MemoryRelay)) {
             MemoryRelay& memRelay = static_cast<MemoryRelay&>(*obj);
             for (IScriptObject::Connection& conn : memRelay.connections) {
               MemRelayLink linkOut;
@@ -319,7 +319,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
       areaOut.depLayers.push_back(areaOut.deps.size());
       for (const std::pair<hecl::ProjectPath, bool>& path : layer) {
         if (path.first) {
-          urde::SObjectTag tag = g_curSpec->buildTagFromPath(path.first);
+          metaforce::SObjectTag tag = g_curSpec->buildTagFromPath(path.first);
           if (tag.id.IsValid()) {
             if (path.second)
               areaOut.lazyDeps.emplace_back(tag.id.Value(), tag.type);
@@ -348,7 +348,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
         layerResources.addSharedPath(path, false);
 
       for (const std::pair<hecl::ProjectPath, bool>& path : layerResources.sharedPaths) {
-        urde::SObjectTag tag = g_curSpec->buildTagFromPath(path.first);
+        metaforce::SObjectTag tag = g_curSpec->buildTagFromPath(path.first);
         if (tag.id.IsValid()) {
           if (path.second)
             areaOut.lazyDeps.emplace_back(tag.id.Value(), tag.type);
@@ -359,7 +359,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
       }
 
       hecl::ProjectPath pathPath = GetPathBeginsWith(areaDEnum, area.path, _SYS_STR("!path_"));
-      urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath);
+      metaforce::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath);
       if (pathTag.id.IsValid()) {
         areaOut.deps.emplace_back(pathTag.id.Value(), pathTag.type);
         areaOut.lazyDeps.emplace_back(0, FOURCC('NONE'));
@@ -392,7 +392,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
 }
 
 bool MLVL::CookMAPW(const hecl::ProjectPath& outPath, const World& wld) {
-  std::vector<urde::SObjectTag> mapaTags;
+  std::vector<metaforce::SObjectTag> mapaTags;
   mapaTags.reserve(wld.areas.size());
 
   for (const World::Area& area : wld.areas) {
@@ -411,7 +411,7 @@ bool MLVL::CookMAPW(const hecl::ProjectPath& outPath, const World& wld) {
     fo.writeUint32Big(0xDEADF00D);
     fo.writeUint32Big(1);
     fo.writeUint32Big(mapaTags.size());
-    for (const urde::SObjectTag& mapa : mapaTags)
+    for (const metaforce::SObjectTag& mapa : mapaTags)
       fo.writeUint32Big(u32(mapa.id.Value()));
     int64_t rem = fo.position() % 32;
     if (rem)
@@ -479,7 +479,7 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath, const World& wld) {
       {
         std::vector<Scan> scans;
         for (std::unique_ptr<IScriptObject>& obj : layer.objects) {
-          if (obj->type == int(urde::EScriptObjectType::MemoryRelay)) {
+          if (obj->type == int(metaforce::EScriptObjectType::MemoryRelay)) {
             MemoryRelay& memRelay = static_cast<MemoryRelay&>(*obj);
             auto iter = std::find(memRelays.begin(), memRelays.end(), memRelay.id);
             if (iter == memRelays.end()) {
@@ -487,7 +487,7 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath, const World& wld) {
               savw.relays.push_back(memRelay.id);
               memRelays.push_back(memRelay.id);
             }
-          } else if (obj->type == int(urde::EScriptObjectType::SpecialFunction)) {
+          } else if (obj->type == int(metaforce::EScriptObjectType::SpecialFunction)) {
             SpecialFunction& specialFunc = static_cast<SpecialFunction&>(*obj);
             if (specialFunc.function == ESpecialFunctionType::CinematicSkip)
               savw.skippableCutscenes.push_back(specialFunc.id);
@@ -497,7 +497,7 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath, const World& wld) {
               layer.areaId = specialFunc.layerSwitch.area;
               layer.layer = specialFunc.layerSwitch.layerIdx;
             }
-          } else if (obj->type == int(urde::EScriptObjectType::Door)) {
+          } else if (obj->type == int(metaforce::EScriptObjectType::Door)) {
             DoorArea& doorArea = static_cast<DoorArea&>(*obj);
             savw.doors.push_back(doorArea.id);
           }

DataSpec/DNAMP1/SCAN.cpp

@@ -66,7 +66,7 @@ void SCAN::Texture::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
   w.writeFloat("fadeDuration", fadeDuration);
 }
 
-std::string_view SCAN::Texture::DNAType() { return "urde::DNAMP1::SCAN::Texture"sv; }
+std::string_view SCAN::Texture::DNAType() { return "DNAMP1::SCAN::Texture"sv; }
 
 template <>
 void SCAN::Texture::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {

DataSpec/DNAMP1/SCLY.cpp

@@ -91,7 +91,7 @@ void SCLY::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& docout) {
   docout.enumerate("layers", layers);
 }
 
-std::string_view SCLY::DNAType() { return "urde::DNAMP1::SCLY"sv; }
+std::string_view SCLY::DNAType() { return "DNAMP1::SCLY"sv; }
 
 template <>
 void SCLY::ScriptLayer::Enumerate<BigDNA::Read>(athena::io::IStreamReader& rs) {
@@ -191,6 +191,6 @@ void SCLY::ScriptLayer::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter&
   }
 }
 
-std::string_view SCLY::ScriptLayer::DNAType() { return "urde::DNAMP1::SCLY::ScriptLayer"sv; }
+std::string_view SCLY::ScriptLayer::DNAType() { return "DNAMP1::SCLY::ScriptLayer"sv; }
 
 } // namespace DataSpec::DNAMP1

DataSpec/DNAMP1/STRG.cpp

@@ -458,5 +458,5 @@ void STRG::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer) {
   }
 }
 
-std::string_view STRG::DNAType() { return "urde::DNAMP1::STRG"sv; }
+std::string_view STRG::DNAType() { return "DNAMP1::STRG"sv; }
 } // namespace DataSpec::DNAMP1

DataSpec/DNAMP1/ScriptObjects/Oculus.cpp

@@ -26,7 +26,7 @@ void Oculus::Enumerate(typename Op::StreamT& s) {
     unknown8 = 0.f;
 }
 
-std::string_view Oculus::DNAType() { return "urde::DNAMP1::Oculus"sv; }
+std::string_view Oculus::DNAType() { return "DNAMP1::Oculus"sv; }
 
 AT_SPECIALIZE_DNA_YAML(Oculus)
 

DataSpec/DNAMP1/ScriptObjects/Ridley.cpp

@@ -61,7 +61,7 @@ void Ridley::Enumerate(typename Op::StreamT& s) {
     Do<Op>(athena::io::PropId{"damageInfo9"}, damageInfo9, s);
 }
 
-std::string_view Ridley::DNAType() { return "urde::DNAMP1::Ridley"sv; }
+std::string_view Ridley::DNAType() { return "DNAMP1::Ridley"sv; }
 
 AT_SPECIALIZE_DNA_YAML(Ridley)
 

DataSpec/DNAMP1/ScriptObjects/WorldTeleporter.cpp

@@ -41,7 +41,7 @@ void WorldTeleporter::Enumerate(typename Op::StreamT& s) {
   }
 }
 
-std::string_view WorldTeleporter::DNAType() { return "urde::DNAMP1::WorldTeleporter"sv; }
+std::string_view WorldTeleporter::DNAType() { return "DNAMP1::WorldTeleporter"sv; }
 
 AT_SPECIALIZE_DNA_YAML(WorldTeleporter)
 

DataSpec/DNAMP2/ANCS.cpp

@@ -347,7 +347,7 @@ void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::WriteYaml>(typename Wr
 }
 
 std::string_view ANCS::CharacterSet::CharacterInfo::DNAType() {
-  return "urde::DNAMP2::ANCS::CharacterSet::CharacterInfo"sv;
+  return "DNAMP2::ANCS::CharacterSet::CharacterInfo"sv;
 }
 
 template <>
@@ -523,7 +523,7 @@ void ANCS::AnimationSet::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::Stream
   }
 }
 
-std::string_view ANCS::AnimationSet::DNAType() { return "urde::DNAMP2::ANCS::AnimationSet"sv; }
+std::string_view ANCS::AnimationSet::DNAType() { return "DNAMP2::ANCS::AnimationSet"sv; }
 
 template <class Op>
 void ANCS::AnimationSet::EVNT::Enumerate(typename Op::StreamT& s) {
@@ -542,6 +542,6 @@ void ANCS::AnimationSet::EVNT::Enumerate(typename Op::StreamT& s) {
 
 AT_SPECIALIZE_DNA(ANCS::AnimationSet::EVNT)
 
-std::string_view ANCS::AnimationSet::EVNT::DNAType() { return "urde::DNAMP2::ANCS::AnimationSet::EVNT"sv; }
+std::string_view ANCS::AnimationSet::EVNT::DNAType() { return "DNAMP2::ANCS::AnimationSet::EVNT"sv; }
 
 } // namespace DataSpec::DNAMP2

DataSpec/DNAMP2/DNAMP2.cpp

@@ -22,7 +22,7 @@
 #include "Runtime/GCNTypes.hpp"
 
 namespace DataSpec::DNAMP2 {
-logvisor::Module Log("urde::DNAMP2");
+logvisor::Module Log("DataSpec::DNAMP2");
 
 static bool GetNoShare(std::string_view name) {
   std::string lowerName(name);

DataSpec/DNAMP2/STRG.cpp

@@ -213,6 +213,6 @@ void STRG::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer) {
   }
 }
 
-std::string_view STRG::DNAType() { return "urde::DNAMP2::STRG"sv; }
+std::string_view STRG::DNAType() { return "DNAMP2::STRG"sv; }
 
 } // namespace DataSpec::DNAMP2

DataSpec/DNAMP3/CHAR.cpp

@@ -69,7 +69,7 @@ void CHAR::AnimationInfo::EVNT::SFXEvent::Enumerate<BigDNA::WriteYaml>(athena::i
 }
 
 std::string_view CHAR::AnimationInfo::EVNT::SFXEvent::DNAType() {
-  return "urde::DNAMP3::CHAR::AnimationInfo::EVNT::SFXEvent"sv;
+  return "DNAMP3::CHAR::AnimationInfo::EVNT::SFXEvent"sv;
 }
 
 template <>
@@ -151,7 +151,7 @@ void CHAR::AnimationInfo::MetaAnimFactory::Enumerate<BigDNA::WriteYaml>(athena::
 }
 
 std::string_view CHAR::AnimationInfo::MetaAnimFactory::DNAType() {
-  return "urde::DNAMP3::CHAR::AnimationInfo::MetaAnimFactory"sv;
+  return "DNAMP3::CHAR::AnimationInfo::MetaAnimFactory"sv;
 }
 
 } // namespace DataSpec::DNAMP3

DataSpec/DNAMP3/DNAMP3.cpp

@@ -19,7 +19,7 @@
 #include "Runtime/GCNTypes.hpp"
 
 namespace DataSpec::DNAMP3 {
-logvisor::Module Log("urde::DNAMP3");
+logvisor::Module Log("DataSpec::DNAMP3");
 
 static bool GetNoShare(std::string_view name) {
   std::string lowerName(name);

DataSpec/DNAMP3/STRG.cpp

@@ -220,6 +220,6 @@ void STRG::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer) {
   }
 }
 
-std::string_view STRG::DNAType() { return "urde::DNAMP3::STRG"sv; }
+std::string_view STRG::DNAType() { return "DNAMP3::STRG"sv; }
 
 } // namespace DataSpec::DNAMP3

DataSpec/SpecBase.cpp

@@ -8,7 +8,7 @@
 #include "DataSpec/DNACommon/DNACommon.hpp"
 #include "DataSpec/DNACommon/TXTR.hpp"
 #include "DataSpec/AssetNameMap.hpp"
-#include "DataSpec/DNACommon/URDEVersionInfo.hpp"
+#include "DataSpec/DNACommon/MetaforceVersionInfo.hpp"
 #include "hecl/ClientProcess.hpp"
 #include "nod/DiscBase.hpp"
 #include "nod/nod.hpp"
@@ -22,7 +22,7 @@
 
 namespace DataSpec {
 
-static logvisor::Module Log("urde::SpecBase");
+static logvisor::Module Log("DataSpec::SpecBase");
 
 static const hecl::SystemChar* MomErr[] = {_SYS_STR("Your metroid is in another castle"),
                                            _SYS_STR("HECL is experiencing a PTSD attack"),
@@ -441,8 +441,8 @@ bool SpecBase::canPackage(const hecl::ProjectPath& path) {
   return path.isFile() || path.isDirectory();
 }
 
-void SpecBase::recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut,
-                                          std::unordered_set<urde::SObjectTag>& addedTags,
+void SpecBase::recursiveBuildResourceList(std::vector<metaforce::SObjectTag>& listOut,
+                                          std::unordered_set<metaforce::SObjectTag>& addedTags,
                                           const hecl::ProjectPath& path, hecl::blender::Token& btok) {
   hecl::DirectoryEnumerator dEnum(path.getAbsolutePath(), hecl::DirectoryEnumerator::Mode::DirsThenFilesSorted, false,
                                   false, true);
@@ -452,7 +452,7 @@ void SpecBase::recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut
       if (hecl::ProjectPath(childPath, _SYS_STR("!project.yaml")).isFile() &&
           hecl::ProjectPath(childPath, _SYS_STR("!pool.yaml")).isFile()) {
         /* Handle AudioGroup case */
-        if (urde::SObjectTag tag = tagFromPath(childPath)) {
+        if (metaforce::SObjectTag tag = tagFromPath(childPath)) {
           if (addedTags.find(tag) != addedTags.end())
             continue;
           addedTags.insert(tag);
@@ -466,7 +466,7 @@ void SpecBase::recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut
       std::vector<hecl::ProjectPath> subPaths;
       flattenDependencies(childPath, subPaths, btok);
       for (const auto& subPath : subPaths) {
-        if (urde::SObjectTag tag = tagFromPath(subPath)) {
+        if (metaforce::SObjectTag tag = tagFromPath(subPath)) {
           if (addedTags.find(tag) != addedTags.end())
             continue;
           addedTags.insert(tag);
@@ -478,10 +478,10 @@ void SpecBase::recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut
 }
 
 void SpecBase::copyBuildListData(std::vector<std::tuple<size_t, size_t, bool>>& fileIndex,
-                                 const std::vector<urde::SObjectTag>& buildList,
+                                 const std::vector<metaforce::SObjectTag>& buildList,
                                  const hecl::Database::DataSpecEntry* entry, bool fast,
                                  const hecl::MultiProgressPrinter& progress, athena::io::FileWriter& pakOut,
-                                 const std::unordered_map<urde::CAssetId, std::vector<uint8_t>>& mlvlData) {
+                                 const std::unordered_map<metaforce::CAssetId, std::vector<uint8_t>>& mlvlData) {
   fileIndex.reserve(buildList.size());
   int loadIdx = 0;
   for (const auto& tag : buildList) {
@@ -564,9 +564,9 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
 
   /* Output file */
   athena::io::FileWriter pakOut(outPath.getAbsolutePath());
-  std::vector<urde::SObjectTag> buildList;
+  std::vector<metaforce::SObjectTag> buildList;
   atUint64 resTableOffset = 0;
-  std::unordered_map<urde::CAssetId, std::vector<uint8_t>> mlvlData;
+  std::unordered_map<metaforce::CAssetId, std::vector<uint8_t>> mlvlData;
 
   if (IsWorldBlend(path)) /* World PAK */
   {
@@ -583,9 +583,9 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
   } else if (path.getPathType() == hecl::ProjectPath::Type::Directory) /* General PAK */
   {
     /* Build resource list */
-    std::unordered_set<urde::SObjectTag> addedTags;
+    std::unordered_set<metaforce::SObjectTag> addedTags;
     recursiveBuildResourceList(buildList, addedTags, path, btok);
-    std::vector<std::pair<urde::SObjectTag, std::string>> nameList;
+    std::vector<std::pair<metaforce::SObjectTag, std::string>> nameList;
 
     /* Build name list */
     for (const auto& item : buildList) {
@@ -605,10 +605,10 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
     /* Build resource list */
     std::vector<hecl::ProjectPath> subPaths;
     flattenDependencies(path, subPaths, btok);
-    std::unordered_set<urde::SObjectTag> addedTags;
-    std::vector<std::pair<urde::SObjectTag, std::string>> nameList;
+    std::unordered_set<metaforce::SObjectTag> addedTags;
+    std::vector<std::pair<metaforce::SObjectTag, std::string>> nameList;
     for (const auto& subPath : subPaths) {
-      if (urde::SObjectTag tag = tagFromPath(subPath)) {
+      if (metaforce::SObjectTag tag = tagFromPath(subPath)) {
         if (addedTags.find(tag) != addedTags.end())
           continue;
         addedTags.insert(tag);
@@ -635,12 +635,12 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
   if (cp) {
     Log.report(logvisor::Info, FMT_STRING(_SYS_STR("Validating resources")));
     progress.setMainIndeterminate(true);
-    std::vector<urde::SObjectTag> cookTags;
+    std::vector<metaforce::SObjectTag> cookTags;
     cookTags.reserve(buildList.size());
 
     /* Ensure CMDLs are enqueued first to minimize synchronous dependency cooking */
     for (int i = 0; i < 2; ++i) {
-      std::unordered_set<urde::SObjectTag> addedTags;
+      std::unordered_set<metaforce::SObjectTag> addedTags;
       addedTags.reserve(buildList.size());
       for (auto& tag : buildList) {
         if ((i == 0 && tag.type == FOURCC('CMDL')) || (i == 1 && tag.type != FOURCC('CMDL'))) {
@@ -732,7 +732,7 @@ void SpecBase::extractRandomStaticEntropy(const uint8_t* buf, const hecl::Projec
   png_infop info = png_create_info_struct(png);
 
   png_text textStruct = {};
-  textStruct.key = png_charp("urde_nomip");
+  textStruct.key = png_charp("meta_nomip");
   png_set_text(png, info, &textStruct, 1);
 
   png_set_IHDR(png, info, 1024, 512, 8, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
@@ -761,7 +761,7 @@ void SpecBase::clearTagCache() {
   m_catalogTagToNames.clear();
 }
 
-hecl::ProjectPath SpecBase::pathFromTag(const urde::SObjectTag& tag) const {
+hecl::ProjectPath SpecBase::pathFromTag(const metaforce::SObjectTag& tag) const {
   std::unique_lock lk(m_backgroundIndexMutex);
   auto search = m_tagToPath.find(tag);
   if (search != m_tagToPath.cend())
@@ -769,14 +769,14 @@ hecl::ProjectPath SpecBase::pathFromTag(const urde::SObjectTag& tag) const {
   return {};
 }
 
-urde::SObjectTag SpecBase::tagFromPath(const hecl::ProjectPath& path) const {
+metaforce::SObjectTag SpecBase::tagFromPath(const hecl::ProjectPath& path) const {
   auto search = m_pathToTag.find(path.hash());
   if (search != m_pathToTag.cend())
     return search->second;
   return buildTagFromPath(path);
 }
 
-bool SpecBase::waitForTagReady(const urde::SObjectTag& tag, const hecl::ProjectPath*& pathOut) {
+bool SpecBase::waitForTagReady(const metaforce::SObjectTag& tag, const hecl::ProjectPath*& pathOut) {
   std::unique_lock lk(m_backgroundIndexMutex);
   auto search = m_tagToPath.find(tag);
   if (search == m_tagToPath.end()) {
@@ -799,7 +799,7 @@ bool SpecBase::waitForTagReady(const urde::SObjectTag& tag, const hecl::ProjectP
   return true;
 }
 
-const urde::SObjectTag* SpecBase::getResourceIdByName(std::string_view name) const {
+const metaforce::SObjectTag* SpecBase::getResourceIdByName(std::string_view name) const {
   std::string lower(name);
   std::transform(lower.cbegin(), lower.cend(), lower.begin(), tolower);
 
@@ -823,12 +823,12 @@ const urde::SObjectTag* SpecBase::getResourceIdByName(std::string_view name) con
   return &search->second;
 }
 
-FourCC SpecBase::getResourceTypeById(urde::CAssetId id) const {
+FourCC SpecBase::getResourceTypeById(metaforce::CAssetId id) const {
   if (!id.IsValid())
     return {};
 
   std::unique_lock lk(m_backgroundIndexMutex);
-  urde::SObjectTag searchTag = {FourCC(), id};
+  metaforce::SObjectTag searchTag = {FourCC(), id};
   auto search = m_tagToPath.find(searchTag);
   if (search == m_tagToPath.end()) {
     if (m_backgroundRunning) {
@@ -849,7 +849,7 @@ FourCC SpecBase::getResourceTypeById(urde::CAssetId id) const {
   return search->first.type;
 }
 
-void SpecBase::enumerateResources(const std::function<bool(const urde::SObjectTag&)>& lambda) const {
+void SpecBase::enumerateResources(const std::function<bool(const metaforce::SObjectTag&)>& lambda) const {
   waitForIndexComplete();
   for (const auto& pair : m_tagToPath) {
     if (!lambda(pair.first))
@@ -858,7 +858,7 @@ void SpecBase::enumerateResources(const std::function<bool(const urde::SObjectTa
 }
 
 void SpecBase::enumerateNamedResources(
-    const std::function<bool(std::string_view, const urde::SObjectTag&)>& lambda) const {
+    const std::function<bool(std::string_view, const metaforce::SObjectTag&)>& lambda) const {
   waitForIndexComplete();
   for (const auto& pair : m_catalogNameToTag) {
     if (!lambda(pair.first, pair.second))
@@ -866,7 +866,7 @@ void SpecBase::enumerateNamedResources(
   }
 }
 
-static void WriteTag(athena::io::YAMLDocWriter& cacheWriter, const urde::SObjectTag& pathTag,
+static void WriteTag(athena::io::YAMLDocWriter& cacheWriter, const metaforce::SObjectTag& pathTag,
                      const hecl::ProjectPath& path) {
   auto key = fmt::format(FMT_STRING("{}"), pathTag.id);
   if (auto* existing = cacheWriter.getCurNode()->findMapChild(key)) {
@@ -877,7 +877,7 @@ static void WriteTag(athena::io::YAMLDocWriter& cacheWriter, const urde::SObject
   }
 }
 
-static void WriteNameTag(athena::io::YAMLDocWriter& nameWriter, const urde::SObjectTag& pathTag,
+static void WriteNameTag(athena::io::YAMLDocWriter& nameWriter, const metaforce::SObjectTag& pathTag,
                          std::string_view name) {
   nameWriter.writeString(name.data(), fmt::format(FMT_STRING("{}"), pathTag.id));
 }
@@ -915,7 +915,7 @@ void SpecBase::readCatalog(const hecl::ProjectPath& catalogPath, athena::io::YAM
     }
     if (path.isNone())
       continue;
-    urde::SObjectTag pathTag = tagFromPath(path);
+    metaforce::SObjectTag pathTag = tagFromPath(path);
     if (pathTag) {
       std::unique_lock lk(m_backgroundIndexMutex);
       m_catalogNameToTag[pLower] = pathTag;
@@ -956,7 +956,7 @@ void SpecBase::backgroundIndexRecursiveCatalogs(const hecl::ProjectPath& dir, at
   }
 }
 
-void SpecBase::insertPathTag(athena::io::YAMLDocWriter& cacheWriter, const urde::SObjectTag& tag,
+void SpecBase::insertPathTag(athena::io::YAMLDocWriter& cacheWriter, const metaforce::SObjectTag& tag,
                              const hecl::ProjectPath& path, bool dump) {
 #if 0
   auto search = m_tagToPath.find(tag);
@@ -989,7 +989,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path, athena::io::YAMLDoc
     return true;
 
   /* Classify intermediate into tag */
-  urde::SObjectTag pathTag = buildTagFromPath(path);
+  metaforce::SObjectTag pathTag = buildTagFromPath(path);
   if (pathTag) {
     std::unique_lock lk{m_backgroundIndexMutex};
     bool useGlob = false;
@@ -1085,7 +1085,7 @@ void SpecBase::backgroundIndexRecursiveProc(const hecl::ProjectPath& dir, athena
       if (hecl::ProjectPath(path, "!project.yaml").isFile() && hecl::ProjectPath(path, "!pool.yaml").isFile()) {
         /* Avoid redundant filesystem access for re-caches */
         if (m_pathToTag.find(path.hash()) == m_pathToTag.cend()) {
-          urde::SObjectTag pathTag(SBIG('AGSC'), path.parsedHash32());
+          metaforce::SObjectTag pathTag(SBIG('AGSC'), path.parsedHash32());
           insertPathTag(cacheWriter, pathTag, path);
         }
       } else {
@@ -1138,7 +1138,7 @@ void SpecBase::backgroundIndexProc() {
           if (node.m_seqChildren.size() >= 2) {
             unsigned long id = strtoul(child.first.c_str(), nullptr, 16);
             hecl::FourCC type(node.m_seqChildren[0]->m_scalarString.c_str());
-            urde::SObjectTag pathTag(type, id);
+            metaforce::SObjectTag pathTag(type, id);
             for (auto I = node.m_seqChildren.begin() + 1, E = node.m_seqChildren.end(); I != E; ++I) {
               hecl::ProjectPath path(m_project.getProjectWorkingPath(), (*I)->m_scalarString);
               if (!path.isNone())
@@ -1166,7 +1166,7 @@ void SpecBase::backgroundIndexProc() {
           m_catalogTagToNames.reserve(nameReader.getRootNode()->m_mapChildren.size());
           for (const auto& child : nameReader.getRootNode()->m_mapChildren) {
             unsigned long id = strtoul(child.second->m_scalarString.c_str(), nullptr, 16);
-            auto search = m_tagToPath.find(urde::SObjectTag(FourCC(), uint32_t(id)));
+            auto search = m_tagToPath.find(metaforce::SObjectTag(FourCC(), uint32_t(id)));
             if (search != m_tagToPath.cend()) {
               std::string chLower = child.first;
               std::transform(chLower.cbegin(), chLower.cend(), chLower.begin(), tolower);
@@ -1224,7 +1224,7 @@ void SpecBase::WriteVersionInfo(hecl::Database::Project& project, const hecl::Pr
   hecl::ProjectPath versionPath(pakPath, _SYS_STR("version.yaml"));
   versionPath.makeDirChain(false);
 
-  URDEVersionInfo info;
+  MetaforceVersionInfo info;
   info.version = m_version;
   info.region = m_region;
   info.game = m_game;

DataSpec/SpecBase.hpp

@@ -57,7 +57,7 @@ struct SpecBase : hecl::Database::IDataSpec {
   virtual bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress) = 0;
 
   /* Convert path to object tag */
-  virtual urde::SObjectTag buildTagFromPath(const hecl::ProjectPath& path) const = 0;
+  virtual metaforce::SObjectTag buildTagFromPath(const hecl::ProjectPath& path) const = 0;
 
   /* Even if PC spec is being cooked, this will return the vanilla GCN spec */
   virtual const hecl::Database::DataSpecEntry& getOriginalSpec() const = 0;
@@ -121,15 +121,15 @@ struct SpecBase : hecl::Database::IDataSpec {
 
   virtual void buildWorldPakList(const hecl::ProjectPath& worldPath, const hecl::ProjectPath& worldPathCooked,
                                  hecl::blender::Token& btok, athena::io::FileWriter& w,
-                                 std::vector<urde::SObjectTag>& listOut, atUint64& resTableOffset,
-                                 std::unordered_map<urde::CAssetId, std::vector<uint8_t>>& mlvlData) {}
+                                 std::vector<metaforce::SObjectTag>& listOut, atUint64& resTableOffset,
+                                 std::unordered_map<metaforce::CAssetId, std::vector<uint8_t>>& mlvlData) {}
   virtual void buildPakList(hecl::blender::Token& btok, athena::io::FileWriter& w,
-                            const std::vector<urde::SObjectTag>& list,
-                            const std::vector<std::pair<urde::SObjectTag, std::string>>& nameList,
+                            const std::vector<metaforce::SObjectTag>& list,
+                            const std::vector<std::pair<metaforce::SObjectTag, std::string>>& nameList,
                             atUint64& resTableOffset) {}
-  virtual void writePakFileIndex(athena::io::FileWriter& w, const std::vector<urde::SObjectTag>& tags,
+  virtual 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) {}
-  virtual std::pair<std::unique_ptr<uint8_t[]>, size_t> compressPakData(const urde::SObjectTag& tag,
+  virtual std::pair<std::unique_ptr<uint8_t[]>, size_t> compressPakData(const metaforce::SObjectTag& tag,
                                                                         const uint8_t* data, size_t len) {
     return {};
   }
@@ -149,19 +149,19 @@ struct SpecBase : hecl::Database::IDataSpec {
   void extractRandomStaticEntropy(const uint8_t* buf, const hecl::ProjectPath& pakPath);
 
   /* Tag cache functions */
-  urde::SObjectTag tagFromPath(const hecl::ProjectPath& path) const;
-  hecl::ProjectPath pathFromTag(const urde::SObjectTag& tag) const;
-  bool waitForTagReady(const urde::SObjectTag& tag, const hecl::ProjectPath*& pathOut);
-  const urde::SObjectTag* getResourceIdByName(std::string_view name) const;
-  hecl::FourCC getResourceTypeById(urde::CAssetId id) const;
-  void enumerateResources(const std::function<bool(const urde::SObjectTag&)>& lambda) const;
-  void enumerateNamedResources(const std::function<bool(std::string_view, const urde::SObjectTag&)>& lambda) const;
+  metaforce::SObjectTag tagFromPath(const hecl::ProjectPath& path) const;
+  hecl::ProjectPath pathFromTag(const metaforce::SObjectTag& tag) const;
+  bool waitForTagReady(const metaforce::SObjectTag& tag, const hecl::ProjectPath*& pathOut);
+  const metaforce::SObjectTag* getResourceIdByName(std::string_view name) const;
+  hecl::FourCC getResourceTypeById(metaforce::CAssetId id) const;
+  void enumerateResources(const std::function<bool(const metaforce::SObjectTag&)>& lambda) const;
+  void enumerateNamedResources(const std::function<bool(std::string_view, const metaforce::SObjectTag&)>& lambda) const;
   void cancelBackgroundIndex();
   void beginBackgroundIndex();
   bool backgroundIndexRunning() const { return m_backgroundRunning; }
   void waitForIndexComplete() const;
 
-  virtual void getTagListForFile(const char* pakName, std::vector<urde::SObjectTag>& out) const {}
+  virtual void getTagListForFile(const char* pakName, std::vector<metaforce::SObjectTag>& out) const {}
 
   SpecBase(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc);
   ~SpecBase();
@@ -171,10 +171,10 @@ protected:
   bool m_pc;
   hecl::ProjectPath m_masterShader;
 
-  std::unordered_multimap<urde::SObjectTag, hecl::ProjectPath> m_tagToPath;
-  std::unordered_map<hecl::Hash, urde::SObjectTag> m_pathToTag;
-  std::unordered_map<std::string, urde::SObjectTag> m_catalogNameToTag;
-  std::unordered_map<urde::SObjectTag, std::unordered_set<std::string>> m_catalogTagToNames;
+  std::unordered_multimap<metaforce::SObjectTag, hecl::ProjectPath> m_tagToPath;
+  std::unordered_map<hecl::Hash, metaforce::SObjectTag> m_pathToTag;
+  std::unordered_map<std::string, metaforce::SObjectTag> m_catalogNameToTag;
+  std::unordered_map<metaforce::SObjectTag, std::unordered_set<std::string>> m_catalogTagToNames;
   void clearTagCache();
 
   hecl::blender::Token m_backgroundBlender;
@@ -183,7 +183,7 @@ protected:
   bool m_backgroundRunning = false;
 
   void readCatalog(const hecl::ProjectPath& catalogPath, athena::io::YAMLDocWriter& nameWriter);
-  void insertPathTag(athena::io::YAMLDocWriter& cacheWriter, const urde::SObjectTag& tag, const hecl::ProjectPath& path,
+  void insertPathTag(athena::io::YAMLDocWriter& cacheWriter, const metaforce::SObjectTag& tag, const hecl::ProjectPath& path,
                      bool dump = true);
   bool addFileToIndex(const hecl::ProjectPath& path, athena::io::YAMLDocWriter& cacheWriter);
   void backgroundIndexRecursiveProc(const hecl::ProjectPath& path, athena::io::YAMLDocWriter& cacheWriter,
@@ -192,13 +192,13 @@ protected:
                                         int level);
   void backgroundIndexProc();
 
-  void recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut,
-                                  std::unordered_set<urde::SObjectTag>& addedTags, const hecl::ProjectPath& path,
+  void recursiveBuildResourceList(std::vector<metaforce::SObjectTag>& listOut,
+                                  std::unordered_set<metaforce::SObjectTag>& addedTags, const hecl::ProjectPath& path,
                                   hecl::blender::Token& btok);
   void copyBuildListData(std::vector<std::tuple<size_t, size_t, bool>>& fileIndex,
-                         const std::vector<urde::SObjectTag>& buildList, const hecl::Database::DataSpecEntry* entry,
+                         const std::vector<metaforce::SObjectTag>& buildList, const hecl::Database::DataSpecEntry* entry,
                          bool fast, const hecl::MultiProgressPrinter& progress, athena::io::FileWriter& pakOut,
-                         const std::unordered_map<urde::CAssetId, std::vector<uint8_t>>& mlvlData);
+                         const std::unordered_map<metaforce::CAssetId, std::vector<uint8_t>>& mlvlData);
 
   std::unique_ptr<nod::DiscBase> m_disc;
   bool m_isWii{};

DataSpec/SpecMP1.cpp

@@ -29,7 +29,7 @@
 #include "DNACommon/DPSC.hpp"
 #include "DNACommon/DGRP.hpp"
 #include "DNACommon/MAPU.hpp"
-#include "DNACommon/URDEVersionInfo.hpp"
+#include "DNACommon/MetaforceVersionInfo.hpp"
 #include "DNACommon/Tweaks/TweakWriter.hpp"
 #include "DNAMP1/Tweaks/CTweakPlayerRes.hpp"
 #include "DNAMP1/Tweaks/CTweakGunRes.hpp"
@@ -57,7 +57,7 @@ namespace DataSpec {
 
 using namespace std::literals;
 
-static logvisor::Module Log("urde::SpecMP1");
+static logvisor::Module Log("metaforce::SpecMP1");
 extern hecl::Database::DataSpecEntry SpecEntMP1;
 extern hecl::Database::DataSpecEntry SpecEntMP1PC;
 extern hecl::Database::DataSpecEntry SpecEntMP1ORIG;
@@ -473,7 +473,7 @@ struct SpecMP1 : SpecBase {