add 'offset', 'bits' properties & fix is_solid_at

src/content/ContentBuilder.cpp

@@ -37,9 +37,11 @@ std::unique_ptr<Content> ContentBuilder::build() {
         } else {
             def.defaults.rt.solid = def.defaults.model.type == BlockModelType::BLOCK;
         }
-        
+
         const float EPSILON = 0.01f;
-        def.rt.solid = glm::i8vec3(def.hitboxes[0].size() + EPSILON) == def.size;
+        def.rt.solid =
+            def.obstacle &&
+            (glm::i8vec3(def.hitboxes[0].size() + EPSILON) == def.size);
         def.rt.extended = def.size.x > 1 || def.size.y > 1 || def.size.z > 1;
 
         if (def.rotatable) {

src/content/loading/BlockLoader.cpp

@@ -121,7 +121,18 @@ template<> void ContentUnitLoader<Block>::loadUnit(
         const auto& stateBased = root["state-based"];
         if (stateBased.has("variants")) {
             const auto& variants = stateBased["variants"];
+
+            int offset = 0;
+            int bitsCount = 4;
+            stateBased.at("offset").get(offset);
+            stateBased.at("bits").get(bitsCount);
+            if (offset < 0 || bitsCount <= 0 || offset + bitsCount > 8) {
+                throw std::runtime_error("Invalid state-based bits configuration");
+            }
+
             def.variants = std::make_unique<Variants>();
+            def.variants->offset = 0;
+            def.variants->mask = 0xF;
             def.variants->variants.push_back(def.defaults);
             for (int i = 0; i < variants.size(); i++) {
                 Variant variant = def.defaults;

src/voxels/Block.hpp

@@ -161,6 +161,8 @@ struct Variant {
 };
 
 struct Variants {
+    uint8_t offset;
+    uint8_t mask;
     /// First variant is copy of Block::defaults
     util::stack_vector<Variant, BLOCK_MAX_VARIANTS> variants {};
 };
@@ -292,10 +294,12 @@ public:
 
     void cloneTo(Block& dst);
 
-    constexpr const Variant& getVariant(uint8_t bits) const {
-        if (bits == 0 || variants == nullptr)
+    constexpr const Variant& getVariant(uint8_t userbits) const {
+        if (userbits == 0 || variants == nullptr)
             return defaults;
-        return variants->variants[bits % BLOCK_MAX_VARIANTS];
+        return variants->variants[
+            (userbits >> variants->offset) & variants->mask
+        ];
     }
 
     constexpr const BlockModel& getModel(uint8_t bits) const {