chore: implement obj loading skeleton with localize asset

This commit is contained in:
Jan
2024-12-23 22:55:58 +01:00
parent 673db0592f
commit c524cb007a
64 changed files with 1238 additions and 1038 deletions

View File

@ -1,17 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/IW3/IW3.h"
#include "SearchPath/ISearchPath.h"
namespace IW3
{
class AssetLoaderGfxImage final : public BasicAssetLoader<AssetImage>
{
public:
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace IW3

View File

@ -1,36 +0,0 @@
#include "AssetLoaderLocalizeEntry.h"
#include "Localize/LocalizeCommonAssetLoader.h"
using namespace IW3;
XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
{
return nullptr;
}
void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
return nullptr;
}
bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderLocalizeEntry::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const LocalizeCommonAssetLoader commonLoader(
[memory, manager](const CommonLocalizeEntry& entry)
{
auto* localizeEntry = memory->Create<LocalizeEntry>();
localizeEntry->name = memory->Dup(entry.m_key.c_str());
localizeEntry->value = memory->Dup(entry.m_value.c_str());
manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
});
return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
}

View File

@ -1,19 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/IW3/IW3.h"
#include "SearchPath/ISearchPath.h"
namespace IW3
{
class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
{
public:
_NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace IW3

View File

@ -1,44 +0,0 @@
#include "AssetLoaderRawFile.h"
#include "Game/IW3/IW3.h"
#include "Pool/GlobalAssetPool.h"
#include <cstring>
using namespace IW3;
void* AssetLoaderRawFile::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
auto* rawFile = memory->Create<RawFile>();
memset(rawFile, 0, sizeof(RawFile));
rawFile->name = memory->Dup(assetName.c_str());
return rawFile;
}
bool AssetLoaderRawFile::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderRawFile::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const auto file = searchPath->Open(assetName);
if (!file.IsOpen())
return false;
auto* rawFile = memory->Create<RawFile>();
rawFile->name = memory->Dup(assetName.c_str());
rawFile->len = static_cast<int>(file.m_length);
auto* fileBuffer = memory->Alloc<char>(static_cast<size_t>(file.m_length + 1));
file.m_stream->read(fileBuffer, file.m_length);
if (file.m_stream->gcount() != file.m_length)
return false;
fileBuffer[rawFile->len] = '\0';
rawFile->buffer = fileBuffer;
manager->AddAsset<AssetRawFile>(assetName, rawFile);
return true;
}

View File

@ -1,17 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/IW3/IW3.h"
#include "SearchPath/ISearchPath.h"
namespace IW3
{
class AssetLoaderRawFile final : public BasicAssetLoader<AssetRawFile>
{
public:
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace IW3

View File

@ -1,4 +1,4 @@
#include "AssetLoaderGfxImage.h"
#include "AssetLoaderImageIW3.h"
#include "Game/IW3/IW3.h"
#include "Image/DdsLoader.h"
@ -12,43 +12,35 @@
using namespace IW3;
void* AssetLoaderGfxImage::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
AssetLoaderImage::AssetLoaderImage(MemoryManager& memory, ISearchPath& searchPath)
: m_memory(memory),
m_search_path(searchPath)
{
auto* image = memory->Create<GfxImage>();
memset(image, 0, sizeof(GfxImage));
image->name = memory->Dup(assetName.c_str());
return image;
}
bool AssetLoaderGfxImage::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderGfxImage::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
AssetCreationResult AssetLoaderImage::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
// Do not load any GfxImages from raw for now that are not loaded
// TODO: Load iwis and add streaming info to asset
if (assetName.empty() || assetName[0] != '*')
return false;
return AssetCreationResult::NoAction();
std::string safeAssetName = assetName;
std::ranges::replace(safeAssetName, '*', '_');
const auto file = searchPath->Open(std::format("images/{}.dds", safeAssetName));
const auto file = m_search_path.Open(std::format("images/{}.dds", safeAssetName));
if (!file.IsOpen())
return false;
return AssetCreationResult::NoAction();
const auto texture = dds::LoadDds(*file.m_stream);
if (!texture)
{
std::cerr << std::format("Failed to load dds file for image asset \"{}\"\n", assetName);
return false;
return AssetCreationResult::Failure();
}
auto* image = memory->Create<GfxImage>();
image->name = memory->Dup(assetName.c_str());
auto* image = m_memory.Alloc<GfxImage>();
image->name = m_memory.Dup(assetName.c_str());
image->picmip.platform[0] = 0;
image->picmip.platform[1] = 0;
image->noPicmip = !texture->HasMipMaps();
@ -88,7 +80,7 @@ bool AssetLoaderGfxImage::LoadFromRaw(
for (auto mipLevel = 0; mipLevel < mipCount; mipLevel++)
dataSize += texture->GetSizeOfMipLevel(mipLevel) * faceCount;
auto* loadDef = static_cast<GfxImageLoadDef*>(zone->GetMemory()->AllocRaw(offsetof(GfxImageLoadDef, data) + dataSize));
auto* loadDef = static_cast<GfxImageLoadDef*>(m_memory.AllocRaw(offsetof(GfxImageLoadDef, data) + dataSize));
image->texture.loadDef = loadDef;
loadDef->levelCount = static_cast<char>(mipCount);
loadDef->flags = 0;
@ -116,7 +108,5 @@ bool AssetLoaderGfxImage::LoadFromRaw(
}
}
manager->AddAsset<AssetImage>(assetName, image);
return true;
return AssetCreationResult::Success(context.AddAsset<AssetImage>(assetName, image));
}

View File

@ -0,0 +1,21 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/IW3/IW3.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
namespace IW3
{
class AssetLoaderImage final : public AssetCreator<AssetImage>
{
public:
AssetLoaderImage(MemoryManager& memory, ISearchPath& searchPath);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
ISearchPath& m_search_path;
};
} // namespace IW3

View File

@ -0,0 +1,16 @@
#include "DefaultCreatorImageIW3.h"
using namespace IW3;
DefaultCreatorImage::DefaultCreatorImage(MemoryManager& memory)
: m_memory(memory)
{
}
AssetCreationResult DefaultCreatorImage::CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const
{
auto* asset = m_memory.Alloc<GfxImage>();
asset->name = m_memory.Dup(assetName.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetImage>(assetName, asset));
}

View File

@ -0,0 +1,18 @@
#pragma once
#include "Asset/IDefaultAssetCreator.h"
#include "Game/IW3/IW3.h"
#include "Utils/MemoryManager.h"
namespace IW3
{
class DefaultCreatorImage : public DefaultAssetCreator<AssetImage>
{
public:
explicit DefaultCreatorImage(MemoryManager& memory);
AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override;
private:
MemoryManager& m_memory;
};
} // namespace IW3

View File

@ -0,0 +1,23 @@
#include "AssetLoaderLocalizeIW3.h"
using namespace IW3;
AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
: CommonLocalizeLoader(searchPath, zone),
m_memory(memory)
{
}
AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
return CreateLocalizeAsset(assetName, context);
}
AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
{
auto* asset = m_memory.Alloc<LocalizeEntry>();
asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
}

