change rigs role from assets to content units

res/content/base/preload.json

@@ -7,9 +7,5 @@
     "models": [
         "drop-block",
         "drop-item"
-    ],
-    "rigs": [
-        "drop",
-        "drop-item"
     ]
 }

res/preload.json

@@ -9,8 +9,5 @@
         "misc/moon",
         "misc/sun",
         "gui/crosshair"
-    ],
-    "rigs": [
-        "player"
     ]
 }

src/assets/AssetsLoader.cpp

@@ -31,7 +31,6 @@ AssetsLoader::AssetsLoader(Assets* assets, const ResPaths* paths)
     addLoader(AssetType::LAYOUT, assetload::layout);
     addLoader(AssetType::SOUND, assetload::sound);
     addLoader(AssetType::MODEL, assetload::model);
-    addLoader(AssetType::RIG, assetload::rig);
 }
 
 void AssetsLoader::addLoader(AssetType tag, aloader_func func) {
@@ -102,7 +101,6 @@ static std::string assets_def_folder(AssetType tag) {
         case AssetType::LAYOUT: return LAYOUTS_FOLDER;
         case AssetType::SOUND: return SOUNDS_FOLDER;
         case AssetType::MODEL: return MODELS_FOLDER;
-        case AssetType::RIG: return RIGS_FOLDER;
     }
     return "<error>";
 }
@@ -160,7 +158,6 @@ void AssetsLoader::processPreloadConfig(const fs::path& file) {
     processPreloadList(AssetType::TEXTURE, root->list("textures"));
     processPreloadList(AssetType::SOUND, root->list("sounds"));
     processPreloadList(AssetType::MODEL, root->list("models"));
-    processPreloadList(AssetType::RIG, root->list("rigs"));
     // layouts are loaded automatically
 }
 

src/assets/AssetsLoader.hpp

@@ -26,8 +26,7 @@ enum class AssetType {
     ATLAS,
     LAYOUT,
     SOUND,
-    MODEL,
-    RIG,
+    MODEL
 };
 
 class ResPaths;

src/assets/assetload_funcs.cpp

@@ -228,27 +228,6 @@ assetload::postfunc assetload::model(
     }
 }
 
-assetload::postfunc assetload::rig(
-    AssetsLoader* loader,
-    const ResPaths* paths,
-    const std::string& file,
-    const std::string& name,
-    const std::shared_ptr<AssetCfg>&
-) {
-    auto path = paths->find(file+".json");
-    auto text = files::read_string(path);
-    try {
-        auto rig = rigging::RigConfig::parse(text, path.u8string(), name).release();
-        return [=](Assets* assets) {
-            // TODO: add models loading
-            assets->store(std::unique_ptr<rigging::RigConfig>(rig), name);
-        };
-    } catch (const parsing_error& err) {
-        std::cerr << err.errorLog() << std::endl;
-        throw;
-    }
-}
-
 static void read_anim_file(
     const std::string& animFile,
     std::vector<std::pair<std::string, int>>& frameList

src/assets/assetload_funcs.hpp

@@ -63,13 +63,6 @@ namespace assetload {
         const std::string& name,
         const std::shared_ptr<AssetCfg>& settings
     );
-    postfunc rig(
-        AssetsLoader*,
-        const ResPaths* paths,
-        const std::string& file,
-        const std::string& name,
-        const std::shared_ptr<AssetCfg>& settings
-    );
 }
 
 #endif // ASSETS_ASSET_LOADERS_HPP_

src/content/Content.cpp

@@ -8,6 +8,7 @@
 #include "../voxels/Block.hpp"
 #include "../items/ItemDef.hpp"
 #include "../objects/EntityDef.hpp"
+#include "../objects/rigging.hpp"
 
 #include "ContentPack.hpp"
 #include "../logic/scripting/scripting.hpp"
