VariantBlock.h

#pragma once
 
#include <block/Block.h>
#include <block/Geometry.h>
 
#include <initializer_list>
#include <vector>
 
namespace engine {
 
    class VariantBlock : public Block {
      public:
        static constexpr bool isValidRotationMode(RotationMode mode) {
            return mode != RotationMode::AxisY && mode != RotationMode::AxisXYZ;
        }
 
        struct Condition {
            Side direction;
            std::vector<BlockID> blockIDs;  // unordered_set is more correct, but vector is faster
            std::vector<glm::vec3> requiredFacings;  // Optional: if empty, any rotation is valid
 
            bool operator==(const Condition& other) const {
                return direction == other.direction && blockIDs == other.blockIDs &&
                       requiredFacings == other.requiredFacings;
            }
        };
 
        struct Variant {
            Geometry geometry;
            std::vector<Condition> conditions;
 
            bool operator==(const Variant& other) const {
                return geometry.getID() == other.geometry.getID() && conditions == other.conditions;
            }
        };
 
        struct Neighbours {
            BlockID north;
            BlockID south;
            BlockID east;
            BlockID west;
            BlockID up;
            BlockID down;
 
            glm::vec3 northFacing;
            glm::vec3 southFacing;
            glm::vec3 eastFacing;
            glm::vec3 westFacing;
            glm::vec3 upFacing;
            glm::vec3 downFacing;
 
            BlockID operator[](Side direction) const;
            glm::vec3 getFacing(Side direction) const;
            void rotate(Side from, Side to);
        };
 
        VariantBlock(
            BlockID id,
            Layer layer,
            const Geometry* baseGeo,
            RotationMode rotationMode,
            int variantCount
        );
        ~VariantBlock() override = default;
 
 
        VariantBlock& allowMultiple(bool allowMultiple);
        bool allowMultiple() const { return m_allowMultiple; }
 
        VariantBlock& alwaysUseBaseGeometry(bool alwaysUseBaseGeometry);
        bool alwaysUseBaseGeometry() const { return m_alwaysUseBaseGeometry; }
 
        VariantBlock& addVariant(
            const Geometry& geometry, std::initializer_list<Condition> conditions
        );
 
        VariantBlock& addVariant(Variant&& variant);
 
        const Variant* getVariant(const Neighbours& neighbours) const;
 
        std::vector<const Variant*> getVariants(const Neighbours& neighbours) const;
 
        std::vector<const Geometry*> getGeometries(const Neighbours& neighbours) const;
 
      private:
        // variant count is small, vector is faster than unordered_set
        std::vector<Variant> m_variants;
        bool m_allowMultiple = false;
        bool m_alwaysUseBaseGeometry = false;
 
        bool checkConditions(
            const std::vector<Condition>& conditions, const Neighbours& neighbours
        ) const;
    };
}  // namespace engine