View File

@ -0,0 +1,23 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/IW3/IW3.h"
#include "Localize/CommonLocalizeLoader.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
namespace IW3
{
class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
{
public:
AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
protected:
AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
};
} // namespace IW3

View File

@ -1,77 +1,123 @@
#include "ObjLoaderIW3.h"
#include "AssetLoaders/AssetLoaderGfxImage.h"
#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
#include "AssetLoaders/AssetLoaderRawFile.h"
#include "AssetLoading/AssetLoadingManager.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "Game/IW3/GameIW3.h"
#include "Game/IW3/IW3.h"
#include "Image/AssetLoaderImageIW3.h"
#include "Image/DefaultCreatorImageIW3.h"
#include "Localize/AssetLoaderLocalizeIW3.h"
#include "ObjLoading.h"
#include <memory>
using namespace IW3;
ObjLoader::ObjLoader()
{
#define REGISTER_ASSET_LOADER(t) \
{ \
auto l = std::make_unique<t>(); \
m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l); \
}
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysPreset>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXAnim>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXModel>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMaterial>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetTechniqueSet>)
REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSound>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundCurve>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLoadedSound>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMap>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMapPvs>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetComWorld>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldSp>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldMp>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMapEnts>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGfxWorld>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLightDef>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFont>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenuList>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenu>)
REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetWeapon>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundDriverGlobals>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFx>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImpactFx>)
REGISTER_ASSET_LOADER(AssetLoaderRawFile)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetStringTable>)
#undef REGISTER_ASSET_LOADER
}
bool ObjLoader::IsMpZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
}
bool ObjLoader::IsZmZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
}
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
namespace
{
AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = *zone.GetMemory();
void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
}
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = *zone.GetMemory();
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory, searchPath));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
{
for (const auto& [type, loader] : m_asset_loaders_by_type)
loader->FinalizeAssetsForZone(context);
ConfigureDefaultCreators(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}

View File

@ -1,30 +1,16 @@
#pragma once
#include "AssetLoading/IAssetLoader.h"
#include "IObjLoader.h"
#include "SearchPath/ISearchPath.h"
#include <memory>
#include <unordered_map>
namespace IW3
{
class ObjLoader final : public IObjLoader
{
std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
static bool IsMpZone(const Zone& zone);
static bool IsZmZone(const Zone& zone);
public:
ObjLoader();
void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
void UnloadContainersOfZone(Zone& zone) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
};
} // namespace IW3

View File

@ -0,0 +1,35 @@
#include "AssetLoaderRawFileIW3.h"
#include "Game/IW3/IW3.h"
#include "Pool/GlobalAssetPool.h"
#include <cstring>
using namespace IW3;
AssetLoaderRawFile::AssetLoaderRawFile(MemoryManager& memory, ISearchPath& searchPath)
: m_memory(memory),
m_search_path(searchPath)
{
}
AssetCreationResult AssetLoaderRawFile::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
const auto file = m_search_path.Open(assetName);
if (!file.IsOpen())
return AssetCreationResult::NoAction();
auto* rawFile = m_memory.Alloc<RawFile>();
rawFile->name = m_memory.Dup(assetName.c_str());
rawFile->len = static_cast<int>(file.m_length);
auto* fileBuffer = m_memory.Alloc<char>(static_cast<size_t>(file.m_length + 1));
file.m_stream->read(fileBuffer, file.m_length);
if (file.m_stream->gcount() != file.m_length)
return AssetCreationResult::Failure();
fileBuffer[rawFile->len] = '\0';
rawFile->buffer = fileBuffer;
return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, rawFile));
}

View File

@ -0,0 +1,21 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/IW3/IW3.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
namespace IW3
{
class AssetLoaderRawFile final : public AssetCreator<AssetRawFile>
{
public:
AssetLoaderRawFile(MemoryManager& memory, ISearchPath& searchPath);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
ISearchPath& m_search_path;
};
} // namespace IW3

