Merge pull request #807 from MihailRis/assets-stabilization

preserve assets from being destroyed during frame

src/assets/Assets.cpp

@@ -1,6 +1,19 @@
 #include "Assets.hpp"
 
-Assets::~Assets() = default;
+Assets::Assets(util::ObjectsKeeper* vault) : vault(vault) {
+}
+
+Assets::~Assets() {
+    if (vault == nullptr) {
+        return;
+    }
+    for (auto& [_, map] : assets) {
+        for (auto& [__, asset] : map) {
+            vault->keepAlive(std::move(asset));
+        }
+        map.clear();
+    }
+}
 
 const std::vector<TextureAnimation>& Assets::getAnimations() {
     return animations;

src/assets/Assets.hpp

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "util/stringutil.hpp"
+#include "util/ObjectsKeeper.hpp"
 #include "graphics/core/TextureAnimation.hpp"
 
 class Assets;
@@ -64,13 +65,14 @@ namespace assetload {
 }
 
 class Assets {
+    util::ObjectsKeeper* vault;
     std::vector<TextureAnimation> animations;
 
     using assets_map = std::unordered_map<std::string, std::shared_ptr<void>>;
     std::unordered_map<std::type_index, assets_map> assets;
     std::vector<assetload::setupfunc> setupFuncs;
 public:
-    Assets() = default;
+    Assets(util::ObjectsKeeper* vault);
     Assets(const Assets&) = delete;
     ~Assets();
 
@@ -79,12 +81,20 @@ public:
 
     template <class T>
     void store(std::unique_ptr<T> asset, const std::string& name) {
-        assets[typeid(T)][name].reset(asset.release());
+        auto& dst = assets[typeid(T)][name];
+        if (vault != nullptr && dst != nullptr) {
+            vault->keepAlive(std::move(dst));
+        }
+        dst.reset(asset.release());
     }
 
     template <class T>
     void store(std::shared_ptr<T> asset, const std::string& name) {
-        assets[typeid(T)][name] = std::move(asset);
+        auto& dst = assets[typeid(T)][name];
+        if (vault != nullptr && dst != nullptr) {
+            vault->keepAlive(std::move(dst));
+        }
+        dst = std::move(asset);
     }
 
     template <class T>

src/engine/AssetsManagement.cpp

@@ -51,7 +51,9 @@ void AssetsManagement::loadAssets(Content* content) {
     logger.info() << "loading assets";
     Shader::preprocessor->setPaths(&paths.resPaths);
 
-    auto new_assets = std::make_unique<Assets>();
+    auto new_assets = std::make_unique<Assets>(
+        settings.system.preserveAssetsDuringFrame.get() ? &assetsVault : nullptr 
+    );
     AssetsLoader loader(engine, *new_assets, paths.resPaths);
     AssetsLoader::addDefaults(loader, content);
 
@@ -78,6 +80,7 @@ void AssetsManagement::loadAssets(Content* content) {
 }
 
 void AssetsManagement::update() {
+    assetsVault.clearKeepedObjects();
     if (backgroundLoaderTask) {
         backgroundLoaderTask->update();
     }

src/engine/AssetsManagement.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "assets/Assets.hpp"
+#include "util/ObjectsKeeper.hpp"
 
 #include <memory>
 
@@ -30,4 +31,5 @@ private:
     std::unique_ptr<Assets> assets;
     std::unique_ptr<AssetsLoader> backgroundLoader;
     std::shared_ptr<Task> backgroundLoaderTask;
+    util::ObjectsKeeper assetsVault;
 };

src/io/settings_io.cpp

@@ -100,6 +100,7 @@ SettingsHandler::SettingsHandler(EngineSettings& settings) {
 
     builder.addSection("system");
     builder.add("max-bg-asset-loaders", &settings.system.maxBgAssetLoaders);
+    builder.add("preserve-assets-during-frame", &settings.system.preserveAssetsDuringFrame);
 }
 
 dv::value SettingsHandler::getValue(const std::string& name) const {

src/settings.hpp

@@ -122,7 +122,10 @@ struct NetworkSettings {
 };
 
 struct SystemSettings {
+    /// @brief Max background assets loaders
     IntegerSetting maxBgAssetLoaders {3, -4, 16};
+    /// @brief Preserve assets during current frame from being destroyed
+    FlagSetting preserveAssetsDuringFrame {true};
 };
 
 struct EngineSettings {