chore: always use dynamic asset pools and remove static implementation

src/ZoneCommon/Pool/AssetPoolDynamic.h

@@ -4,20 +4,18 @@
 #include "GlobalAssetPool.h"
 #include "XAssetInfo.h"
 
-#include <cstring>
+#include <vector>
 
 template<typename T> class AssetPoolDynamic final : public AssetPool<T>
 {
     using AssetPool<T>::m_asset_lookup;
 
     std::vector<std::unique_ptr<XAssetInfo<T>>> m_assets;
-    asset_type_t m_type;
 
 public:
-    AssetPoolDynamic(const int priority, const asset_type_t type)
+    explicit AssetPoolDynamic(const zone_priority_t priority)
     {
         GlobalAssetPool<T>::LinkAssetPool(this, priority);
-        m_type = type;
     }
 
     AssetPoolDynamic(AssetPoolDynamic<T>&) = delete;

src/ZoneCommon/Pool/AssetPoolStatic.h

@@ -1,104 +0,0 @@
-#pragma once
-
-#include "AssetPool.h"
-#include "GlobalAssetPool.h"
-#include "XAssetInfo.h"
-
-#include <cstring>
-#include <stdexcept>
-
-template<typename T> class AssetPoolStatic final : public AssetPool<T>
-{
-    using AssetPool<T>::m_asset_lookup;
-
-    struct AssetPoolEntry
-    {
-        XAssetInfo<T>* m_info;
-
-        union
-        {
-            T m_entry;
-            AssetPoolEntry* m_next;
-        };
-    };
-
-    AssetPoolEntry* m_free;
-    AssetPoolEntry* m_pool;
-    XAssetInfo<T>* m_info_pool;
-    size_t m_capacity;
-    asset_type_t m_type;
-
-public:
-    AssetPoolStatic(const size_t capacity, const int priority, const asset_type_t type)
-    {
-        m_capacity = capacity;
-        m_type = type;
-
-        if (m_capacity > 0)
-        {
-            m_pool = new AssetPoolEntry[m_capacity];
-            m_info_pool = new XAssetInfo<T>[m_capacity];
-
-            for (size_t i = 0; i < m_capacity - 1; i++)
-            {
-                m_pool[i].m_info = &m_info_pool[i];
-                m_pool[i].m_next = &m_pool[i + 1];
-            }
-            m_pool[m_capacity - 1].m_info = &m_info_pool[m_capacity - 1];
-            m_pool[m_capacity - 1].m_next = nullptr;
-
-            m_free = m_pool;
-
-            GlobalAssetPool<T>::LinkAssetPool(this, priority);
-        }
-        else
-        {
-            m_pool = nullptr;
-            m_free = nullptr;
-            m_info_pool = nullptr;
-        }
-    }
-
-    AssetPoolStatic(AssetPoolStatic<T>&) = delete;
-    AssetPoolStatic(AssetPoolStatic<T>&&) = delete;
-    AssetPoolStatic<T>& operator=(AssetPoolStatic<T>&) = delete;
-    AssetPoolStatic<T>& operator=(AssetPoolStatic<T>&&) = default;
-
-    ~AssetPoolStatic() override
-    {
-        if (m_capacity > 0)
-            GlobalAssetPool<T>::UnlinkAssetPool(this);
-
-        delete[] m_pool;
-        m_pool = nullptr;
-
-        delete[] m_info_pool;
-        m_info_pool = nullptr;
-
-        m_free = nullptr;
-        m_capacity = 0;
-    }
-
-    XAssetInfo<T>* AddAsset(std::unique_ptr<XAssetInfo<T>> xAssetInfo) override
-    {
-        if (m_free == nullptr)
-            throw std::runtime_error("Could not add asset to static asset pool: capacity exhausted.");
-
-        const auto normalizedName = XAssetInfo<T>::NormalizeAssetName(xAssetInfo->m_name);
-
-        AssetPoolEntry* poolSlot = m_free;
-        m_free = m_free->m_next;
-
-        const T* pAsset = xAssetInfo->Asset();
-        xAssetInfo->m_ptr = static_cast<void*>(&poolSlot->m_entry);
-        memcpy(&poolSlot->m_entry, pAsset, sizeof(T));
-
-        *poolSlot->m_info = std::move(*xAssetInfo);
-
-        m_asset_lookup[normalizedName] = poolSlot->m_info;
-
-        GlobalAssetPool<T>::LinkAsset(this, normalizedName, poolSlot->m_info);
-
-        return poolSlot->m_info;
-    }
-};

src/ZoneCommon/Pool/GlobalAssetPool.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "AssetPool.h"
+#include "Zone/ZoneTypes.h"
 
 #include <algorithm>
 #include <cassert>
@@ -14,7 +15,7 @@ template<typename T> class GlobalAssetPool
     struct LinkedAssetPool
     {
         AssetPool<T>* m_asset_pool;
-        int m_priority;
+        zone_priority_t m_priority;
     };
 
     struct GameAssetPoolEntry
@@ -92,7 +93,7 @@ template<typename T> class GlobalAssetPool
     }
 
 public:
-    static void LinkAssetPool(AssetPool<T>* assetPool, const int priority)
+    static void LinkAssetPool(AssetPool<T>* assetPool, const zone_priority_t priority)
     {
         auto newLink = std::make_unique<LinkedAssetPool>();
         newLink->m_asset_pool = assetPool;

src/ZoneCommon/Pool/ZoneAssetPools.h

@@ -16,12 +16,6 @@ class XAssetInfoGeneric;
 
 class ZoneAssetPools
 {
-protected:
-    Zone* m_zone;
-    std::vector<XAssetInfoGeneric*> m_assets_in_order;
-
-    virtual XAssetInfoGeneric* AddAssetToPool(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) = 0;
-
 public:
     using iterator = std::vector<XAssetInfoGeneric*>::const_iterator;
 
@@ -45,13 +39,16 @@ public:
     _NODISCARD virtual asset_type_t GetAssetTypeCount() const = 0;
     _NODISCARD virtual std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const = 0;
 
-    virtual void InitPoolStatic(asset_type_t type, size_t capacity) = 0;
-    virtual void InitPoolDynamic(asset_type_t type) = 0;
-
     _NODISCARD size_t GetTotalAssetCount() const;
 
     _NODISCARD iterator begin() const;
     _NODISCARD iterator end() const;
 
     static std::unique_ptr<ZoneAssetPools> CreateForGame(GameId game, Zone* zone, zone_priority_t priority);
+
+protected:
+    virtual XAssetInfoGeneric* AddAssetToPool(std::unique_ptr<XAssetInfoGeneric> xAssetInfo) = 0;
+
+    Zone* m_zone;
+    std::vector<XAssetInfoGeneric*> m_assets_in_order;
 };