View File

@ -0,0 +1,16 @@
#include "DefaultCreatorRawFileIW3.h"
using namespace IW3;
DefaultCreatorRawFile::DefaultCreatorRawFile(MemoryManager& memory)
: m_memory(memory)
{
}
AssetCreationResult DefaultCreatorRawFile::CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const
{
auto* asset = m_memory.Alloc<RawFile>();
asset->name = m_memory.Dup(assetName.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, asset));
}

View File

@ -0,0 +1,18 @@
#pragma once
#include "Asset/IDefaultAssetCreator.h"
#include "Game/IW3/IW3.h"
#include "Utils/MemoryManager.h"
namespace IW3
{
class DefaultCreatorRawFile : public DefaultAssetCreator<AssetRawFile>
{
public:
explicit DefaultCreatorRawFile(MemoryManager& memory);
AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override;
private:
MemoryManager& m_memory;
};
} // namespace IW3

View File

@ -1,36 +0,0 @@
#include "AssetLoaderLocalizeEntry.h"
#include "Localize/LocalizeCommonAssetLoader.h"
using namespace IW4;
XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
{
return nullptr;
}
void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
return nullptr;
}
bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderLocalizeEntry::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const LocalizeCommonAssetLoader commonLoader(
[memory, manager](const CommonLocalizeEntry& entry)
{
auto* localizeEntry = memory->Create<LocalizeEntry>();
localizeEntry->name = memory->Dup(entry.m_key.c_str());
localizeEntry->value = memory->Dup(entry.m_value.c_str());
manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
});
return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
}

View File

