INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-07 21:38:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #174 from Laupetin/feature/normalized-asset-names

Browse Source 
feat: normalize asset names
This commit is contained in:
Jan 2024-04-22 19:54:11 +02:00 committed by GitHub
commit 7d920e1060
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 79 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/ObjLoading/AssetLoading/AssetLoadingManager.cpp
View File

@ -1,5 +1,9 @@
#include "AssetLoadingManager.h" #include "AssetLoadingManager.h"
#include "Utils/StringUtils.h"
#include <algorithm>
#include <format>
#include <iostream> #include <iostream>
AssetLoadingManager::AssetLoadingManager(const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& assetLoadersByType, AssetLoadingContext& context) AssetLoadingManager::AssetLoadingManager(const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& assetLoadersByType, AssetLoadingContext& context)
@ -26,31 +30,11 @@ XAssetInfoGeneric* AssetLoadingManager::AddAssetInternal(std::unique_ptr<XAssetI
m_last_dependency_loaded = m_context.m_zone->m_pools->AddAsset(std::move(xAssetInfo)); m_last_dependency_loaded = m_context.m_zone->m_pools->AddAsset(std::move(xAssetInfo));
if (m_last_dependency_loaded == nullptr) if (m_last_dependency_loaded == nullptr)
std::cout << "Failed to add asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\" to pool: \"" << pAssetName << "\"\n"; std::cerr << "Failed to add asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\" to pool: \"" << pAssetName << "\"\n";
return m_last_dependency_loaded; return m_last_dependency_loaded;
} }
XAssetInfoGeneric* AssetLoadingManager::AddAsset(const asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings)
{
return AddAsset(std::make_unique<XAssetInfoGeneric>(assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings)));
}
XAssetInfoGeneric* AssetLoadingManager::AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences)
{
return AddAsset(std::make_unique<XAssetInfoGeneric>(
assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings), std::move(indirectAssetReferences)));
}
XAssetInfoGeneric* AssetLoadingManager::AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) XAssetInfoGeneric* AssetLoadingManager::AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo)
{ {
xAssetInfo->m_zone = m_context.m_zone; xAssetInfo->m_zone = m_context.m_zone;
@ -66,7 +50,8 @@ XAssetInfoGeneric* AssetLoadingManager::LoadIgnoredDependency(const asset_type_t
auto* linkAsset = loader->CreateEmptyAsset(assetName, m_context.m_zone->GetMemory()); auto* linkAsset = loader->CreateEmptyAsset(assetName, m_context.m_zone->GetMemory());
if (linkAsset) if (linkAsset)
{ {
AddAsset(assetType, assetName, linkAsset, std::vector<XAssetInfoGeneric*>(), std::vector<scr_string_t>()); IAssetLoadingManager::AddAsset(
assetType, assetName, linkAsset, std::vector<XAssetInfoGeneric*>(), std::vector<scr_string_t>(), std::vector<IndirectAssetReference>());
auto* lastDependency = m_last_dependency_loaded; auto* lastDependency = m_last_dependency_loaded;
m_last_dependency_loaded = nullptr; m_last_dependency_loaded = nullptr;
return lastDependency; return lastDependency;
@ -81,11 +66,11 @@ XAssetInfoGeneric* AssetLoadingManager::LoadIgnoredDependency(const asset_type_t
return lastDependency; return lastDependency;
} }
std::cout << "Failed to create empty asset \"" << assetName << "\" for type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n"; std::cerr << "Failed to create empty asset \"" << assetName << "\" for type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
return nullptr; return nullptr;
} }
XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t assetType, const std::string& assetName, IAssetLoader* loader) XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t assetType, const std::string& assetName, const IAssetLoader* loader)
{ {
if (loader->CanLoadFromGdt() && !m_context.m_gdt_files.empty() if (loader->CanLoadFromGdt() && !m_context.m_gdt_files.empty()
&& loader->LoadFromGdt(assetName, &m_context, m_context.m_zone->GetMemory(), this, m_context.m_zone)) && loader->LoadFromGdt(assetName, &m_context, m_context.m_zone->GetMemory(), this, m_context.m_zone))
@ -141,51 +126,65 @@ XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t a
return lastDependency; return lastDependency;
} }
std::cout << "Failed to load asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\": \"" << assetName << "\"\n"; std::cerr << "Failed to load asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\": \"" << assetName << "\"\n";
return nullptr; return nullptr;
} }
XAssetInfoGeneric* AssetLoadingManager::LoadDependency(const asset_type_t assetType, const std::string& assetName) XAssetInfoGeneric* AssetLoadingManager::LoadDependency(const asset_type_t assetType, const std::string& assetName)
{ {
auto* alreadyLoadedAsset = m_context.m_zone->m_pools->GetAssetOrAssetReference(assetType, assetName); const auto normalizedAssetName = NormalizeAssetName(assetName);
auto* alreadyLoadedAsset = m_context.m_zone->m_pools->GetAssetOrAssetReference(assetType, normalizedAssetName);
if (alreadyLoadedAsset) if (alreadyLoadedAsset)
return alreadyLoadedAsset; return alreadyLoadedAsset;
const auto loader = m_asset_loaders_by_type.find(assetType); const auto loader = m_asset_loaders_by_type.find(assetType);
if (loader != m_asset_loaders_by_type.end()) if (loader != m_asset_loaders_by_type.end())
{ {
const auto ignoreEntry = m_context.m_ignored_asset_map.find(assetName); const auto ignoreEntry = m_context.m_ignored_asset_map.find(normalizedAssetName);
if (ignoreEntry != m_context.m_ignored_asset_map.end() && ignoreEntry->second == assetType) if (ignoreEntry != m_context.m_ignored_asset_map.end() && ignoreEntry->second == assetType)
{ {
const auto linkAssetName = ',' + assetName; const auto linkAssetName = std::format(",{}", normalizedAssetName);
return LoadIgnoredDependency(assetType, linkAssetName, loader->second.get()); return LoadIgnoredDependency(assetType, linkAssetName, loader->second.get());
} }
return LoadAssetDependency(assetType, assetName, loader->second.get()); return LoadAssetDependency(assetType, normalizedAssetName, loader->second.get());
} }
std::cout << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n"; std::cerr << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
return nullptr; return nullptr;
} }
IndirectAssetReference AssetLoadingManager::LoadIndirectAssetReference(const asset_type_t assetType, const std::string& assetName) IndirectAssetReference AssetLoadingManager::LoadIndirectAssetReference(const asset_type_t assetType, const std::string& assetName)
{ {
const auto* alreadyLoadedAsset = m_context.m_zone->m_pools->GetAssetOrAssetReference(assetType, assetName); const auto normalizedAssetName = NormalizeAssetName(assetName);
if (alreadyLoadedAsset)
return IndirectAssetReference(assetType, assetName);
const auto ignoreEntry = m_context.m_ignored_asset_map.find(assetName); const auto* alreadyLoadedAsset = m_context.m_zone->m_pools->GetAssetOrAssetReference(assetType, normalizedAssetName);
if (alreadyLoadedAsset)
return IndirectAssetReference(assetType, normalizedAssetName);
const auto ignoreEntry = m_context.m_ignored_asset_map.find(normalizedAssetName);
if (ignoreEntry != m_context.m_ignored_asset_map.end() && ignoreEntry->second == assetType) if (ignoreEntry != m_context.m_ignored_asset_map.end() && ignoreEntry->second == assetType)
return IndirectAssetReference(assetType, assetName); return IndirectAssetReference(assetType, normalizedAssetName);
const auto loader = m_asset_loaders_by_type.find(assetType); const auto loader = m_asset_loaders_by_type.find(assetType);
if (loader != m_asset_loaders_by_type.end()) if (loader != m_asset_loaders_by_type.end())
{ {
LoadAssetDependency(assetType, assetName, loader->second.get()); LoadAssetDependency(assetType, normalizedAssetName, loader->second.get());
return IndirectAssetReference(assetType, assetName); return IndirectAssetReference(assetType, normalizedAssetName);
} }
std::cout << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n"; std::cerr << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
return IndirectAssetReference(assetType, assetName); return IndirectAssetReference(assetType, normalizedAssetName);
}
std::string AssetLoadingManager::NormalizeAssetName(const std::string& assetName)
{
std::string result(assetName);
utils::MakeStringLowerCase(result);
std::ranges::replace(result, '\\', '/');
return result;
} }