@@ -27,20 +28,30 @@ Content::Content(
     ContentUnitDefs<Block> blocks,
     ContentUnitDefs<ItemDef> items,
     ContentUnitDefs<EntityDef> entities,
-    std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>> packs,
-    std::unordered_map<std::string, std::unique_ptr<BlockMaterial>> blockMaterials
+    UptrsMap<std::string, ContentPackRuntime> packs,
+    UptrsMap<std::string, BlockMaterial> blockMaterials,
+    UptrsMap<std::string, rigging::RigConfig> rigs
 ) : indices(std::move(indices)),
     packs(std::move(packs)),
     blockMaterials(std::move(blockMaterials)),
+    rigs(std::move(rigs)),
     blocks(std::move(blocks)),
     items(std::move(items)),
     entities(std::move(entities)),
-    drawGroups(std::move(drawGroups)) 
+    drawGroups(std::move(drawGroups))
 {}
 
 Content::~Content() {
 }
 
+const rigging::RigConfig* Content::getRig(const std::string& id) const {
+    auto found = rigs.find(id);
+    if (found == rigs.end()) {
+        return nullptr;
+    }
+    return found->second.get();
+}
+
 const BlockMaterial* Content::findBlockMaterial(const std::string& id) const {
     auto found = blockMaterials.find(id);
     if (found == blockMaterials.end()) {
@@ -57,10 +68,10 @@ const ContentPackRuntime* Content::getPackRuntime(const std::string& id) const {
     return found->second.get();
 }
 
-const std::unordered_map<std::string, std::unique_ptr<BlockMaterial>>& Content::getBlockMaterials() const {
+const UptrsMap<std::string, BlockMaterial>& Content::getBlockMaterials() const {
     return blockMaterials;
 }
 
-const std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>>& Content::getPacks() const {
+const UptrsMap<std::string, ContentPackRuntime>& Content::getPacks() const {
     return packs;
 }

src/content/Content.hpp

@@ -11,6 +11,8 @@
 #include <set>
 
 using DrawGroups = std::set<ubyte>;
+template<class K, class V>
+using UptrsMap = std::unordered_map<K, std::unique_ptr<V>>;
 
 class Block;
 struct BlockMaterial;
@@ -19,6 +21,10 @@ struct EntityDef;
 class Content;
 class ContentPackRuntime;
 
+namespace rigging {
+    class RigConfig;
+}
+
 enum class contenttype {
     none, block, item, entity
 };
@@ -83,9 +89,9 @@ public:
 
 template<class T>
 class ContentUnitDefs {
-    std::unordered_map<std::string, std::unique_ptr<T>> defs;
+    UptrsMap<std::string, T> defs;
 public:
-    ContentUnitDefs(std::unordered_map<std::string, std::unique_ptr<T>> defs) 
+    ContentUnitDefs(UptrsMap<std::string, T> defs) 
     : defs(std::move(defs)) {
     }
 
@@ -108,8 +114,9 @@ public:
 /// @brief Content is a definitions repository
 class Content {
     std::unique_ptr<ContentIndices> indices;
-    std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>> packs;
-    std::unordered_map<std::string, std::unique_ptr<BlockMaterial>> blockMaterials;
+    UptrsMap<std::string, ContentPackRuntime> packs;
+    UptrsMap<std::string, BlockMaterial> blockMaterials;
+    UptrsMap<std::string, rigging::RigConfig> rigs;
 public:
     ContentUnitDefs<Block> blocks;
     ContentUnitDefs<ItemDef> items;
@@ -122,8 +129,9 @@ public:
         ContentUnitDefs<Block> blocks,
         ContentUnitDefs<ItemDef> items,
         ContentUnitDefs<EntityDef> entities,
-        std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>> packs,
-        std::unordered_map<std::string, std::unique_ptr<BlockMaterial>> blockMaterials
+        UptrsMap<std::string, ContentPackRuntime> packs,
+        UptrsMap<std::string, BlockMaterial> blockMaterials,
+        UptrsMap<std::string, rigging::RigConfig> rigs
     );
     ~Content();
 
@@ -131,11 +139,12 @@ public:
         return indices.get();
     }
 
+    const rigging::RigConfig* getRig(const std::string& id) const;
     const BlockMaterial* findBlockMaterial(const std::string& id) const;
     const ContentPackRuntime* getPackRuntime(const std::string& id) const;
 
-    const std::unordered_map<std::string, std::unique_ptr<BlockMaterial>>& getBlockMaterials() const;
-    const std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>>& getPacks() const;
+    const UptrsMap<std::string, BlockMaterial>& getBlockMaterials() const;
+    const UptrsMap<std::string, ContentPackRuntime>& getPacks() const;
 };
 
 #endif // CONTENT_CONTENT_HPP_

src/content/ContentBuilder.cpp

@@ -1,11 +1,17 @@
 #include "ContentBuilder.hpp"
 
+#include "../objects/rigging.hpp"
+
 ContentBuilder::~ContentBuilder() {}
 
 void ContentBuilder::add(std::unique_ptr<ContentPackRuntime> pack) {
     packs[pack->getId()] = std::move(pack);
 }
 
+void ContentBuilder::add(std::unique_ptr<rigging::RigConfig> rig) {
+    rigs[rig->getName()] = std::move(rig);
+}
+
 BlockMaterial& ContentBuilder::createBlockMaterial(const std::string& id) {
     blockMaterials[id] = std::make_unique<BlockMaterial>();
     auto& material = *blockMaterials[id];
@@ -68,7 +74,8 @@ std::unique_ptr<Content> ContentBuilder::build() {
         items.build(),
         entities.build(),
         std::move(packs),
-        std::move(blockMaterials)
+        std::move(blockMaterials),
+        std::move(rigs)
     );
 
     // Now, it's time to resolve foreign keys

src/content/ContentBuilder.hpp

@@ -23,7 +23,7 @@ class ContentUnitBuilder {
         }
     }
 public:
-    std::unordered_map<std::string, std::unique_ptr<T>> defs;
+    UptrsMap<std::string, T> defs;
     std::vector<std::string> names;
     
     ContentUnitBuilder(
@@ -49,8 +49,9 @@ public:
 };
 
 class ContentBuilder {
-    std::unordered_map<std::string, std::unique_ptr<BlockMaterial>> blockMaterials;
-    std::unordered_map<std::string, std::unique_ptr<ContentPackRuntime>> packs;
+    UptrsMap<std::string, BlockMaterial> blockMaterials;
+    UptrsMap<std::string, rigging::RigConfig> rigs;
+    UptrsMap<std::string, ContentPackRuntime> packs;
     std::unordered_map<std::string, contenttype> allNames;
 public:
     ContentUnitBuilder<Block> blocks {allNames, contenttype::block};
@@ -60,6 +61,7 @@ public:
     ~ContentBuilder();
 
     void add(std::unique_ptr<ContentPackRuntime> pack);
+    void add(std::unique_ptr<rigging::RigConfig> rig);
 
     BlockMaterial& createBlockMaterial(const std::string& id);
 

src/content/ContentLoader.cpp

@@ -9,6 +9,7 @@
 #include "../debug/Logger.hpp"
 #include "../files/files.hpp"
 #include "../items/ItemDef.hpp"
+#include "../objects/rigging.hpp"
 #include "../logic/scripting/scripting.hpp"
 #include "../typedefs.hpp"
 #include "../util/listutil.hpp"
@@ -458,4 +459,14 @@ void ContentLoader::load() {
             loadBlockMaterial(builder.createBlockMaterial(name), file);
         }
     }
+
+    fs::path rigsDir = folder / fs::u8path("rigs");
+    if (fs::is_directory(rigsDir)) {
+        for (const auto& entry : fs::directory_iterator(rigsDir)) {
+            const fs::path& file = entry.path();
+            std::string name = pack->id+":"+file.stem().u8string();
+            std::string text = files::read_string(file);
+            builder.add(rigging::RigConfig::parse(text, file.u8string(), name));
+        }
+    }
 }

src/logic/scripting/lua/libentity.cpp

@@ -40,7 +40,7 @@ static int l_spawn(lua::State* L) {
     Transform transform {
         pos, glm::vec3(1.0f), glm::mat3(1.0f), {}, true
     };
-    level->entities->spawn(scripting::engine->getAssets(), def, transform, args);
+    level->entities->spawn(def, transform, args);
     return 1;
 }
 
@@ -53,9 +53,8 @@ static int l_despawn(lua::State* L) {
 
 static int l_set_rig(lua::State* L) {
     if (auto entity = get_entity(L, 1)) {
-        auto assets = scripting::engine->getAssets();
         std::string rigName = lua::require_string(L, 2);
-        auto rigConfig = assets->get<rigging::RigConfig>(rigName);
+        auto rigConfig = content->getRig(rigName);
         if (rigConfig == nullptr) {
             throw std::runtime_error("rig not found '"+rigName+"'");
         }

src/objects/Entities.cpp

@@ -38,7 +38,7 @@ rigging::Rig& Entity::getModeltree() const {
     return registry.get<rigging::Rig>(entity);
 }
 
-void Entity::setRig(rigging::RigConfig* rigConfig) {
+void Entity::setRig(const rigging::RigConfig* rigConfig) {
     auto& rig = registry.get<rigging::Rig>(entity);
     rig.config = rigConfig;
     rig.pose.matrices.resize(rigConfig->getNodes().size(), glm::mat4(1.0f));
@@ -60,14 +60,13 @@ static triggercallback create_trigger_callback(Entities* entities) {
 }
 
 entityid_t Entities::spawn(
-    Assets* assets,
     EntityDef& def,
     Transform transform,
     dynamic::Value args,
     dynamic::Map_sptr saved,
     entityid_t uid)
 {
-    auto rig = assets->get<rigging::RigConfig>(def.rigName);
+    auto rig = level->content->getRig(def.rigName);
     if (rig == nullptr) {
         throw std::runtime_error("rig "+def.rigName+" not found");
     }
@@ -140,8 +139,7 @@ void Entities::loadEntity(const dynamic::Map_sptr& map) {
         dynamic::get_vec(tsfmap, "pos", transform.pos);
     }
     dynamic::Map_sptr savedMap = map->map("comps");
-    auto assets = scripting::engine->getAssets();
-    spawn(assets, def, transform, dynamic::NONE, savedMap, uid);
+    spawn(def, transform, dynamic::NONE, savedMap, uid);
 }
 
 void Entities::loadEntities(dynamic::Map_sptr root) {

src/objects/Entities.hpp

@@ -138,7 +138,7 @@ public:
 
     rigging::Rig& getModeltree() const;
 
-    void setRig(rigging::RigConfig* rigConfig);
+    void setRig(const rigging::RigConfig* rigConfig);
 
     entityid_t getUID() const {
         return registry.get<EntityId>(entity).uid;
@@ -170,7 +170,6 @@ public:
     void render(Assets* assets, ModelBatch& batch, const Frustum& frustum);
 
     entityid_t spawn(
-        Assets* assets,
         EntityDef& def,
         Transform transform,
         dynamic::Value args=dynamic::NONE,

src/objects/EntityDef.hpp

@@ -21,7 +21,7 @@ struct EntityDef {
     glm::vec3 hitbox {0.5f};
     std::vector<std::pair<size_t, AABB>> boxTriggers {};
     std::vector<std::pair<size_t, float>> radialTriggers {};
-    std::string rigName = name.substr(name.find(":") + 1);
+    std::string rigName = name;
 
     struct {
         bool enabled = true;

src/objects/rigging.hpp

@@ -64,7 +64,7 @@ namespace rigging {
     };
 
     struct Rig {
-        RigConfig* config;
+        const RigConfig* config;
         Pose pose;
         Pose calculated;
         std::unordered_map<std::string, std::string> textures;
@@ -99,7 +99,7 @@ namespace rigging {
             Rig& rig, 
             const glm::mat4& matrix) const;
 
-        Rig instance() {
+        Rig instance() const {
             return Rig {
                 this, Pose(nodes.size()), Pose(nodes.size()), {}
             };