chore: load indirectly referenced assets if they are not ignored

src/ObjLoading/AssetLoading/AssetLoadingManager.cpp

@@ -40,6 +40,17 @@ XAssetInfoGeneric* AssetLoadingManager::AddAsset(const asset_type_t assetType,
     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)
 {
     xAssetInfo->m_zone = m_context.m_zone;
@@ -125,7 +136,7 @@ XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t a
         return lastDependency;
     }
 
-    std::cout << "Failed to load asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\": \"" << assetName << "\"" << std::endl;
+    std::cout << "Failed to load asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\": \"" << assetName << "\"\n";
     return nullptr;
 }
 
@@ -149,6 +160,27 @@ XAssetInfoGeneric* AssetLoadingManager::LoadDependency(const asset_type_t assetT
         return LoadAssetDependency(assetType, assetName, loader->second.get());
     }
 
-    std::cout << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"" << std::endl;
+    std::cout << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
     return nullptr;
 }
+
+IndirectAssetReference AssetLoadingManager::LoadIndirectAssetReference(const asset_type_t assetType, const std::string& assetName)
+{
+    const auto* alreadyLoadedAsset = m_context.m_zone->m_pools->GetAsset(assetType, assetName);
+    if (alreadyLoadedAsset)
+        return IndirectAssetReference(assetType, assetName);
+
+    const auto ignoreEntry = m_context.m_ignored_asset_map.find(assetName);
+    if (ignoreEntry != m_context.m_ignored_asset_map.end() && ignoreEntry->second == assetType)
+        return IndirectAssetReference(assetType, assetName);
+
+    const auto loader = m_asset_loaders_by_type.find(assetType);
+    if (loader != m_asset_loaders_by_type.end())
+    {
+        LoadAssetDependency(assetType, assetName, loader->second.get());
+        return IndirectAssetReference(assetType, assetName);
+    }
+
+    std::cout << "Failed to find loader for asset type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
+    return IndirectAssetReference(assetType, assetName);
+}

src/ObjLoading/AssetLoading/AssetLoadingManager.h

@@ -28,6 +28,13 @@ public:
                                 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* LoadDependency(asset_type_t assetType, const std::string& assetName) override;
+    IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override;
 };

src/ObjLoading/AssetLoading/IAssetLoadingManager.h

@@ -23,6 +23,12 @@ public:
                                         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;
 
     XAssetInfoGeneric* AddAsset(const asset_type_t assetType, const std::string& assetName, void* asset)
@@ -31,4 +37,5 @@ public:
     }
 
     virtual XAssetInfoGeneric* LoadDependency(asset_type_t assetType, const std::string& assetName) = 0;
+    virtual IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) = 0;
 };

src/ZoneCommon/Pool/XAssetInfo.cpp

