Merge pull request #109 from Laupetin/fix/assets-referenced-by-string

fix: assets referenced by their name in a string are not recognized as dependencies

src/Common/Game/T6/T6.h

@@ -98,6 +98,9 @@ namespace T6
         WFT_ATTACHMENTS,
         WFT_ATTACHMENT_UNIQUES,
 
+        // Custom
+        WFT_ANIM_NAME,
+
         WFT_NUM_FIELD_TYPES
     };
 

src/Linker/Game/T6/ZoneCreatorT6.cpp

@@ -102,7 +102,7 @@ void ZoneCreator::HandleMetadata(Zone* zone, const ZoneCreationContext& context)
         for (auto i = 0u; i < kvpList.size(); i++)
             kvps->keyValuePairs[i] = kvpList[i];
 
-        zone->m_pools->AddAsset(ASSET_TYPE_KEYVALUEPAIRS, zone->m_name, kvps, std::vector<XAssetInfoGeneric*>(), std::vector<scr_string_t>());
+        zone->m_pools->AddAsset(std::make_unique<XAssetInfo<KeyValuePairs>>(ASSET_TYPE_KEYVALUEPAIRS, zone->m_name, kvps));
     }
 }
 

src/ObjLoading/AssetLoading/AssetLoadingManager.cpp

@@ -19,17 +19,15 @@ AssetLoadingContext* AssetLoadingManager::GetAssetLoadingContext() const
     return &m_context;
 }
 
-XAssetInfoGeneric* AssetLoadingManager::AddAsset(const asset_type_t assetType,
-                                                 const std::string& assetName,
-                                                 void* asset,
-                                                 std::vector<XAssetInfoGeneric*> dependencies,
-                                                 std::vector<scr_string_t> usedScriptStrings,
-                                                 Zone* zone)
+XAssetInfoGeneric* AssetLoadingManager::AddAssetInternal(std::unique_ptr<XAssetInfoGeneric> xAssetInfo)
 {
-    m_last_dependency_loaded = m_context.m_zone->m_pools->AddAsset(assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings), zone);
+    const auto assetType = xAssetInfo->m_type;
+    const auto* pAssetName = xAssetInfo->m_name.c_str();
+
+    m_last_dependency_loaded = m_context.m_zone->m_pools->AddAsset(std::move(xAssetInfo));
     if (m_last_dependency_loaded == nullptr)
-        std::cout << "Failed to add asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\" to pool: \"" << assetName << "\""
-                  << std::endl;
+        std::cout << "Failed to add asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\" to pool: \"" << pAssetName << "\"\n";
+
     return m_last_dependency_loaded;
 }
 
@@ -39,11 +37,24 @@ XAssetInfoGeneric* AssetLoadingManager::AddAsset(const asset_type_t assetType,
                                                  std::vector<XAssetInfoGeneric*> dependencies,
                                                  std::vector<scr_string_t> usedScriptStrings)
 {
-    m_last_dependency_loaded = m_context.m_zone->m_pools->AddAsset(assetType, assetName, asset, std::move(dependencies), std::move(usedScriptStrings));
-    if (m_last_dependency_loaded == nullptr)
-        std::cout << "Failed to add asset of type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\" to pool: \"" << assetName << "\""
-                  << std::endl;
-    return m_last_dependency_loaded;
+    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;
+    return AddAssetInternal(std::move(xAssetInfo));
 }
 
 XAssetInfoGeneric* AssetLoadingManager::LoadIgnoredDependency(const asset_type_t assetType, const std::string& assetName, IAssetLoader* loader)
@@ -64,20 +75,13 @@ XAssetInfoGeneric* AssetLoadingManager::LoadIgnoredDependency(const asset_type_t
     auto* existingAsset = loader->LoadFromGlobalAssetPools(assetName);
     if (existingAsset)
     {
-        std::vector<XAssetInfoGeneric*> dependencies;
-        AddAsset(existingAsset->m_type,
-                 existingAsset->m_name,
-                 existingAsset->m_ptr,
-                 std::vector<XAssetInfoGeneric*>(),
-                 std::vector<scr_string_t>(),
-                 existingAsset->m_zone);
+        AddAssetInternal(std::make_unique<XAssetInfoGeneric>(*existingAsset));
         auto* lastDependency = m_last_dependency_loaded;
         m_last_dependency_loaded = nullptr;
         return lastDependency;
     }
 
-    std::cout << "Failed to create empty asset \"" << assetName << "\" for type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\""
-              << std::endl;
+    std::cout << "Failed to create empty asset \"" << assetName << "\" for type \"" << m_context.m_zone->m_pools->GetAssetTypeName(assetType) << "\"\n";
     return nullptr;
 }
 