35
src/ObjLoading/AssetLoading/AssetLoadingManager.h
View File

@ -1,4 +1,5 @@
#pragma once #pragma once
#include "AssetLoadingContext.h" #include "AssetLoadingContext.h"
#include "IAssetLoader.h" #include "IAssetLoader.h"
#include "IAssetLoadingManager.h" #include "IAssetLoadingManager.h"
@ -7,34 +8,26 @@
class AssetLoadingManager final : public IAssetLoadingManager class AssetLoadingManager final : public IAssetLoadingManager
{ {
const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& m_asset_loaders_by_type;
AssetLoadingContext& m_context;
XAssetInfoGeneric* m_last_dependency_loaded;
XAssetInfoGeneric* LoadIgnoredDependency(asset_type_t assetType, const std::string& assetName, IAssetLoader* loader);
XAssetInfoGeneric* LoadAssetDependency(asset_type_t assetType, const std::string& assetName, IAssetLoader* loader);
XAssetInfoGeneric* AddAssetInternal(std::unique_ptr<XAssetInfoGeneric> xAssetInfo);
public: public:
AssetLoadingManager(const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& assetLoadersByType, AssetLoadingContext& context); AssetLoadingManager(const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& assetLoadersByType, AssetLoadingContext& context);
bool LoadAssetFromLoader(asset_type_t assetType, const std::string& assetName); bool LoadAssetFromLoader(asset_type_t assetType, const std::string& assetName);
_NODISCARD AssetLoadingContext* GetAssetLoadingContext() const override; [[nodiscard]] AssetLoadingContext* GetAssetLoadingContext() const override;
XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings) override;
XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences) override;
XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) override; XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) override;
XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) override; XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) override;
IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override; IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override;
private:
XAssetInfoGeneric* LoadIgnoredDependency(asset_type_t assetType, const std::string& assetName, IAssetLoader* loader);
XAssetInfoGeneric* LoadAssetDependency(asset_type_t assetType, const std::string& assetName, const IAssetLoader* loader);
XAssetInfoGeneric* AddAssetInternal(std::unique_ptr<XAssetInfoGeneric> xAssetInfo);
static std::string NormalizeAssetName(const std::string& assetName);
const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& m_asset_loaders_by_type;
AssetLoadingContext& m_context;
XAssetInfoGeneric* m_last_dependency_loaded;
}; };

