src/block.hpp

   1 #ifndef BLANK_BLOCK_HPP_
   2 #define BLANK_BLOCK_HPP_
   3
   4 #include "geometry.hpp"
   5 #include "model.hpp"
   6 #include "shape.hpp"
   7
   8 #include <vector>
   9 #include <glm/glm.hpp>
  10
  11
  12 namespace blank {
  13
  14 /// single 1x1x1 cube
  15 struct Block {
  16
  17         using Type = unsigned short;
  18         using Pos = glm::vec3;
  19
  20         enum Face {
  21                 FACE_UP,
  22                 FACE_DOWN,
  23                 FACE_RIGHT,
  24                 FACE_LEFT,
  25                 FACE_FRONT,
  26                 FACE_BACK,
  27                 FACE_COUNT,
  28         };
  29         enum Turn {
  30                 TURN_NONE,
  31                 TURN_LEFT,
  32                 TURN_AROUND,
  33                 TURN_RIGHT,
  34                 TURN_COUNT,
  35         };
  36
  37         Type type;
  38         unsigned char orient;
  39
  40         constexpr explicit Block(Type type = 0, Face face = FACE_UP, Turn turn = TURN_NONE)
  41         : type(type), orient(face * TURN_COUNT + turn) { }
  42
  43         const glm::mat4 &Transform() const;
  44
  45         Face GetFace() const { return Face(orient / 4); }
  46         void SetFace(Face face) { orient = face * TURN_COUNT + GetTurn(); }
  47         Turn GetTurn() const { return Turn(orient % 4); }
  48         void SetTurn(Turn turn) { orient = GetFace() * TURN_COUNT + turn; }
  49
  50         static glm::tvec3<int> FaceNormal(Face face) {
  51                 switch (face) {
  52                         case FACE_UP:
  53                                 return { 0, 1, 0 };
  54                         case FACE_DOWN:
  55                                 return { 0, -1, 0 };
  56                         case FACE_RIGHT:
  57                                 return { 1, 0, 0 };
  58                         case FACE_LEFT:
  59                                 return { -1, 0, 0 };
  60                         case FACE_FRONT:
  61                                 return { 0, 0, 1 };
  62                         case FACE_BACK:
  63                                 return { 0, 0, -1 };
  64                         default:
  65                                 return { 0, 0, 0 };
  66                 }
  67         }
  68
  69 };
  70
  71
  72 /// attributes of a type of block
  73 struct BlockType {
  74
  75         const Shape *shape;
  76         glm::vec3 color;
  77         glm::vec3 outline_color;
  78
  79         Block::Type id;
  80
  81         int luminosity;
  82
  83         bool visible;
  84         bool block_light;
  85
  86         struct Faces {
  87                 bool face[Block::FACE_COUNT];
  88                 Faces &operator =(const Faces &other) {
  89                         for (int i = 0; i < Block::FACE_COUNT; ++i) {
  90                                 face[i] = other.face[i];
  91                         }
  92                         return *this;
  93                 }
  94                 bool operator [](Block::Face f) const {
  95                         return face[f];
  96                 }
  97         } fill;
  98
  99         explicit BlockType(
 100                 bool v = false,
 101                 const glm::vec3 &color = { 1, 1, 1 },
 102                 const Shape *shape = &DEFAULT_SHAPE
 103         );
 104
 105         static const NullShape DEFAULT_SHAPE;
 106
 107         bool FaceFilled(const Block &, Block::Face) const;
 108
 109         void FillModel(
 110                 Model::Buffer &m,
 111                 const glm::mat4 &transform = glm::mat4(1.0f),
 112                 Model::Index idx_offset = 0
 113         ) const;
 114         void FillOutlineModel(
 115                 OutlineModel &m,
 116                 const glm::vec3 &pos_offset = { 0, 0, 0 },
 117                 OutlineModel::Index idx_offset = 0
 118         ) const;
 119
 120 };
 121
 122
 123 class BlockTypeRegistry {
 124
 125 public:
 126         BlockTypeRegistry();
 127
 128 public:
 129         Block::Type Add(const BlockType &);
 130
 131         size_t Size() const { return types.size(); }
 132
 133         BlockType *operator [](Block::Type id) { return &types[id]; }
 134         const BlockType *Get(Block::Type id) const { return &types[id]; }
 135
 136 private:
 137         std::vector<BlockType> types;
 138
 139 };
 140
 141 }
 142
 143 #endif