@ -1,19 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/IW4/IW4.h"
#include "SearchPath/ISearchPath.h"
namespace IW4
{
class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
{
public:
_NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace IW4

View File

@ -0,0 +1,23 @@
#include "AssetLoaderLocalizeIW4.h"
using namespace IW4;
AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
: CommonLocalizeLoader(searchPath, zone),
m_memory(memory)
{
}
AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
return CreateLocalizeAsset(assetName, context);
}
AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
{
auto* asset = m_memory.Alloc<LocalizeEntry>();
asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
}

View File

@ -0,0 +1,25 @@
#pragma once
#include "Asset/AssetCreationContext.h"
#include "Asset/IAssetCreator.h"
#include "Game/IW4/IW4.h"
#include "Localize/CommonLocalizeLoader.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include "Zone/Zone.h"
namespace IW4
{
class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
{
public:
AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
protected:
AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
};
} // namespace IW4

View File

@ -1,121 +1,150 @@
#include "ObjLoaderIW4.h"
#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
#include "AssetLoaders/AssetLoaderClipMap.h"
#include "AssetLoaders/AssetLoaderComWorld.h"
#include "AssetLoaders/AssetLoaderFont.h"
#include "AssetLoaders/AssetLoaderFx.h"
#include "AssetLoaders/AssetLoaderFxImpactTable.h"
#include "AssetLoaders/AssetLoaderFxWorld.h"
#include "AssetLoaders/AssetLoaderGameWorldMp.h"
#include "AssetLoaders/AssetLoaderGameWorldSp.h"
#include "AssetLoaders/AssetLoaderGfxImage.h"
#include "AssetLoaders/AssetLoaderGfxLightDef.h"
#include "AssetLoaders/AssetLoaderGfxWorld.h"
#include "AssetLoaders/AssetLoaderLeaderboard.h"
#include "AssetLoaders/AssetLoaderLoadedSound.h"
#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
#include "AssetLoaders/AssetLoaderMapEnts.h"
#include "AssetLoaders/AssetLoaderMaterial.h"
#include "AssetLoaders/AssetLoaderMenuDef.h"
#include "AssetLoaders/AssetLoaderMenuList.h"
#include "AssetLoaders/AssetLoaderPhysCollmap.h"
#include "AssetLoaders/AssetLoaderPhysPreset.h"
#include "AssetLoaders/AssetLoaderPixelShader.h"
#include "AssetLoaders/AssetLoaderRawFile.h"
#include "AssetLoaders/AssetLoaderSndCurve.h"
#include "AssetLoaders/AssetLoaderSoundAliasList.h"
#include "AssetLoaders/AssetLoaderStringTable.h"
#include "AssetLoaders/AssetLoaderStructuredDataDefSet.h"
#include "AssetLoaders/AssetLoaderTechniqueSet.h"
#include "AssetLoaders/AssetLoaderTracer.h"
#include "AssetLoaders/AssetLoaderVehicle.h"
#include "AssetLoaders/AssetLoaderVertexDecl.h"
#include "AssetLoaders/AssetLoaderVertexShader.h"
#include "AssetLoaders/AssetLoaderWeapon.h"
#include "AssetLoaders/AssetLoaderXAnim.h"
#include "AssetLoaders/AssetLoaderXModel.h"
#include "AssetLoaders/AssetLoaderXModelSurfs.h"
#include "AssetLoading/AssetLoadingManager.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "Game/IW4/GameIW4.h"
#include "Image/IwiLoader.h"
#include "ObjContainer/IPak/IPak.h"
#include "Game/IW4/IW4.h"
#include "Localize/AssetLoaderLocalizeIW4.h"
#include "ObjLoading.h"
#include <memory>
using namespace IW4;
ObjLoader::ObjLoader()
{
#define REGISTER_ASSET_LOADER(t) \
{ \
auto l = std::make_unique<t>(); \
m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l); \
}
REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
REGISTER_ASSET_LOADER(AssetLoaderPhysCollmap)
REGISTER_ASSET_LOADER(AssetLoaderXAnim)
REGISTER_ASSET_LOADER(AssetLoaderXModelSurfs)
REGISTER_ASSET_LOADER(AssetLoaderXModel)
REGISTER_ASSET_LOADER(AssetLoaderMaterial)
REGISTER_ASSET_LOADER(AssetLoaderPixelShader)
REGISTER_ASSET_LOADER(AssetLoaderVertexShader)
REGISTER_ASSET_LOADER(AssetLoaderVertexDecl)
REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
REGISTER_ASSET_LOADER(AssetLoaderSoundAliasList)
REGISTER_ASSET_LOADER(AssetLoaderSndCurve)
REGISTER_ASSET_LOADER(AssetLoaderLoadedSound)
REGISTER_ASSET_LOADER(AssetLoaderClipMapSp)
REGISTER_ASSET_LOADER(AssetLoaderClipMapMp)
REGISTER_ASSET_LOADER(AssetLoaderComWorld)
REGISTER_ASSET_LOADER(AssetLoaderGameWorldSp)
REGISTER_ASSET_LOADER(AssetLoaderGameWorldMp)
REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
REGISTER_ASSET_LOADER(AssetLoaderFxWorld)
REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
REGISTER_ASSET_LOADER(AssetLoaderFont)
REGISTER_ASSET_LOADER(AssetLoaderMenuList)
REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
REGISTER_ASSET_LOADER(AssetLoaderWeapon)
REGISTER_ASSET_LOADER(AssetLoaderFx)
REGISTER_ASSET_LOADER(AssetLoaderFxImpactTable)
REGISTER_ASSET_LOADER(AssetLoaderRawFile)
REGISTER_ASSET_LOADER(AssetLoaderStringTable)
REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
REGISTER_ASSET_LOADER(AssetLoaderStructuredDataDefSet)
REGISTER_ASSET_LOADER(AssetLoaderTracer)
REGISTER_ASSET_LOADER(AssetLoaderVehicle)
REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
#undef REGISTER_ASSET_LOADER
}
bool ObjLoader::IsMpZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
}
bool ObjLoader::IsZmZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
}
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const
namespace
{
AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = *zone.GetMemory();
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysCollMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModelSurfs>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPixelShader>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexShader>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexDecl>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapSp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapMp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLeaderboard>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStructuredDataDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTracer>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicle>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAddonMapEnts>(memory));
}
void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysCollMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModelSurfs>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPixelShader>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexShader>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexDecl>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStructuredDataDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = *zone.GetMemory();
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysCollMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPixelShader>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVertexShader>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVertexDecl>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapSp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapMp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStructuredDataDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
{
for (const auto& [type, loader] : m_asset_loaders_by_type)
loader->FinalizeAssetsForZone(context);
ConfigureDefaultCreators(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}

View File

@ -3,29 +3,16 @@
#include "AssetLoading/IAssetLoader.h"
#include "IObjLoader.h"
#include "SearchPath/ISearchPath.h"
#include <memory>
#include <unordered_map>
#include "Zone/Zone.h"
namespace IW4
{
class ObjLoader final : public IObjLoader
{
public:
ObjLoader();
void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
void UnloadContainersOfZone(Zone& zone) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
private:
static bool IsMpZone(const Zone& zone);
static bool IsZmZone(const Zone& zone);
std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
};
} // namespace IW4

View File

@ -1,36 +0,0 @@
#include "AssetLoaderLocalizeEntry.h"
#include "Localize/LocalizeCommonAssetLoader.h"
using namespace IW5;
XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
{
return nullptr;
}
void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
return nullptr;
}
bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderLocalizeEntry::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const LocalizeCommonAssetLoader commonLoader(
[memory, manager](const CommonLocalizeEntry& entry)
{
auto* localizeEntry = memory->Create<LocalizeEntry>();
localizeEntry->name = memory->Dup(entry.m_key.c_str());
localizeEntry->value = memory->Dup(entry.m_value.c_str());
manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
});
return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
}

View File

