mirror of https://github.com/AxioDL/metaforce.git
96 lines
3.2 KiB
C++
96 lines
3.2 KiB
C++
#include "AssetNameMap.hpp"
|
|
#include "athena/Compression.hpp"
|
|
#include "athena/MemoryReader.hpp"
|
|
|
|
extern "C" const uint8_t ASSET_NAME_MP32[];
|
|
extern "C" const size_t ASSET_NAME_MP32_SZ;
|
|
extern "C" const size_t ASSET_NAME_MP32_DECOMPRESSED_SZ;
|
|
extern "C" const uint8_t ASSET_NAME_MP64[];
|
|
extern "C" const size_t ASSET_NAME_MP64_SZ;
|
|
extern "C" const size_t ASSET_NAME_MP64_DECOMPRESSED_SZ;
|
|
|
|
namespace DataSpec::AssetNameMap {
|
|
logvisor::Module Log("AssetNameMap");
|
|
|
|
struct SAsset {
|
|
std::string name;
|
|
std::string directory;
|
|
hecl::FourCC type;
|
|
SAsset() = default;
|
|
SAsset(const hecl::FourCC& typeIn, athena::io::IStreamReader& in) : type(typeIn) {
|
|
uint32_t nameLen = in.readUint32Big();
|
|
name = in.readString(nameLen);
|
|
uint32_t dirLen = in.readUint32Big();
|
|
directory = in.readString(dirLen);
|
|
}
|
|
};
|
|
|
|
static std::unordered_map<uint64_t, SAsset> g_AssetNameMap;
|
|
static bool g_AssetNameMapInit = false;
|
|
|
|
void LoadAssetMap(athena::io::MemoryReader& ar) {
|
|
if (!ar.hasError()) {
|
|
hecl::FourCC magic;
|
|
if (ar.length() >= 4)
|
|
ar.readBytesToBuf(&magic, 4);
|
|
if (magic != FOURCC('AIDM'))
|
|
Log.report(
|
|
logvisor::Warning,
|
|
FMT_STRING("Unable to load asset map; Assets will not have proper filenames for most files."));
|
|
else {
|
|
uint32_t assetCount = ar.readUint32Big();
|
|
g_AssetNameMap.reserve(assetCount);
|
|
for (uint32_t i = 0; i < assetCount; ++i) {
|
|
hecl::FourCC type;
|
|
ar.readBytesToBuf(&type, 4);
|
|
uint64_t id = ar.readUint64Big();
|
|
g_AssetNameMap[id] = SAsset(type, ar);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitAssetNameMap() {
|
|
if (g_AssetNameMapInit)
|
|
return;
|
|
|
|
Log.report(logvisor::Info, FMT_STRING("Initializing asset name database..."));
|
|
|
|
/* First load the 32bit map for MP1/2 */
|
|
if (ASSET_NAME_MP32_DECOMPRESSED_SZ != 0u) {
|
|
auto* decompressed = new uint8_t[ASSET_NAME_MP32_DECOMPRESSED_SZ];
|
|
athena::io::Compression::decompressZlib(ASSET_NAME_MP32, ASSET_NAME_MP32_SZ, decompressed,
|
|
ASSET_NAME_MP32_DECOMPRESSED_SZ);
|
|
athena::io::MemoryReader ar(decompressed, ASSET_NAME_MP32_DECOMPRESSED_SZ);
|
|
LoadAssetMap(ar);
|
|
delete[](decompressed);
|
|
} else {
|
|
Log.report(
|
|
logvisor::Warning,
|
|
FMT_STRING("AssetNameMap32 unavailable; Assets will not have proper filenames for most files."));
|
|
}
|
|
/* Now load the 64bit map for MP3 */
|
|
if (ASSET_NAME_MP64_DECOMPRESSED_SZ != 0u) {
|
|
auto* decompressed = new uint8_t[ASSET_NAME_MP64_DECOMPRESSED_SZ];
|
|
athena::io::Compression::decompressZlib(ASSET_NAME_MP64, ASSET_NAME_MP64_SZ, decompressed,
|
|
ASSET_NAME_MP64_DECOMPRESSED_SZ);
|
|
athena::io::MemoryReader ar(decompressed, ASSET_NAME_MP64_DECOMPRESSED_SZ);
|
|
LoadAssetMap(ar);
|
|
delete[](decompressed);
|
|
} else {
|
|
Log.report(
|
|
logvisor::Warning,
|
|
FMT_STRING("AssetNameMap64 unavailable; Assets will not have proper filenames for most files."));
|
|
}
|
|
g_AssetNameMapInit = true;
|
|
}
|
|
|
|
const std::string* TranslateIdToName(const UniqueID32& id) {
|
|
if (g_AssetNameMap.find(id.toUint64()) == g_AssetNameMap.cend())
|
|
return nullptr;
|
|
|
|
return &g_AssetNameMap[id.toUint64()].name;
|
|
}
|
|
|
|
} // namespace DataSpec::AssetNameMap
|