@@ -11,6 +11,24 @@ IndirectAssetReference::IndirectAssetReference(const asset_type_t type, std::str
 {
 }
 
+bool operator==(const IndirectAssetReference& lhs, const IndirectAssetReference& rhs)
+{
+    return lhs.m_type == rhs.m_type && lhs.m_name == rhs.m_name;
+}
+
+bool operator!=(const IndirectAssetReference& lhs, const IndirectAssetReference& rhs)
+{
+    return !(lhs == rhs);
+}
+
+std::size_t std::hash<IndirectAssetReference>::operator()(const IndirectAssetReference& v) const noexcept
+{
+    std::size_t seed = 0x01A627D3;
+    seed ^= (seed << 6) + (seed >> 2) + 0x0BCEF9CE + static_cast<std::size_t>(v.m_type);
+    seed ^= (seed << 6) + (seed >> 2) + 0x7225148B + std::hash<std::string>()(v.m_name);
+    return seed;
+}
+
 XAssetInfoGeneric::XAssetInfoGeneric()
     : m_type(-1),
       m_ptr(nullptr),
@@ -37,6 +55,22 @@ XAssetInfoGeneric::XAssetInfoGeneric(
 {
 }
 
+XAssetInfoGeneric::XAssetInfoGeneric(asset_type_t type,
+                                     std::string name,
+                                     void* ptr,
+                                     std::vector<XAssetInfoGeneric*> dependencies,
+                                     std::vector<scr_string_t> usedScriptStrings,
+                                     std::vector<IndirectAssetReference> indirectAssetReferences)
+    : m_type(type),
+      m_name(std::move(name)),
+      m_ptr(ptr),
+      m_dependencies(std::move(dependencies)),
+      m_used_script_strings(std::move(usedScriptStrings)),
+      m_indirect_asset_references(std::move(indirectAssetReferences)),
+      m_zone(nullptr)
+{
+}
+
 XAssetInfoGeneric::XAssetInfoGeneric(const asset_type_t type,
                                      std::string name,
                                      void* ptr,

src/ZoneCommon/Pool/XAssetInfo.h

@@ -17,6 +17,14 @@ public:
 
     IndirectAssetReference();
     IndirectAssetReference(asset_type_t type, std::string name);
+
+    friend bool operator==(const IndirectAssetReference& lhs, const IndirectAssetReference& rhs);
+    friend bool operator!=(const IndirectAssetReference& lhs, const IndirectAssetReference& rhs);
+};
+
+template<> struct std::hash<IndirectAssetReference>
+{
+    std::size_t operator()(const IndirectAssetReference& v) const noexcept;
 };
 
 class XAssetInfoGeneric
@@ -34,6 +42,12 @@ public:
     XAssetInfoGeneric(asset_type_t type, std::string name, void* ptr);
     XAssetInfoGeneric(
         asset_type_t type, std::string name, void* ptr, std::vector<XAssetInfoGeneric*> dependencies, std::vector<scr_string_t> usedScriptStrings);
+    XAssetInfoGeneric(asset_type_t type,
+                      std::string name,
+                      void* ptr,
+                      std::vector<XAssetInfoGeneric*> dependencies,
+                      std::vector<scr_string_t> usedScriptStrings,
+                      std::vector<IndirectAssetReference> indirectAssetReferences);
     XAssetInfoGeneric(asset_type_t type,
                       std::string name,
                       void* ptr,
@@ -64,6 +78,17 @@ public:
     {
     }
 
+    XAssetInfo(const asset_type_t type,
+               std::string name,
+               T* ptr,
+               std::vector<XAssetInfoGeneric*> dependencies,
+               std::vector<scr_string_t> usedScriptStrings,
+               std::vector<IndirectAssetReference> indirectAssetReferences)
+        : XAssetInfoGeneric(
+              type, std::move(name), static_cast<void*>(ptr), std::move(dependencies), std::move(usedScriptStrings), std::move(indirectAssetReferences))
+    {
+    }
+
     XAssetInfo(const asset_type_t type,
                std::string name,
                T* ptr,

test/ObjLoadingTests/Mock/MockAssetLoadingManager.cpp

@@ -29,6 +29,17 @@ XAssetInfoGeneric* MockAssetLoadingManager::AddAsset(const asset_type_t assetTyp
     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)
 {
     auto foundDependencies = m_available_dependencies.find(assetName);
@@ -44,6 +55,11 @@ XAssetInfoGeneric* MockAssetLoadingManager::LoadDependency(const asset_type_t as
     return nullptr;
 }
 
+IndirectAssetReference MockAssetLoadingManager::LoadIndirectAssetReference(const asset_type_t assetType, const std::string& assetName)
+{
+    return IndirectAssetReference(assetType, assetName);
+}
+
 void MockAssetLoadingManager::MockAddAvailableDependency(const asset_type_t assetType, std::string assetName, void* asset)
 {
     auto assetInfo = std::make_unique<XAssetInfoGeneric>(assetType, std::move(assetName), asset);

test/ObjLoadingTests/Mock/MockAssetLoadingManager.h

@@ -23,7 +23,14 @@ public:
                                 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;
+    IndirectAssetReference LoadIndirectAssetReference(asset_type_t assetType, const std::string& assetName) override;
 
     void MockAddAvailableDependency(asset_type_t assetType, std::string assetName, void* asset);
     XAssetInfoGeneric* MockGetAddedAsset(const std::string& assetName);