@ -1,19 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/IW5/IW5.h"
#include "SearchPath/ISearchPath.h"
namespace IW5
{
class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
{
public:
_NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace IW5

View File

@ -0,0 +1,23 @@
#include "AssetLoaderLocalizeIW5.h"
using namespace IW5;
AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
: CommonLocalizeLoader(searchPath, zone),
m_memory(memory)
{
}
AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
return CreateLocalizeAsset(assetName, context);
}
AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
{
auto* asset = m_memory.Alloc<LocalizeEntry>();
asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
}

View File

@ -0,0 +1,25 @@
#pragma once
#include "Asset/AssetCreationContext.h"
#include "Asset/IAssetCreator.h"
#include "Game/IW5/IW5.h"
#include "Localize/CommonLocalizeLoader.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include "Zone/Zone.h"
namespace IW5
{
class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
{
public:
AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
protected:
AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
};
} // namespace IW5

View File

@ -1,128 +1,158 @@
#include "ObjLoaderIW5.h"
#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
#include "AssetLoaders/AssetLoaderClipMap.h"
#include "AssetLoaders/AssetLoaderComWorld.h"
#include "AssetLoaders/AssetLoaderFont.h"
#include "AssetLoaders/AssetLoaderFx.h"
#include "AssetLoaders/AssetLoaderFxImpactTable.h"
#include "AssetLoaders/AssetLoaderFxWorld.h"
#include "AssetLoaders/AssetLoaderGfxImage.h"
#include "AssetLoaders/AssetLoaderGfxLightDef.h"
#include "AssetLoaders/AssetLoaderGfxWorld.h"
#include "AssetLoaders/AssetLoaderGlassWorld.h"
#include "AssetLoaders/AssetLoaderLeaderboard.h"
#include "AssetLoaders/AssetLoaderLoadedSound.h"
#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
#include "AssetLoaders/AssetLoaderMapEnts.h"
#include "AssetLoaders/AssetLoaderMaterial.h"
#include "AssetLoaders/AssetLoaderMenuDef.h"
#include "AssetLoaders/AssetLoaderMenuList.h"
#include "AssetLoaders/AssetLoaderPathData.h"
#include "AssetLoaders/AssetLoaderPhysCollmap.h"
#include "AssetLoaders/AssetLoaderPhysPreset.h"
#include "AssetLoaders/AssetLoaderPixelShader.h"
#include "AssetLoaders/AssetLoaderRawFile.h"
#include "AssetLoaders/AssetLoaderScriptFile.h"
#include "AssetLoaders/AssetLoaderSoundAliasList.h"
#include "AssetLoaders/AssetLoaderSoundCurve.h"
#include "AssetLoaders/AssetLoaderStringTable.h"
#include "AssetLoaders/AssetLoaderStructuredDataDef.h"
#include "AssetLoaders/AssetLoaderSurfaceFxTable.h"
#include "AssetLoaders/AssetLoaderTechniqueSet.h"
#include "AssetLoaders/AssetLoaderTracerDef.h"
#include "AssetLoaders/AssetLoaderVehicleDef.h"
#include "AssetLoaders/AssetLoaderVehicleTrack.h"
#include "AssetLoaders/AssetLoaderVertexDecl.h"
#include "AssetLoaders/AssetLoaderVertexShader.h"
#include "AssetLoaders/AssetLoaderWeapon.h"
#include "AssetLoaders/AssetLoaderWeaponAttachment.h"
#include "AssetLoaders/AssetLoaderXAnim.h"
#include "AssetLoaders/AssetLoaderXModel.h"
#include "AssetLoaders/AssetLoaderXModelSurfs.h"
#include "AssetLoading/AssetLoadingManager.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "Game/IW5/GameIW5.h"
#include "Image/IwiLoader.h"
#include "ObjContainer/IPak/IPak.h"
#include "Game/IW5/IW5.h"
#include "Localize/AssetLoaderLocalizeIW5.h"
#include "ObjLoading.h"
#include <memory>
using namespace IW5;
ObjLoader::ObjLoader()
{
#define REGISTER_ASSET_LOADER(t) \
{ \
auto l = std::make_unique<t>(); \
m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l); \
}
REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
REGISTER_ASSET_LOADER(AssetLoaderPhysCollmap)
REGISTER_ASSET_LOADER(AssetLoaderXAnim)
REGISTER_ASSET_LOADER(AssetLoaderXModelSurfs)
REGISTER_ASSET_LOADER(AssetLoaderXModel)
REGISTER_ASSET_LOADER(AssetLoaderMaterial)
REGISTER_ASSET_LOADER(AssetLoaderPixelShader)
REGISTER_ASSET_LOADER(AssetLoaderVertexShader)
REGISTER_ASSET_LOADER(AssetLoaderVertexDecl)
REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
REGISTER_ASSET_LOADER(AssetLoaderSoundAliasList)
REGISTER_ASSET_LOADER(AssetLoaderSoundCurve)
REGISTER_ASSET_LOADER(AssetLoaderLoadedSound)
REGISTER_ASSET_LOADER(AssetLoaderClipMap)
REGISTER_ASSET_LOADER(AssetLoaderComWorld)
REGISTER_ASSET_LOADER(AssetLoaderGlassWorld)
REGISTER_ASSET_LOADER(AssetLoaderPathData)
REGISTER_ASSET_LOADER(AssetLoaderVehicleTrack)
REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
REGISTER_ASSET_LOADER(AssetLoaderFxWorld)
REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
REGISTER_ASSET_LOADER(AssetLoaderFont)
REGISTER_ASSET_LOADER(AssetLoaderMenuList)
REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachment)
REGISTER_ASSET_LOADER(AssetLoaderWeapon)
REGISTER_ASSET_LOADER(AssetLoaderFx)
REGISTER_ASSET_LOADER(AssetLoaderFxImpactTable)
REGISTER_ASSET_LOADER(AssetLoaderSurfaceFxTable)
REGISTER_ASSET_LOADER(AssetLoaderRawFile)
REGISTER_ASSET_LOADER(AssetLoaderScriptFile)
REGISTER_ASSET_LOADER(AssetLoaderStringTable)
REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
REGISTER_ASSET_LOADER(AssetLoaderStructuredDataDef)
REGISTER_ASSET_LOADER(AssetLoaderTracerDef)
REGISTER_ASSET_LOADER(AssetLoaderVehicleDef)
REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
#undef REGISTER_ASSET_LOADER
}
bool ObjLoader::IsMpZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
}
bool ObjLoader::IsZmZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
}
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
namespace
{
AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = *zone.GetMemory();
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysCollMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModelSurfs>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPixelShader>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexShader>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexDecl>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlassWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPathData>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicleTrack>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAttachment>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSurfaceFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorScript>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLeaderboard>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStructuredDataDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTracer>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicle>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAddonMapEnts>(memory));
}
void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysCollMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModelSurfs>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPixelShader>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexShader>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexDecl>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlassWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPathData>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicleTrack>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachment>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSurfaceFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetScript>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStructuredDataDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = *zone.GetMemory();
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysCollMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPixelShader>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVertexShader>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVertexDecl>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGlassWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPathData>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVehicleTrack>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAttachment>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSurfaceFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderScript>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStructuredDataDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
{
for (const auto& [type, loader] : m_asset_loaders_by_type)
loader->FinalizeAssetsForZone(context);
ConfigureDefaultCreators(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}

View File

@ -4,28 +4,14 @@
#include "IObjLoader.h"
#include "SearchPath/ISearchPath.h"
#include <memory>
#include <unordered_map>
namespace IW5
{
class ObjLoader final : public IObjLoader
{
public:
ObjLoader();
void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
void UnloadContainersOfZone(Zone& zone) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
private:
static bool IsMpZone(const Zone& zone);
static bool IsZmZone(const Zone& zone);
std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
};
} // namespace IW5

View File

@ -1,36 +0,0 @@
#include "AssetLoaderLocalizeEntry.h"
#include "Localize/LocalizeCommonAssetLoader.h"
using namespace T5;
XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
{
return nullptr;
}
void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
return nullptr;
}
bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderLocalizeEntry::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const LocalizeCommonAssetLoader commonLoader(
[memory, manager](const CommonLocalizeEntry& entry)
{
auto* localizeEntry = memory->Create<LocalizeEntry>();
localizeEntry->name = memory->Dup(entry.m_key.c_str());
localizeEntry->value = memory->Dup(entry.m_value.c_str());
manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
});
return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
}

