Merge branch 'main' into content-loader-refactor

src/content/Content.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <memory>
-#include <optional>
 #include <set>
 #include <stdexcept>
 #include <string>
@@ -25,23 +24,6 @@ namespace rigging {
     class SkeletonConfig;
 }
 
-constexpr const char* ContentType_name(ContentType type) {
-    switch (type) {
-        case ContentType::NONE:
-            return "none";
-        case ContentType::BLOCK:
-            return "block";
-        case ContentType::ITEM:
-            return "item";
-        case ContentType::ENTITY:
-            return "entity";
-        case ContentType::GENERATOR:
-            return "generator";
-        default:
-            return "unknown";
-    }
-}
-
 class namereuse_error : public std::runtime_error {
     ContentType type;
 public:
@@ -185,26 +167,6 @@ public:
     }
 };
 
-constexpr const char* to_string(ResourceType type) {
-    switch (type) {
-        case ResourceType::CAMERA:
-            return "camera";
-        case ResourceType::POST_EFFECT_SLOT:
-            return "post-effect-slot";
-        default:
-            return "unknown";
-    }
-}
-
-inline std::optional<ResourceType> ResourceType_from(std::string_view str) {
-    if (str == "camera") {
-        return ResourceType::CAMERA;
-    } else if (str == "post-effect-slot") {
-        return ResourceType::POST_EFFECT_SLOT;
-    }
-    return std::nullopt;
-}
-
 using ResourceIndicesSet = ResourceIndices[RESOURCE_TYPES_COUNT];
 
 /// @brief Content is a definitions repository

src/content/ContentLoader.cpp

@@ -1,3 +1,4 @@
+#define VC_ENABLE_REFLECTION
 #include "ContentLoader.hpp"
 
 #include <algorithm>
@@ -259,28 +260,25 @@ void ContentLoader::loadBlock(
     }
 
     // block model
-    std::string modelTypeName = to_string(def.model);
+    std::string modelTypeName = BlockModelMeta.getNameString(def.model);
     root.at("model").get(modelTypeName);
     root.at("model-name").get(def.modelName);
-    if (auto model = BlockModel_from(modelTypeName)) {
-        if (*model == BlockModel::custom && def.customModelRaw == nullptr) {
+    if (BlockModelMeta.getItem(modelTypeName, def.model)) {
+        if (def.model == BlockModel::custom && def.customModelRaw == nullptr) {
             if (root.has("model-primitives")) {
                 def.customModelRaw = root["model-primitives"];
             } else if (def.modelName.empty()) {
                 throw std::runtime_error(name + ": no 'model-primitives' or 'model-name' found");
             }
         }
-        def.model = *model;
     } else if (!modelTypeName.empty()) {
         logger.error() << "unknown model: " << modelTypeName;
         def.model = BlockModel::none;
     }
 
-    std::string cullingModeName = to_string(def.culling);
+    std::string cullingModeName = CullingModeMeta.getNameString(def.culling);
     root.at("culling").get(cullingModeName);
-    if (auto mode = CullingMode_from(cullingModeName)) {
-        def.culling = *mode;
-    } else {
+    if (!CullingModeMeta.getItem(cullingModeName, def.culling)) {
         logger.error() << "unknown culling mode: " << cullingModeName;
     }
 
@@ -518,9 +516,7 @@ void ContentLoader::loadEntity(
 
     std::string bodyTypeName;
     root.at("body-type").get(bodyTypeName);
-    if (auto bodyType = BodyType_from(bodyTypeName)) {
-        def.bodyType = *bodyType;
-    }
+    BodyTypeMeta.getItem(bodyTypeName, def.bodyType);
 
     root.at("skeleton-name").get(def.skeletonName);
     root.at("blocking").get(def.blocking);
@@ -749,8 +745,9 @@ void ContentLoader::load() {
     if (io::exists(resourcesFile)) {
         auto resRoot = io::read_json(resourcesFile);
         for (const auto& [key, arr] : resRoot.asObject()) {
-            if (auto resType = ResourceType_from(key)) {
-                loadResources(*resType, arr);
+            ResourceType type;
+            if (ResourceTypeMeta.getItem(key, type)) {
+                loadResources(type, arr);
             } else {
                 // Ignore unknown resources
                 logger.warning() << "unknown resource type: " << key;
@@ -763,8 +760,9 @@ void ContentLoader::load() {
     if (io::exists(aliasesFile)) {
         auto resRoot = io::read_json(aliasesFile);
         for (const auto& [key, arr] : resRoot.asObject()) {
-            if (auto resType = ResourceType_from(key)) {
-                loadResourceAliases(*resType, arr);
+            ResourceType type;
+            if (ResourceTypeMeta.getItem(key, type)) {
+                loadResourceAliases(type, arr);
             } else {
                 // Ignore unknown resources
                 logger.warning() << "unknown resource type: " << key;

src/content/content_fwd.hpp

@@ -1,12 +1,21 @@
 #pragma once
 
 #include "typedefs.hpp"
+#include "util/EnumMetadata.hpp"
 
 class Content;
 class ContentPackRuntime;
 
 enum class ContentType { NONE, BLOCK, ITEM, ENTITY, GENERATOR };
 
+VC_ENUM_METADATA(ContentType)
+    {"none", ContentType::NONE},
+    {"block", ContentType::BLOCK},
+    {"item", ContentType::ITEM},
+    {"entity", ContentType::ENTITY},
+    {"generator", ContentType::GENERATOR},
+VC_ENUM_END
+
 enum class ResourceType : size_t {
     CAMERA,
     POST_EFFECT_SLOT,
@@ -15,3 +24,8 @@ enum class ResourceType : size_t {
 
 inline constexpr auto RESOURCE_TYPES_COUNT =
     static_cast<size_t>(ResourceType::LAST) + 1;
+
+VC_ENUM_METADATA(ResourceType)
+    {"camera", ResourceType::CAMERA},
+    {"post-effect-slot", ResourceType::POST_EFFECT_SLOT},
+VC_ENUM_END

src/content/loading/GeneratorLoader.cpp

@@ -1,3 +1,4 @@
+#define VC_ENABLE_REFLECTION
 #include "../ContentLoader.hpp"
 
 #include <algorithm>
@@ -210,13 +211,9 @@ void ContentLoader::loadGenerator(
     map.at("heights-bpd").get(def.heightsBPD);
     std::string interpName;
     map.at("heights-interpolation").get(interpName);
-    if (auto interp = InterpolationType_from(interpName)) {
-        def.heightsInterpolation = *interp;
-    }
+    InterpolationTypeMeta.getItem(interpName, def.heightsInterpolation);
     map.at("biomes-interpolation").get(interpName);
-    if (auto interp = InterpolationType_from(interpName)) {
-        def.biomesInterpolation = *interp;
-    }
+    InterpolationTypeMeta.getItem(interpName, def.biomesInterpolation);
 
     map.at("sea-level").get(def.seaLevel);
     map.at("wide-structs-chunks-radius").get(def.wideStructsChunksRadius);