31
src/ObjLoading/AssetLoading/IAssetLoadingManager.h
View File

@ -18,17 +18,6 @@ public:
_NODISCARD virtual AssetLoadingContext* GetAssetLoadingContext() const = 0; _NODISCARD virtual AssetLoadingContext* GetAssetLoadingContext() const = 0;
virtual XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings) = 0;
virtual XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences) = 0;
virtual XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) = 0; virtual XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) = 0;
XAssetInfoGeneric* AddAsset(const asset_type_t assetType, const std::string& assetName, void* asset) XAssetInfoGeneric* AddAsset(const asset_type_t assetType, const std::string& assetName, void* asset)
@ -41,6 +30,26 @@ public:
return AddAsset(assetType, assetName, asset, std::move(dependencies), std::vector<scr_string_t>()); return AddAsset(assetType, assetName, asset, std::move(dependencies), std::vector<scr_string_t>());
} }
XAssetInfoGeneric* AddAsset(const asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings)
{
return AddAsset(assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings), std::vector<IndirectAssetReference>());
}
XAssetInfoGeneric* AddAsset(const asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences)
{
return AddAsset(std::make_unique<XAssetInfoGeneric>(
assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings), std::move(indirectAssetReferences)));
}
virtual XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) = 0; virtual XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) = 0;
virtual IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) = 0; virtual IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) = 0;
}; };

7
src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderWeapon.cpp
View File

@ -137,11 +137,8 @@ namespace
if (ConvertString(value, field.iOffset)) if (ConvertString(value, field.iOffset))
{ {
if (!value.empty()) if (!value.empty())
{ m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value));
auto lowerValue = value;
utils::MakeStringLowerCase(lowerValue);
m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, lowerValue));
}
return true; return true;
} }

7
src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderWeapon.cpp
View File

@ -135,11 +135,8 @@ namespace
if (ConvertString(value, field.iOffset)) if (ConvertString(value, field.iOffset))
{ {
if (!value.empty()) if (!value.empty())
{ m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value));
auto lowerValue = value;
utils::MakeStringLowerCase(lowerValue);
m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, lowerValue));
}
return true; return true;
} }

7
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeapon.cpp
View File

@ -263,11 +263,8 @@ namespace T6
if (ConvertString(value, field.iOffset)) if (ConvertString(value, field.iOffset))
{ {
if (!value.empty()) if (!value.empty())
{ m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value));
auto lowerValue = value;
utils::MakeStringLowerCase(lowerValue);
m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, lowerValue));
}
return true; return true;
} }

1
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponAttachmentUnique.cpp
View File

@ -86,6 +86,7 @@ namespace T6
{ {
if (!value.empty()) if (!value.empty())
m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value)); m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value));
return true; return true;
} }

20
test/ObjLoadingTests/Mock/MockAssetLoadingManager.cpp
View File

@ -20,26 +20,6 @@ XAssetInfoGeneric* MockAssetLoadingManager::AddAsset(std::unique_ptr<XAssetInfoG
return assetInfoPtr; return assetInfoPtr;
} }
XAssetInfoGeneric* MockAssetLoadingManager::AddAsset(const asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings)
{
return AddAsset(std::make_unique<XAssetInfoGeneric>(assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings)));
}
XAssetInfoGeneric* MockAssetLoadingManager::AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences)
{
return AddAsset(std::make_unique<XAssetInfoGeneric>(
assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings), std::move(indirectAssetReferences)));
}
XAssetInfoGeneric* MockAssetLoadingManager::LoadDependency(const asset_type_t assetType, const std::string& assetName) XAssetInfoGeneric* MockAssetLoadingManager::LoadDependency(const asset_type_t assetType, const std::string& assetName)
{ {
auto foundDependencies = m_available_dependencies.find(assetName); auto foundDependencies = m_available_dependencies.find(assetName);

11
test/ObjLoadingTests/Mock/MockAssetLoadingManager.h
View File

@ -18,17 +18,6 @@ public:
_NODISCARD AssetLoadingContext* GetAssetLoadingContext() const override; _NODISCARD AssetLoadingContext* GetAssetLoadingContext() const override;
XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) override; XAssetInfoGeneric* AddAsset(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) override;
XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings) override;
XAssetInfoGeneric* AddAsset(asset_type_t assetType,
const std::string& assetName,
void* asset,
std::vector<XAssetInfoGeneric*> dependencies,
std::vector<scr_string_t> usedScriptStrings,
std::vector<IndirectAssetReference> indirectAssetReferences) override;
XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) override; XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) override;
IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override; IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override;