src/world.cpp

   1 #include "world.hpp"
   2
   3 #include <limits>
   4 #include <glm/gtx/transform.hpp>
   5
   6
   7 namespace blank {
   8
   9 const BlockType BlockType::DEFAULT;
  10 const NullShape BlockType::DEFAULT_SHAPE;
  11
  12 void BlockType::FillVBO(
  13         const glm::vec3 &pos,
  14         std::vector<glm::vec3> &vertices,
  15         std::vector<glm::vec3> &colors,
  16         std::vector<glm::vec3> &normals
  17 ) const {
  18         shape->Vertices(vertices, pos);
  19         colors.insert(colors.end(), shape->VertexCount(), color);
  20         shape->Normals(normals);
  21 }
  22
  23 void BlockType::FillOutlineVBO(
  24         std::vector<glm::vec3> &vertices,
  25         std::vector<glm::vec3> &colors
  26 ) const {
  27         shape->Outline(vertices);
  28         colors.insert(colors.end(), shape->OutlineCount(), outline_color);
  29 }
  30
  31
  32 BlockTypeRegistry::BlockTypeRegistry() {
  33         Add(BlockType::DEFAULT);
  34 }
  35
  36 int BlockTypeRegistry::Add(const BlockType &t) {
  37         int id = types.size();
  38         types.push_back(t);
  39         types.back().id = id;
  40         return id;
  41 }
  42
  43
  44 Chunk::Chunk()
  45 : blocks(Size())
  46 , model()
  47 , transform(1.0f)
  48 , dirty(false) {
  49
  50 }
  51
  52 Chunk::Chunk(Chunk &&other)
  53 : blocks(std::move(other.blocks))
  54 , model(std::move(other.model))
  55 , transform(other.transform)
  56 , dirty(other.dirty) {
  57
  58 }
  59
  60 Chunk &Chunk::operator =(Chunk &&other) {
  61         blocks = std::move(other.blocks);
  62         model = std::move(other.model);
  63         transform = other.transform;
  64         dirty = other.dirty;
  65         return *this;
  66 }
  67
  68
  69 void Chunk::Draw() {
  70         if (dirty) {
  71                 Update();
  72         }
  73         model.Draw();
  74 }
  75
  76
  77 bool Chunk::Intersection(
  78         const Ray &ray,
  79         const glm::mat4 &M,
  80         int *blkid,
  81         float *dist,
  82         glm::vec3 *normal) const {
  83         { // rough check
  84                 const AABB bb{{0, 0, 0}, {Width(), Height(), Depth()}};
  85                 if (!blank::Intersection(ray, bb, M)) {
  86                         return false;
  87                 }
  88         }
  89
  90         if (!blkid && !dist && !normal) {
  91                 return true;
  92         }
  93
  94         // TODO: should be possible to heavily optimize this
  95         int id = 0;
  96         int closest_id = -1;
  97         float closest_dist = std::numeric_limits<float>::infinity();
  98         glm::vec3 closest_normal(0, 1, 0);
  99         for (int z = 0; z < Depth(); ++z) {
 100                 for (int y = 0; y < Height(); ++y) {
 101                         for (int x = 0; x < Width(); ++x, ++id) {
 102                                 if (!blocks[id].type->visible) {
 103                                         continue;
 104                                 }
 105                                 float cur_dist;
 106                                 glm::vec3 cur_norm;
 107                                 glm::vec3 pos(float(x) + 0.5f, float(y) + 0.5f, float(z) + 0.5f);
 108                                 if (blocks[id].type->shape->Intersects(ray, glm::translate(M, pos), cur_dist, cur_norm)) {
 109                                         if (cur_dist < closest_dist) {
 110                                                 closest_id = id;
 111                                                 closest_dist = cur_dist;
 112                                                 closest_normal = cur_norm;
 113                                         }
 114                                 }
 115                         }
 116                 }
 117         }
 118
 119         if (closest_id < 0) {
 120                 return false;
 121         }
 122
 123         if (blkid) {
 124                 *blkid = closest_id;
 125         }
 126         if (dist) {
 127                 *dist = closest_dist;
 128         }
 129         if (normal) {
 130                 *normal = closest_normal;
 131         }
 132         return true;
 133 }
 134
 135 void Chunk::Position(const glm::vec3 &pos) {
 136         position = pos;
 137         transform = glm::translate(pos * Extent());
 138 }
 139
 140
 141 int Chunk::VertexCount() const {
 142         int count = 0;
 143         for (const auto &block : blocks) {
 144                 count += block.type->shape->VertexCount();
 145         }
 146         return count;
 147 }
 148
 149 void Chunk::Update() {
 150         model.Clear();
 151         model.Reserve(VertexCount());
 152
 153         for (size_t i = 0; i < Size(); ++i) {
 154                 blocks[i].type->FillModel(ToCoords(i), model);
 155         }
 156
 157         model.Invalidate();
 158         dirty = false;
 159 }
 160
 161
 162 World::World()
 163 : blockType()
 164 , blockShape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }})
 165 , stairShape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }}, { 0.0f, 0.0f })
 166 , slabShape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.0f, 0.5f }})
 167 , blockNoise(0)
 168 , colorNoise(1)
 169 , loaded()
 170 , to_generate() {
 171         blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &blockShape }); // white block
 172         blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &stairShape }); // white stair
 173         blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &slabShape }); // white slab
 174         blockType.Add(BlockType{ true, { 1.0f, 0.0f, 0.0f }, &blockShape }); // red block
 175         blockType.Add(BlockType{ true, { 1.0f, 0.0f, 0.0f }, &stairShape }); // red stair
 176         blockType.Add(BlockType{ true, { 1.0f, 0.0f, 0.0f }, &slabShape }); // red slab
 177         blockType.Add(BlockType{ true, { 0.0f, 1.0f, 0.0f }, &blockShape }); // green block
 178         blockType.Add(BlockType{ true, { 0.0f, 1.0f, 0.0f }, &stairShape }); // green stair
 179         blockType.Add(BlockType{ true, { 0.0f, 1.0f, 0.0f }, &slabShape }); // green slab
 180         blockType.Add(BlockType{ true, { 0.0f, 0.0f, 1.0f }, &blockShape }); // blue block
 181         blockType.Add(BlockType{ true, { 0.0f, 0.0f, 1.0f }, &stairShape }); // blue stair
 182         blockType.Add(BlockType{ true, { 0.0f, 0.0f, 1.0f }, &slabShape }); // blue slab
 183
 184         player.Position({ 4.0f, 4.0f, 4.0f });
 185 }
 186
 187
 188 namespace {
 189
 190 bool ChunkLess(const Chunk &a, const Chunk &b) {
 191         return dot(a.Position(), a.Position()) < dot(b.Position(), b.Position());
 192 }
 193
 194 }
 195
 196 void World::Generate(const glm::tvec3<int> &from, const glm::tvec3<int> &to) {
 197         for (int z = from.z; z < to.z; ++z) {
 198                 for (int y = from.y; y < to.y; ++y) {
 199                         for (int x = from.x; x < to.x; ++x) {
 200                                 glm::vec3 pos{float(x), float(y), float(z)};
 201                                 if (x == 0 && y == 0 && z == 0) {
 202                                         loaded.emplace_back();
 203                                         loaded.back().Position(pos);
 204                                         Generate(loaded.back());
 205                                 } else {
 206                                         to_generate.emplace_back();
 207                                         to_generate.back().Position(pos);
 208                                 }
 209                         }
 210                 }
 211         }
 212         to_generate.sort(ChunkLess);
 213 }
 214
 215 void World::Generate(Chunk &chunk) {
 216         glm::vec3 pos(chunk.Position());
 217         if (pos.x == 0 && pos.y == 0 && pos.z == 0) {
 218                 for (size_t i = 1; i < blockType.Size(); ++i) {
 219                         chunk.BlockAt(i) = Block(blockType[i]);
 220                         chunk.BlockAt(i + 257) = Block(blockType[i]);
 221                         chunk.BlockAt(i + 514) = Block(blockType[i]);
 222                 }
 223         } else {
 224                 for (int z = 0; z < Chunk::Depth(); ++z) {
 225                         for (int y = 0; y < Chunk::Height(); ++y) {
 226                                 for (int x = 0; x < Chunk::Width(); ++x) {
 227                                         glm::vec3 block_pos{float(x), float(y), float(z)};
 228                                         glm::vec3 gen_pos = (pos * Chunk::Extent() + block_pos) / 64.0f;
 229                                         float val = blockNoise(gen_pos);
 230                                         if (val > 0.8f) {
 231                                                 int col_val = int((colorNoise(gen_pos) + 1.0f) * 2.0f) % 4;
 232                                                 chunk.BlockAt(block_pos) = Block(blockType[col_val * 3 + 1]);
 233                                         }
 234                                 }
 235                         }
 236                 }
 237         }
 238         chunk.Invalidate();
 239 }
 240
 241 bool World::Intersection(
 242                 const Ray &ray,
 243                 const glm::mat4 &M,
 244                 Chunk **chunk,
 245                 int *blkid,
 246                 float *dist,
 247                 glm::vec3 *normal) {
 248         Chunk *closest_chunk = nullptr;
 249         int closest_blkid = -1;
 250         float closest_dist = std::numeric_limits<float>::infinity();
 251         glm::vec3 closest_normal;
 252
 253         for (Chunk &cur_chunk : loaded) {
 254                 int cur_blkid;
 255                 float cur_dist;
 256                 glm::vec3 cur_normal;
 257                 if (cur_chunk.Intersection(ray, M * cur_chunk.Transform(), &cur_blkid, &cur_dist, &cur_normal)) {
 258                         if (cur_dist < closest_dist) {
 259                                 closest_chunk = &cur_chunk;
 260                                 closest_blkid = cur_blkid;
 261                                 closest_dist = cur_dist;
 262                                 closest_normal = cur_normal;
 263                         }
 264                 }
 265         }
 266
 267         if (chunk) {
 268                 *chunk = closest_chunk;
 269         }
 270         if (blkid) {
 271                 *blkid = closest_blkid;
 272         }
 273         if (dist) {
 274                 *dist = closest_dist;
 275         }
 276         if (normal) {
 277                 *normal = closest_normal;
 278         }
 279         return closest_chunk;
 280 }
 281
 282
 283 Chunk &World::Next(const Chunk &to, const glm::vec3 &dir) {
 284         const glm::vec3 tgt_pos = to.Position() + dir;
 285         for (Chunk &chunk : LoadedChunks()) {
 286                 if (chunk.Position() == tgt_pos) {
 287                         return chunk;
 288                 }
 289         }
 290         for (Chunk &chunk : to_generate) {
 291                 if (chunk.Position() == tgt_pos) {
 292                         Generate(chunk);
 293                         return chunk;
 294                 }
 295         }
 296         loaded.emplace_back();
 297         loaded.back().Position(tgt_pos);
 298         Generate(loaded.back());
 299         return loaded.back();
 300 }
 301
 302
 303 void World::Update(int dt) {
 304         player.Update(dt);
 305
 306         if (!to_generate.empty()) {
 307                 Generate(to_generate.front());
 308                 loaded.splice(loaded.end(), to_generate, to_generate.begin());
 309         }
 310 }
 311
 312
 313 void World::Render(DirectionalLighting &program) {
 314         program.SetLightDirection({ -1.0f, -3.0f, -2.0f });
 315         program.SetView(glm::inverse(player.Transform()));
 316
 317         for (Chunk &chunk : LoadedChunks()) {
 318                 program.SetM(chunk.Transform());
 319                 chunk.Draw();
 320         }
 321 }
 322
 323 }