feat: item models generation simple & remove core:item_models

src/graphics/core/Model.cpp

@@ -29,6 +29,11 @@ void Mesh::addBox(glm::vec3 pos, glm::vec3 size) {
     addPlane(pos-X*size, Z*size, Y*size, -X);
 }
 
+void Mesh::scale(const glm::vec3& size) {
+    for (auto& vertex : vertices) {
+        vertex.coord *= size;
+    }
+}
 
 void Model::clean() {
     meshes.erase(

src/graphics/core/Model.hpp

@@ -17,6 +17,7 @@ namespace model {
     
         void addPlane(glm::vec3 pos, glm::vec3 right, glm::vec3 up, glm::vec3 norm);
         void addBox(glm::vec3 pos, glm::vec3 size);
+        void scale(const glm::vec3& size);
     };
 
     struct Model {

src/graphics/render/ModelsGenerator.cpp

@@ -0,0 +1,71 @@
+#include "ModelsGenerator.hpp"
+
+#include "assets/Assets.hpp"
+#include "items/ItemDef.hpp"
+#include "voxels/Block.hpp"
+#include "content/Content.hpp"
+#include "debug/Logger.hpp"
+
+static debug::Logger logger("models-generator");
+
+static void configure_textures(
+    model::Model& model,
+    const Block& blockDef,
+    const Assets& assets
+) {
+    for (auto& mesh : model.meshes) {
+        auto& texture = mesh.texture;
+        if (texture.empty() || texture.at(0) != '$') {
+            continue;
+        }
+        try {
+            int index = std::stoi(texture.substr(1));
+            texture = "blocks:"+blockDef.textureFaces.at(index);
+        } catch (const std::invalid_argument& err) {
+        } catch (const std::runtime_error& err) {
+            logger.error() << err.what();
+        }
+    }
+}
+
+static model::Model create_flat_model(
+    const std::string& texture, const Assets& assets
+) {
+    auto model = assets.require<model::Model>("drop-item");
+    for (auto& mesh : model.meshes) {
+        if (mesh.texture == "$0") {
+            mesh.texture = texture;
+        }
+    }
+    return model;
+}
+
+model::Model ModelsGenerator::generate(
+    const ItemDef& def, const Content& content, const Assets& assets
+) {
+    if (def.iconType == ItemIconType::BLOCK) {
+        auto model = assets.require<model::Model>("block");
+        const auto& blockDef = content.blocks.require(def.icon);
+        if (blockDef.model == BlockModel::xsprite) {
+            return create_flat_model(
+                "blocks:" + blockDef.textureFaces.at(0), assets
+            );
+        }
+        for (auto& mesh : model.meshes) {
+            switch (blockDef.model) {
+                case BlockModel::aabb:
+                    mesh.scale(blockDef.hitboxes.at(0).size());
+                    break;
+                default:
+                    break;
+            }
+            mesh.scale(glm::vec3(0.3f));
+        }
+        configure_textures(model, blockDef, assets);
+        return model;
+    } else if (def.iconType == ItemIconType::SPRITE) {
+        return create_flat_model(def.icon, assets);
+    } else {
+        return model::Model();
+    }
+}

src/graphics/render/ModelsGenerator.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "graphics/core/Model.hpp"
+
+struct ItemDef;
+class Assets;
+class Content;
+
+class ModelsGenerator {
+public:
+    static model::Model generate(
+        const ItemDef& def, const Content& content, const Assets& assets
+    );
+};

src/graphics/ui/elements/InventoryView.cpp

@@ -161,9 +161,9 @@ void SlotView::draw(const DrawContext* pctx, Assets* assets) {
 
     auto& item = indices->items.require(stack.getItemId());
     switch (item.iconType) {
-        case item_icon_type::none:
+        case ItemIconType::NONE:
             break;
-        case item_icon_type::block: {
+        case ItemIconType::BLOCK: {
             const Block& cblock = content->blocks.require(item.icon);
             batch->texture(previews->getTexture());
 
@@ -173,7 +173,7 @@ void SlotView::draw(const DrawContext* pctx, Assets* assets) {
                 0, 0, 0, region, false, true, tint);
             break;
         }
-        case item_icon_type::sprite: {
+        case ItemIconType::SPRITE: {
             size_t index = item.icon.find(':');
             std::string name = item.icon.substr(index+1);
             UVRegion region(0.0f, 0.0, 1.0f, 1.0f);