View File

@ -1,19 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/T5/T5.h"
#include "SearchPath/ISearchPath.h"
namespace T5
{
class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
{
public:
_NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace T5

View File

@ -0,0 +1,23 @@
#include "AssetLoaderLocalizeT5.h"
using namespace T5;
AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
: CommonLocalizeLoader(searchPath, zone),
m_memory(memory)
{
}
AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
return CreateLocalizeAsset(assetName, context);
}
AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
{
auto* asset = m_memory.Alloc<LocalizeEntry>();
asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
}

View File

@ -0,0 +1,25 @@
#pragma once
#include "Asset/AssetCreationContext.h"
#include "Asset/IAssetCreator.h"
#include "Game/T5/T5.h"
#include "Localize/CommonLocalizeLoader.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include "Zone/Zone.h"
namespace T5
{
class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
{
public:
AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
protected:
AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
};
} // namespace T5

View File

@ -1,85 +1,137 @@
#include "ObjLoaderT5.h"
#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
#include "AssetLoaders/AssetLoaderRawFile.h"
#include "AssetLoaders/AssetLoaderStringTable.h"
#include "AssetLoaders/AssetLoaderXModel.h"
#include "AssetLoading/AssetLoadingManager.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "Game/T5/GameT5.h"
#include "Image/IwiLoader.h"
#include "ObjContainer/IPak/IPak.h"
#include "Game/T5/T5.h"
#include "Localize/AssetLoaderLocalizeT5.h"
#include "ObjLoading.h"
#include <memory>
using namespace T5;
ObjLoader::ObjLoader()
{
#define REGISTER_ASSET_LOADER(t) \
{ \
auto l = std::make_unique<t>(); \
m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l); \
}
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysPreset>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysConstraints>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDestructibleDef>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXAnim>)
REGISTER_ASSET_LOADER(AssetLoaderXModel)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMaterial>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetTechniqueSet>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImage>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundBank>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundPatch>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMap>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMapPvs>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetComWorld>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldSp>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldMp>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMapEnts>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGfxWorld>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLightDef>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFont>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenuList>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenu>)
REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetWeapon>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundDriverGlobals>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFx>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImpactFx>)
REGISTER_ASSET_LOADER(AssetLoaderRawFile)
REGISTER_ASSET_LOADER(AssetLoaderStringTable)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPackIndex>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXGlobals>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDDL>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGlasses>)
REGISTER_ASSET_LOADER(BasicAssetLoader<AssetEmblemSet>)
#undef REGISTER_ASSET_LOADER
}
bool ObjLoader::IsMpZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
}
bool ObjLoader::IsZmZone(const Zone& zone)
{
return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
}
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const
namespace
{
AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = *zone.GetMemory();
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysConstraints>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDestructibleDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundBank>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundPatch>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPackIndex>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXGlobals>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDDL>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlasses>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorEmblemSet>(memory));
}
void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysConstraints>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDestructibleDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundBank>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundPatch>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPackIndex>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXGlobals>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDDL>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlasses>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetEmblemSet>>(zone));
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = *zone.GetMemory();
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysConstraints>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderDestructibleDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundBank>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundPatch>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPackIndex>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXGlobals>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderDDL>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGlasses>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderEmblemSet>(memory));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
{
for (const auto& [type, loader] : m_asset_loaders_by_type)
loader->FinalizeAssetsForZone(context);
ConfigureDefaultCreators(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}

View File

@ -4,28 +4,14 @@
#include "IObjLoader.h"
#include "SearchPath/ISearchPath.h"
#include <memory>
#include <unordered_map>
namespace T5
{
class ObjLoader final : public IObjLoader
{
public:
ObjLoader();
void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
void UnloadContainersOfZone(Zone& zone) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
private:
static bool IsMpZone(const Zone& zone);
static bool IsZmZone(const Zone& zone);
std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
};
} // namespace T5

View File

@ -1,36 +0,0 @@
#include "AssetLoaderLocalizeEntry.h"
#include "Localize/LocalizeCommonAssetLoader.h"
using namespace T6;
XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
{
return nullptr;
}
void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
{
return nullptr;
}
bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
{
return true;
}
bool AssetLoaderLocalizeEntry::LoadFromRaw(
const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
{
const LocalizeCommonAssetLoader commonLoader(
[memory, manager](const CommonLocalizeEntry& entry)
{
auto* localizeEntry = memory->Create<LocalizeEntry>();
localizeEntry->name = memory->Dup(entry.m_key.c_str());
localizeEntry->value = memory->Dup(entry.m_value.c_str());
manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
});
return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
}

View File

@ -1,18 +0,0 @@
#pragma once
#include "AssetLoading/BasicAssetLoader.h"
#include "AssetLoading/IAssetLoadingManager.h"
#include "Game/T6/T6.h"
#include "SearchPath/ISearchPath.h"
namespace T6
{
class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
{
public:
_NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
_NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
_NODISCARD bool CanLoadFromRaw() const override;
bool
LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
};
} // namespace T6

View File

@ -0,0 +1,23 @@
#include "AssetLoaderLocalizeT6.h"
using namespace T6;
AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
: CommonLocalizeLoader(searchPath, zone),
m_memory(memory)
{
}
AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
{
return CreateLocalizeAsset(assetName, context);
}
AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
{
auto* asset = m_memory.Alloc<LocalizeEntry>();
asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
}

View File

@ -0,0 +1,25 @@
#pragma once
#include "Asset/AssetCreationContext.h"
#include "Asset/IAssetCreator.h"
#include "Game/T6/T6.h"
#include "Localize/CommonLocalizeLoader.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include "Zone/Zone.h"
namespace T6
{
class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
{
public:
AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
protected:
AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
private:
MemoryManager& m_memory;
};
} // namespace T6

View File

@ -1,130 +1,27 @@
#include "ObjLoaderT6.h"
#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
#include "AssetLoaders/AssetLoaderClipMap.h"
#include "AssetLoaders/AssetLoaderComWorld.h"
#include "AssetLoaders/AssetLoaderDDL.h"
#include "AssetLoaders/AssetLoaderDestructibleDef.h"
#include "AssetLoaders/AssetLoaderEmblemSet.h"
#include "AssetLoaders/AssetLoaderFont.h"
#include "AssetLoaders/AssetLoaderFontIcon.h"
#include "AssetLoaders/AssetLoaderFootstepFxTable.h"
#include "AssetLoaders/AssetLoaderFootstepTable.h"
#include "AssetLoaders/AssetLoaderFx.h"
#include "AssetLoaders/AssetLoaderGameWorldMp.h"
#include "AssetLoaders/AssetLoaderGameWorldSp.h"
#include "AssetLoaders/AssetLoaderGfxImage.h"
#include "AssetLoaders/AssetLoaderGfxLightDef.h"
#include "AssetLoaders/AssetLoaderGfxWorld.h"
#include "AssetLoaders/AssetLoaderGlasses.h"
#include "AssetLoaders/AssetLoaderImpactFx.h"
#include "AssetLoaders/AssetLoaderLeaderboard.h"
#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
#include "AssetLoaders/AssetLoaderMapEnts.h"
#include "AssetLoaders/AssetLoaderMaterial.h"
#include "AssetLoaders/AssetLoaderMemoryBlock.h"
#include "AssetLoaders/AssetLoaderMenu.h"
#include "AssetLoaders/AssetLoaderMenuList.h"
#include "AssetLoaders/AssetLoaderPhysConstraints.h"
#include "AssetLoaders/AssetLoaderPhysPreset.h"
#include "AssetLoaders/AssetLoaderQdb.h"
#include "AssetLoaders/AssetLoaderRawFile.h"
#include "AssetLoaders/AssetLoaderScriptParseTree.h"
#include "AssetLoaders/AssetLoaderSkinnedVerts.h"
#include "AssetLoaders/AssetLoaderSlug.h"
#include "AssetLoaders/AssetLoaderSoundBank.h"
#include "AssetLoaders/AssetLoaderSoundDriverGlobals.h"
#include "AssetLoaders/AssetLoaderSoundPatch.h"
#include "AssetLoaders/AssetLoaderStringTable.h"
#include "AssetLoaders/AssetLoaderTechniqueSet.h"
#include "AssetLoaders/AssetLoaderTracer.h"
#include "AssetLoaders/AssetLoaderVehicle.h"
#include "AssetLoaders/AssetLoaderWeapon.h"
#include "AssetLoaders/AssetLoaderWeaponAttachment.h"
#include "AssetLoaders/AssetLoaderWeaponAttachmentUnique.h"
#include "AssetLoaders/AssetLoaderWeaponCamo.h"
#include "AssetLoaders/AssetLoaderXAnim.h"
#include "AssetLoaders/AssetLoaderXGlobals.h"
#include "AssetLoaders/AssetLoaderXModel.h"
#include "AssetLoaders/AssetLoaderZBarrier.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "AssetLoading/AssetLoadingManager.h"
#include "Game/T6/CommonT6.h"
#include "Game/T6/GameAssetPoolT6.h"
#include "Game/T6/GameT6.h"
#include "Game/T6/T6.h"
#include "Image/Dx12TextureLoader.h"
#include "Image/IwiLoader.h"
#include "Image/IwiTypes.h"
#include "Image/Texture.h"
#include "Localize/AssetLoaderLocalizeT6.h"
#include "ObjContainer/IPak/IPak.h"
#include "ObjLoading.h"
#include <format>
#include <memory>
namespace T6
{
constexpr auto IPAK_READ_HASH = Common::Com_HashKey("ipak_read", 64);
constexpr auto GLOBAL_HASH = Common::Com_HashKey("GLOBAL", 64);
ObjLoader::ObjLoader()
{
#define REGISTER_ASSET_LOADER(t) \
{ \
auto l = std::make_unique<t>(); \
m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l); \
}
REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
REGISTER_ASSET_LOADER(AssetLoaderPhysConstraints)
REGISTER_ASSET_LOADER(AssetLoaderDestructibleDef)
REGISTER_ASSET_LOADER(AssetLoaderXAnim)
REGISTER_ASSET_LOADER(AssetLoaderXModel)
REGISTER_ASSET_LOADER(AssetLoaderMaterial)
REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
REGISTER_ASSET_LOADER(AssetLoaderSoundBank)
REGISTER_ASSET_LOADER(AssetLoaderSoundPatch)
REGISTER_ASSET_LOADER(AssetLoaderClipMap)
REGISTER_ASSET_LOADER(AssetLoaderClipMapPvs)
REGISTER_ASSET_LOADER(AssetLoaderComWorld)
REGISTER_ASSET_LOADER(AssetLoaderGameWorldSp)
REGISTER_ASSET_LOADER(AssetLoaderGameWorldMp)
REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
REGISTER_ASSET_LOADER(AssetLoaderFont)
REGISTER_ASSET_LOADER(AssetLoaderFontIcon)
REGISTER_ASSET_LOADER(AssetLoaderMenuList)
REGISTER_ASSET_LOADER(AssetLoaderMenu)
REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
REGISTER_ASSET_LOADER(AssetLoaderWeapon)
REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachment)
REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachmentUnique)
REGISTER_ASSET_LOADER(AssetLoaderWeaponCamo)
REGISTER_ASSET_LOADER(AssetLoaderSoundDriverGlobals)
REGISTER_ASSET_LOADER(AssetLoaderFx)
REGISTER_ASSET_LOADER(AssetLoaderImpactFx)
REGISTER_ASSET_LOADER(AssetLoaderRawFile)
REGISTER_ASSET_LOADER(AssetLoaderStringTable)
REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
REGISTER_ASSET_LOADER(AssetLoaderXGlobals)
REGISTER_ASSET_LOADER(AssetLoaderDDL)
REGISTER_ASSET_LOADER(AssetLoaderGlasses)
REGISTER_ASSET_LOADER(AssetLoaderEmblemSet)
REGISTER_ASSET_LOADER(AssetLoaderScriptParseTree)
REGISTER_ASSET_LOADER(AssetLoaderVehicle)
REGISTER_ASSET_LOADER(AssetLoaderMemoryBlock)
REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
REGISTER_ASSET_LOADER(AssetLoaderTracer)
REGISTER_ASSET_LOADER(AssetLoaderSkinnedVerts)
REGISTER_ASSET_LOADER(AssetLoaderQdb)
REGISTER_ASSET_LOADER(AssetLoaderSlug)
REGISTER_ASSET_LOADER(AssetLoaderFootstepTable)
REGISTER_ASSET_LOADER(AssetLoaderFootstepFxTable)
REGISTER_ASSET_LOADER(AssetLoaderZBarrier)
#undef REGISTER_ASSET_LOADER
}
bool ObjLoader::VerifySoundBankChecksum(const SoundBank& soundBank, const SndRuntimeAssetBank& sndRuntimeAssetBank)
{
SoundAssetBankChecksum checksum{};
@ -356,17 +253,155 @@ namespace T6
IPak::Repository.RemoveContainerReferences(&zone);
}
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
namespace
{
AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = *zone.GetMemory();
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysConstraints>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDestructibleDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundBank>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundPatch>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPackIndex>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXGlobals>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDDL>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlasses>(memory));
// collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorEmblemSet>(memory));
}
void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysConstraints>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDestructibleDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundBank>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundPatch>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFontIcon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachment>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachmentUnique>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeaponCamo>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXGlobals>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDDL>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlasses>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetEmblemSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetScript>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMemoryBlock>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSkinnedVerts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetQdb>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSlug>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFootstepTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFootstepFxTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetZBarrier>>(zone));
}
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = *zone.GetMemory();
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderPhysConstraints>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderDestructibleDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundBank>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundPatch>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFontIcon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAttachment>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAttachmentUnique>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderWeaponCamo>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderXGlobals>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderDDL>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderGlasses>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderEmblemSet>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderScript>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderMemoryBlock>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSkinnedVerts>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderQdb>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderSlug>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFootstepTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderFootstepFxTable>(memory));
// collection.AddAssetCreator(std::make_unique<AssetLoaderZBarrier>(memory));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
{
for (const auto& [type, loader] : m_asset_loaders_by_type)
loader->FinalizeAssetsForZone(context);
ConfigureDefaultCreators(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}
} // namespace T6

View File

@ -10,22 +10,16 @@
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
namespace T6
{
class ObjLoader final : public IObjLoader
{
public:
ObjLoader();
void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
void UnloadContainersOfZone(Zone& zone) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
private:
static bool VerifySoundBankChecksum(const SoundBank& soundBank, const SndRuntimeAssetBank& sndRuntimeAssetBank);
@ -43,7 +37,5 @@ namespace T6
static bool IsMpZone(const Zone& zone);
static bool IsZmZone(const Zone& zone);
std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
};
} // namespace T6