cleanup AssetsLoader

src/assets/Assets.hpp

@@ -71,7 +71,6 @@ class Assets {
 
     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(util::ObjectsKeeper* vault);
     Assets(const Assets&) = delete;
@@ -143,16 +142,6 @@ public:
         }
         return &mapIter->second;
     }
-
-    void setup() {
-        for (auto& setupFunc : setupFuncs) {
-            setupFunc(*this);
-        }
-    }
-
-    void addSetupFunc(assetload::setupfunc setupfunc) {
-        setupFuncs.push_back(setupfunc);
-    }
 };
 
 template <class T>

src/assets/AssetsLoader.cpp

@@ -120,14 +120,6 @@ static void add_layouts(
     }
 }
 
-void AssetsLoader::tryAddSound(const std::string& name) {
-    if (name.empty()) {
-        return;
-    }
-    std::string file = SOUNDS_FOLDER + "/" + name;
-    add(AssetType::SOUND, file, name);
-}
-
 static std::string assets_def_folder(AssetType tag) {
     switch (tag) {
         case AssetType::ANIMATION:
@@ -165,7 +157,8 @@ void AssetsLoader::processPreload(
     }
     std::shared_ptr<AssetCfg> config = nullptr;
     map.at("path").get(path);
-    logger.debug() << "processing preload " << util::quote(name) << " path: " << util::quote(path);
+    logger.debug() << "processing preload " << util::quote(name)
+                   << " path: " << util::quote(path);
     switch (tag) {
         case AssetType::SOUND: {
             bool keepPCM = false;
@@ -269,65 +262,73 @@ static void add_variant(AssetsLoader& loader, const Variant& variant) {
     }
 }
 
-void AssetsLoader::addDefaults(AssetsLoader& loader, const Content* content) {
+void AssetsLoader::addDefaults(const Content* content) {
-    loader.processPreloadConfigs(content);
+    processPreloadConfigs(content);
-    if (content) {
+    if (content == nullptr) {
-        for (auto& entry : content->getBlockMaterials()) {
+        return;
-            auto& material = *entry.second;
+    }
-            loader.tryAddSound(material.stepsSound);
+    auto tryAddSound = [this](const std::string& name){
-            loader.tryAddSound(material.placeSound);
+        if (name.empty()) {
-            loader.tryAddSound(material.breakSound);
+            return;
-            loader.tryAddSound(material.hitSound);
         }
+        std::string file = SOUNDS_FOLDER + "/" + name;
+        add(AssetType::SOUND, file, name);
+    };
+    for (auto& entry : content->getBlockMaterials()) {
+        auto& material = *entry.second;
+        tryAddSound(material.stepsSound);
+        tryAddSound(material.placeSound);
+        tryAddSound(material.breakSound);
+        tryAddSound(material.hitSound);
+    }
 
-        for (auto& entry : content->getPacks()) {
+    for (auto& entry : content->getPacks()) {
-            auto pack = entry.second.get();
+        auto pack = entry.second.get();
-            auto& info = pack->getInfo();
+        auto& info = pack->getInfo();
-            io::path folder = info.folder / "layouts";
+        io::path folder = info.folder / "layouts";
-            add_layouts(pack->getEnvironment(), info.id, folder, loader);
+        add_layouts(pack->getEnvironment(), info.id, folder, *this);
-        }
+    }
 
-        for (const auto& entry : content->getPacks()) {
+    for (const auto& entry : content->getPacks()) {
-            io::path skeletonsDir = entry.first + ":skeletons";
+        io::path skeletonsDir = entry.first + ":skeletons";
-            if (!io::is_directory(skeletonsDir)) {
+        if (!io::is_directory(skeletonsDir)) {
-                continue;
+            continue;
-            }
-            for (const auto& file : io::directory_iterator(skeletonsDir)) {
-                loader.add(
-                    AssetType::SKELETON,
-                    (file.parent() / file.stem()).string(),
-                    entry.first + ":" + file.stem()
-                );
-            }
         }
+        for (const auto& file : io::directory_iterator(skeletonsDir)) {
+            add(
+                AssetType::SKELETON,
+                (file.parent() / file.stem()).string(),
+                entry.first + ":" + file.stem()
+            );
+        }
+    }
 
-        for (const auto& [_, def] : content->blocks.getDefs()) {
+    for (const auto& [_, def] : content->blocks.getDefs()) {
-            if (def->variants) {
+        if (def->variants) {
-                for (const auto& variant : def->variants->variants) {
+            for (const auto& variant : def->variants->variants) {
-                    add_variant(loader, variant);
+                add_variant(*this, variant);
-                }
-            } else {
-                add_variant(loader, def->defaults);
             }
+        } else {
+            add_variant(*this, def->defaults);
         }
-        for (const auto& [_, def] : content->items.getDefs()) {
+    }
-            if (def->modelName.find(':') == std::string::npos) {
+    for (const auto& [_, def] : content->items.getDefs()) {
-                loader.add(
+        if (def->modelName.find(':') == std::string::npos) {
-                    AssetType::MODEL,
+            add(
-                    MODELS_FOLDER + "/" + def->modelName,
+                AssetType::MODEL,
-                    def->modelName
+                MODELS_FOLDER + "/" + def->modelName,
-                );
+                def->modelName
-            }
+            );
         }
-        for (const auto& [_, def] : content->entities.getDefs()) {
+    }
-            if (def->skeletonName.find(':') == std::string::npos) {
+    for (const auto& [_, def] : content->entities.getDefs()) {
-                // expecting a VCM with skeleton
+        if (def->skeletonName.find(':') == std::string::npos) {
-                loader.add(
+            // expecting a VCM with skeleton
-                    AssetType::MODEL,
+            add(
-                    MODELS_FOLDER + "/" + def->skeletonName,
+                AssetType::MODEL,
-                    def->skeletonName
+                MODELS_FOLDER + "/" + def->skeletonName,
-                );
+                def->skeletonName
-            }
+            );
         }
     }
 }

src/assets/AssetsLoader.hpp

@@ -87,21 +87,6 @@ struct aloader_entry {
 };
 
 class AssetsLoader {
-    Engine& engine;
-    Assets& assets;
-    std::map<AssetType, aloader_func> loaders;
-    std::queue<aloader_entry> entries;
-    std::set<std::pair<AssetType, std::string>> enqueued;
-    const ResPaths& paths;
-
-    void tryAddSound(const std::string& name);
-
-    void processPreload(
-        AssetType tag, const std::string& name, const dv::value& map
-    );
-    void processPreloadList(AssetType tag, const dv::value& list);
-    void processPreloadConfig(const io::path& file);
-    void processPreloadConfigs(const Content* content);
 public:
     AssetsLoader(Engine& engine, Assets& assets, const ResPaths& paths);
     AssetsLoader(const AssetsLoader&) = delete;
@@ -132,9 +117,8 @@ public:
     aloader_func getLoader(AssetType tag);
 
     /// @brief Enqueue core and content assets
-    /// @param loader target loader
     /// @param content engine content
-    static void addDefaults(AssetsLoader& loader, const Content* content);
+    void addDefaults(const Content* content);
 
     static bool loadExternalTexture(
         AssetsLoader& loader,
@@ -144,4 +128,18 @@ public:
 
     Assets& getAssets();
     Engine& getEngine();
+private:
+    Engine& engine;
+    Assets& assets;
+    std::map<AssetType, aloader_func> loaders;
+    std::queue<aloader_entry> entries;
+    std::set<std::pair<AssetType, std::string>> enqueued;
+    const ResPaths& paths;
+
+    void processPreload(
+        AssetType tag, const std::string& name, const dv::value& map
+    );
+    void processPreloadList(AssetType tag, const dv::value& list);
+    void processPreloadConfig(const io::path& file);
+    void processPreloadConfigs(const Content* content);
 };

src/engine/AssetsManagement.cpp

@@ -53,11 +53,11 @@ void AssetsManagement::loadAssets(Content* content) {
     logger.info() << "loading assets";
     Shader::preprocessor->setPaths(&paths.resPaths);
 
-    auto new_assets = std::make_unique<Assets>(
+    auto newAssets = std::make_unique<Assets>(
         settings.system.preserveAssetsDuringFrame.get() ? &assetsVault : nullptr 
     );
-    AssetsLoader loader(engine, *new_assets, paths.resPaths);
+    AssetsLoader loader(engine, *newAssets, paths.resPaths);
-    AssetsLoader::addDefaults(loader, content);
+    loader.addDefaults(content);
 
     // no need
     // correct log messages order is more useful
@@ -73,11 +73,10 @@ void AssetsManagement::loadAssets(Content* content) {
             loader.loadNext();
         }
     }
-    assets = std::move(new_assets);
+    assets = std::move(newAssets);
     if (content) {
         ModelsGenerator::prepare(*content, *assets);
     }
-    assets->setup();
     engine.getGUI().onAssetsLoad(assets.get());
 }