@@ -105,6 +109,7 @@ XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t a
     if (existingAsset)
     {
         std::vector<XAssetInfoGeneric*> dependencies;
+        std::vector<IndirectAssetReference> indirectAssetReferences;
         for (const auto* dependency : existingAsset->m_dependencies)
         {
             auto* newDependency = LoadDependency(dependency->m_type, dependency->m_name);
@@ -114,23 +119,29 @@ XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t a
                 return nullptr;
         }
 
+        indirectAssetReferences.reserve(existingAsset->m_indirect_asset_references.size());
+        for (const auto& indirectAssetReference : existingAsset->m_indirect_asset_references)
+            indirectAssetReferences.emplace_back(LoadIndirectAssetReference(indirectAssetReference.m_type, indirectAssetReference.m_name));
+
         // Make sure any used script string is available in the created zone
         // The replacement of the scr_string_t values will be done upon writing
         for (const auto scrString : existingAsset->m_used_script_strings)
             m_context.m_zone->m_script_strings.AddOrGetScriptString(existingAsset->m_zone->m_script_strings.CValue(scrString));
 
-        AddAsset(existingAsset->m_type,
-                 existingAsset->m_name,
-                 existingAsset->m_ptr,
-                 std::move(dependencies),
-                 existingAsset->m_used_script_strings,
-                 existingAsset->m_zone);
+        AddAssetInternal(std::make_unique<XAssetInfoGeneric>(existingAsset->m_type,
+                                                             existingAsset->m_name,
+                                                             existingAsset->m_ptr,
+                                                             std::move(dependencies),
+                                                             existingAsset->m_used_script_strings,
+                                                             std::move(indirectAssetReferences),
+                                                             existingAsset->m_zone));
+
         auto* lastDependency = m_last_dependency_loaded;
         m_last_dependency_loaded = nullptr;
         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;
 }
 
@@ -154,6 +165,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

@@ -14,12 +14,7 @@ class AssetLoadingManager final : public IAssetLoadingManager
     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* AddAsset(asset_type_t assetType,
-                                const std::string& assetName,
-                                void* asset,
-                                std::vector<XAssetInfoGeneric*> dependencies,
-                                std::vector<scr_string_t> usedScriptStrings,
-                                Zone* zone);
+    XAssetInfoGeneric* AddAssetInternal(std::unique_ptr<XAssetInfoGeneric> xAssetInfo);
 
 public:
     AssetLoadingManager(const std::map<asset_type_t, std::unique_ptr<IAssetLoader>>& assetLoadersByType, AssetLoadingContext& context);
@@ -33,5 +28,13 @@ class AssetLoadingManager final : public IAssetLoadingManager
                                 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,11 +23,19 @@ class IAssetLoadingManager
                                         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)
     {
         return AddAsset(assetType, assetName, asset, std::vector<XAssetInfoGeneric*>(), std::vector<scr_string_t>());
     }
 
     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/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeapon.cpp

@@ -227,7 +227,7 @@ namespace T6
                     {
                         std::cout << "Cannot have more than "
                                   << (std::extent_v<decltype(WeaponFullDef::attachmentUniques)> - std::extent_v<decltype(WeaponFullDef::attachments)>)
-                                  << " combined attachment attachment unique entries!" << std::endl;
+                                  << " combined attachment attachment unique entries!\n";
                         return false;
                     }
 
@@ -239,15 +239,14 @@ namespace T6
                     if (static_cast<unsigned>(attachmentUniqueAsset->attachmentType) >= ATTACHMENT_TYPE_COUNT)
                     {
                         std::cout << "Invalid attachment type " << attachmentUniqueAsset->attachmentType << " for attachment unique asset \""
-                                  << attachmentUniqueName << "\"" << std::endl;
+                                  << attachmentUniqueName << "\"\n";
                         return false;
                     }
 
                     if (attachmentUniques[attachmentUniqueAsset->attachmentType] != nullptr)
                     {
                         std::cout << "Already loaded attachment unique with same type " << attachmentUniqueAsset->attachmentType << ": \""
-                                  << attachmentUniques[attachmentUniqueAsset->attachmentType]->szInternalName << "\", \"" << attachmentUniqueName << "\""
-                                  << std::endl;
+                                  << attachmentUniques[attachmentUniqueAsset->attachmentType]->szInternalName << "\", \"" << attachmentUniqueName << "\"\n";
                         return false;
                     }
 
@@ -259,6 +258,18 @@ namespace T6
             return true;
         }
 
