zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-04-20 00:02:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix unlinking every single asset in the global asset pools on unloading a zone

Browse Source
This commit is contained in:
Jan 2022-04-16 16:32:55 +02:00
parent 4abb846ccd
commit 1a36912b44
1 changed files with 36 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
src/ZoneCommon/Pool/GlobalAssetPool.h
View File

@ -5,10 +5,11 @@
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <memory>
#include "AssetPool.h" #include "AssetPool.h"
template<typename T> template <typename T>
class GlobalAssetPool class GlobalAssetPool
{ {
struct LinkedAssetPool struct LinkedAssetPool
@ -24,12 +25,12 @@ class GlobalAssetPool
LinkedAssetPool* m_asset_pool; LinkedAssetPool* m_asset_pool;
}; };
static std::vector<LinkedAssetPool*> m_linked_asset_pools; static std::vector<std::unique_ptr<LinkedAssetPool>> m_linked_asset_pools;
static std::unordered_map<std::string, GameAssetPoolEntry> m_assets; static std::unordered_map<std::string, GameAssetPoolEntry> m_assets;
static void SortLinkedAssetPools() static void SortLinkedAssetPools()
{ {
std::sort(m_linked_asset_pools.begin(), m_linked_asset_pools.end(), [](const LinkedAssetPool* a, const LinkedAssetPool* b) -> bool std::sort(m_linked_asset_pools.begin(), m_linked_asset_pools.end(), [](const std::unique_ptr<LinkedAssetPool>& a, const std::unique_ptr<LinkedAssetPool>& b) -> bool
{ {
return a->m_priority < b->m_priority; return a->m_priority < b->m_priority;
}); });
@ -39,17 +40,17 @@ class GlobalAssetPool
{ {
int occurrences = 0; int occurrences = 0;
for(auto linkedAssetPool : m_linked_asset_pools) for (const auto& linkedAssetPool : m_linked_asset_pools)
{ {
XAssetInfo<T>* foundAsset = linkedAssetPool->m_asset_pool->GetAsset(assetEntry.m_asset->m_name); XAssetInfo<T>* foundAsset = linkedAssetPool->m_asset_pool->GetAsset(assetEntry.m_asset->m_name);
if(foundAsset != nullptr) if (foundAsset != nullptr)
{ {
if(++occurrences == 1) if (++occurrences == 1)
{ {
assetEntry.m_asset = foundAsset; assetEntry.m_asset = foundAsset;
assetEntry.m_duplicate = false; assetEntry.m_duplicate = false;
assetEntry.m_asset_pool = linkedAssetPool; assetEntry.m_asset_pool = linkedAssetPool.get();
} }
else else
{ {
@ -68,7 +69,7 @@ class GlobalAssetPool
auto existingAsset = m_assets.find(assetName); auto existingAsset = m_assets.find(assetName);
if(existingAsset == m_assets.end()) if (existingAsset == m_assets.end())
{ {
GameAssetPoolEntry entry{}; GameAssetPoolEntry entry{};
entry.m_asset = asset; entry.m_asset = asset;
@ -83,7 +84,7 @@ class GlobalAssetPool
existingEntry.m_duplicate = true; existingEntry.m_duplicate = true;
if(existingEntry.m_asset_pool->m_priority < link->m_priority) if (existingEntry.m_asset_pool->m_priority < link->m_priority)
{ {
existingEntry.m_asset_pool = link; existingEntry.m_asset_pool = link;
existingEntry.m_asset = asset; existingEntry.m_asset = asset;
@ -94,16 +95,17 @@ class GlobalAssetPool
public: public:
static void LinkAssetPool(AssetPool<T>* assetPool, const int priority) static void LinkAssetPool(AssetPool<T>* assetPool, const int priority)
{ {
auto* newLink = new LinkedAssetPool(); auto newLink = std::make_unique<LinkedAssetPool>();
newLink->m_asset_pool = assetPool; newLink->m_asset_pool = assetPool;
newLink->m_priority = priority; newLink->m_priority = priority;
m_linked_asset_pools.push_back(newLink); auto* newLinkPtr = newLink.get();
m_linked_asset_pools.emplace_back(std::move(newLink));
SortLinkedAssetPools(); SortLinkedAssetPools();
for(auto asset : *assetPool) for (auto asset : *assetPool)
{ {
LinkAsset(newLink, asset); LinkAsset(newLinkPtr, asset);
} }
} }
@ -111,17 +113,17 @@ public:
{ {
LinkedAssetPool* link = nullptr; LinkedAssetPool* link = nullptr;
for(auto existingLink : m_linked_asset_pools) for (const auto& existingLink : m_linked_asset_pools)
{ {
if(existingLink->m_asset_pool == assetPool) if (existingLink->m_asset_pool == assetPool)
{ {
link = existingLink; link = existingLink.get();
break; break;
} }
} }
assert(link != nullptr); assert(link != nullptr);
if(link == nullptr) if (link == nullptr)
return; return;
LinkAsset(link, asset); LinkAsset(link, asset);
@ -131,26 +133,33 @@ public:
{ {
auto iLinkEntry = m_linked_asset_pools.begin(); auto iLinkEntry = m_linked_asset_pools.begin();
for(; iLinkEntry != m_linked_asset_pools.end(); ++iLinkEntry) for (; iLinkEntry != m_linked_asset_pools.end(); ++iLinkEntry)
{ {
LinkedAssetPool* linkEntry = *iLinkEntry; LinkedAssetPool* linkEntry = iLinkEntry->get();
if(linkEntry->m_asset_pool == assetPool) if (linkEntry->m_asset_pool == assetPool)
{ {
break; break;
} }
} }
assert(iLinkEntry != m_linked_asset_pools.end()); assert(iLinkEntry != m_linked_asset_pools.end());
if(iLinkEntry == m_linked_asset_pools.end()) if (iLinkEntry == m_linked_asset_pools.end())
return; return;
auto assetPoolToUnlink = std::move(*iLinkEntry);
m_linked_asset_pools.erase(iLinkEntry); m_linked_asset_pools.erase(iLinkEntry);
for(auto iAssetEntry = m_assets.begin(); iAssetEntry != m_assets.end(); ) for (auto iAssetEntry = m_assets.begin(); iAssetEntry != m_assets.end();)
{ {
auto& assetEntry = *iAssetEntry; auto& assetEntry = *iAssetEntry;
if(assetEntry.second.m_duplicate && ReplaceAssetPoolEntry(assetEntry.second)) if (assetEntry.second.m_asset_pool != assetPoolToUnlink.get())
{
++iAssetEntry;
continue;
}
if (assetEntry.second.m_duplicate && ReplaceAssetPoolEntry(assetEntry.second))
{ {
++iAssetEntry; ++iAssetEntry;
continue; continue;
@ -170,8 +179,8 @@ public:
} }
}; };
template<typename T> template <typename T>
std::vector<typename GlobalAssetPool<T>::LinkedAssetPool*> GlobalAssetPool<T>::m_linked_asset_pools = std::vector<LinkedAssetPool*>(); std::vector<std::unique_ptr<typename GlobalAssetPool<T>::LinkedAssetPool>> GlobalAssetPool<T>::m_linked_asset_pools = std::vector<std::unique_ptr<LinkedAssetPool>>();
template<typename T> template <typename T>
std::unordered_map<std::string, typename GlobalAssetPool<T>::GameAssetPoolEntry> GlobalAssetPool<T>::m_assets = std::unordered_map<std::string, GameAssetPoolEntry>(); std::unordered_map<std::string, typename GlobalAssetPool<T>::GameAssetPoolEntry> GlobalAssetPool<T>::m_assets = std::unordered_map<std::string, GameAssetPoolEntry>();