+        bool ConvertAnimName(const cspField_t& field, const std::string& value)
+        {
+            if (ConvertString(value, field.iOffset))
+            {
+                if (!value.empty())
+                    m_indirect_asset_references.emplace(m_loading_manager->LoadIndirectAssetReference(ASSET_TYPE_XANIMPARTS, value));
+                return true;
+            }
+
+            return false;
+        }
+
     protected:
         bool ConvertExtensionField(const cspField_t& field, const std::string& value) override
         {
@@ -352,7 +363,9 @@ namespace T6
             case WFT_ATTACHMENT_UNIQUES:
                 return ConvertAttachmentUniques(field, value);
 
-            case WFT_NUM_FIELD_TYPES:
+            case WFT_ANIM_NAME:
+                return ConvertAnimName(field, value);
+
             default:
                 assert(false);
                 return false;
@@ -553,7 +566,12 @@ bool AssetLoaderWeapon::LoadFromInfoString(
     CalculateWeaponFields(weaponFullDef);
     CalculateAttachmentFields(weaponFullDef);
 
-    manager->AddAsset(ASSET_TYPE_WEAPON, assetName, &weaponFullDef->weapVariantDef, converter.GetDependencies(), converter.GetUsedScriptStrings());
+    manager->AddAsset(ASSET_TYPE_WEAPON,
+                      assetName,
+                      &weaponFullDef->weapVariantDef,
+                      converter.GetDependencies(),
+                      converter.GetUsedScriptStrings(),
+                      converter.GetIndirectAssetReferences());
 
     return true;
 }

src/ObjLoading/InfoString/InfoStringToStructConverterBase.cpp

@@ -41,7 +41,7 @@ bool InfoStringToStructConverterBase::ParseAsArray(const std::string& value, std
     return true;
 }
 
-bool InfoStringToStructConverterBase::ParseAsPairs(const std::string& value, std::vector<std::pair<std::string, std::string>>& valueArray) const
+bool InfoStringToStructConverterBase::ParseAsPairs(const std::string& value, std::vector<std::pair<std::string, std::string>>& valueArray)
 {
     std::string key;
     auto isKey = true;
@@ -227,6 +227,7 @@ bool InfoStringToStructConverterBase::ConvertEnumInt(const std::string& value, c
 std::vector<scr_string_t> InfoStringToStructConverterBase::GetUsedScriptStrings() const
 {
     std::vector<scr_string_t> scrStringList;
+    scrStringList.reserve(m_used_script_string_list.size());
     for (auto scrStr : m_used_script_string_list)
     {
         scrStringList.push_back(scrStr);
@@ -238,10 +239,23 @@ std::vector<scr_string_t> InfoStringToStructConverterBase::GetUsedScriptStrings(
 std::vector<XAssetInfoGeneric*> InfoStringToStructConverterBase::GetDependencies() const
 {
     std::vector<XAssetInfoGeneric*> dependencyList;
+    dependencyList.reserve(m_dependencies.size());
     for (auto* dependency : m_dependencies)
     {
         dependencyList.push_back(dependency);
     }
 
     return dependencyList;
 }
+
+std::vector<IndirectAssetReference> InfoStringToStructConverterBase::GetIndirectAssetReferences() const
+{
+    std::vector<IndirectAssetReference> indirectAssetReferences;
+    indirectAssetReferences.reserve(m_indirect_asset_references.size());
+    for (auto& assetReference : m_indirect_asset_references)
+    {
+        indirectAssetReferences.emplace_back(assetReference);
+    }
+
+    return indirectAssetReferences;
+}

src/ObjLoading/InfoString/InfoStringToStructConverterBase.h

@@ -17,11 +17,12 @@ class InfoStringToStructConverterBase
     ZoneScriptStrings& m_zone_script_strings;
     std::unordered_set<scr_string_t> m_used_script_string_list;
     std::unordered_set<XAssetInfoGeneric*> m_dependencies;
+    std::unordered_set<IndirectAssetReference> m_indirect_asset_references;
     MemoryManager* m_memory;
     void* m_structure;
 
     static bool ParseAsArray(const std::string& value, std::vector<std::string>& valueArray);
-    bool ParseAsPairs(const std::string& value, std::vector<std::pair<std::string, std::string>>& valueArray) const;
+    static bool ParseAsPairs(const std::string& value, std::vector<std::pair<std::string, std::string>>& valueArray);
 
     bool ConvertString(const std::string& value, size_t offset);
     bool ConvertStringBuffer(const std::string& value, size_t offset, size_t bufferSize);
@@ -45,4 +46,5 @@ class InfoStringToStructConverterBase
     virtual bool Convert() = 0;
     _NODISCARD std::vector<scr_string_t> GetUsedScriptStrings() const;
     _NODISCARD std::vector<XAssetInfoGeneric*> GetDependencies() const;
+    _NODISCARD std::vector<IndirectAssetReference> GetIndirectAssetReferences() const;
 };