src/chunk.cpp

   1 #include "chunk.hpp"
   2
   3 #include "generator.hpp"
   4
   5 #include <limits>
   6 #include <glm/gtx/transform.hpp>
   7
   8
   9 namespace {
  10
  11 blank::Model::Buffer buf;
  12
  13 }
  14
  15 namespace blank {
  16
  17 Chunk::Chunk(const BlockTypeRegistry &types)
  18 : types(&types)
  19 , blocks()
  20 , model()
  21 , position(0, 0, 0)
  22 , dirty(false) {
  23
  24 }
  25
  26 Chunk::Chunk(Chunk &&other)
  27 : types(other.types)
  28 , blocks(std::move(other.blocks))
  29 , model(std::move(other.model))
  30 , dirty(other.dirty) {
  31
  32 }
  33
  34 Chunk &Chunk::operator =(Chunk &&other) {
  35         types = other.types;
  36         blocks = std::move(other.blocks);
  37         model = std::move(other.model);
  38         dirty = other.dirty;
  39         return *this;
  40 }
  41
  42
  43 void Chunk::Allocate() {
  44         blocks.resize(Size());
  45 }
  46
  47
  48 void Chunk::Draw() {
  49         if (dirty) {
  50                 Update();
  51         }
  52         model.Draw();
  53 }
  54
  55
  56 bool Chunk::Intersection(
  57         const Ray &ray,
  58         const glm::mat4 &M,
  59         int *blkid,
  60         float *dist,
  61         glm::vec3 *normal) const {
  62         { // rough check
  63                 if (!blank::Intersection(ray, Bounds(), M)) {
  64                         return false;
  65                 }
  66         }
  67
  68         if (!blkid && !dist && !normal) {
  69                 return true;
  70         }
  71
  72         // TODO: should be possible to heavily optimize this
  73         int id = 0;
  74         int closest_id = -1;
  75         float closest_dist = std::numeric_limits<float>::infinity();
  76         glm::vec3 closest_normal(0, 1, 0);
  77         for (int z = 0; z < Depth(); ++z) {
  78                 for (int y = 0; y < Height(); ++y) {
  79                         for (int x = 0; x < Width(); ++x, ++id) {
  80                                 if (!Type(blocks[id]).visible) {
  81                                         continue;
  82                                 }
  83                                 float cur_dist;
  84                                 glm::vec3 cur_norm;
  85                                 Block::Pos pos(float(x) + 0.5f, float(y) + 0.5f, float(z) + 0.5f);
  86                                 if (Type(blocks[id]).shape->Intersects(ray, glm::translate(M, pos), cur_dist, cur_norm)) {
  87                                         if (cur_dist < closest_dist) {
  88                                                 closest_id = id;
  89                                                 closest_dist = cur_dist;
  90                                                 closest_normal = cur_norm;
  91                                         }
  92                                 }
  93                         }
  94                 }
  95         }
  96
  97         if (closest_id < 0) {
  98                 return false;
  99         }
 100
 101         if (blkid) {
 102                 *blkid = closest_id;
 103         }
 104         if (dist) {
 105                 *dist = closest_dist;
 106         }
 107         if (normal) {
 108                 *normal = closest_normal;
 109         }
 110         return true;
 111 }
 112
 113 void Chunk::Position(const Pos &pos) {
 114         position = pos;
 115 }
 116
 117 glm::mat4 Chunk::Transform(const Pos &offset) const {
 118         return glm::translate((position - offset) * Extent());
 119 }
 120
 121
 122 void Chunk::CheckUpdate() {
 123         if (dirty) {
 124                 Update();
 125         }
 126 }
 127
 128 void Chunk::Update() {
 129         int vtx_count = 0, idx_count = 0;
 130         for (const auto &block : blocks) {
 131                 const Shape *shape = Type(block).shape;
 132                 vtx_count += shape->VertexCount();
 133                 idx_count += shape->VertexIndexCount();
 134         }
 135         buf.Clear();
 136         buf.Reserve(vtx_count, idx_count);
 137
 138         Model::Index vtx_counter = 0;
 139         for (size_t i = 0; i < Size(); ++i) {
 140                 const BlockType &type = Type(blocks[i]);
 141                 type.FillModel(buf, ToCoords(i), vtx_counter);
 142                 vtx_counter += type.shape->VertexCount();
 143         }
 144
 145         model.Update(buf);
 146         dirty = false;
 147 }
 148
 149
 150 ChunkLoader::ChunkLoader(const BlockTypeRegistry &reg, const Generator &gen)
 151 : base(0, 0, 0)
 152 , reg(reg)
 153 , gen(gen)
 154 , loaded()
 155 , to_generate()
 156 , to_free()
 157 , load_dist(4)
 158 , unload_dist(5) {
 159
 160 }
 161
 162 namespace {
 163
 164 struct ChunkLess {
 165
 166         explicit ChunkLess(const Chunk::Pos &base)
 167         : base(base) { }
 168
 169         bool operator ()(const Chunk::Pos &a, const Chunk::Pos &b) const {
 170                 Chunk::Pos da(base - a);
 171                 Chunk::Pos db(base - b);
 172                 return
 173                         da.x * da.x + da.y * da.y + da.z * da.z <
 174                         db.x * db.x + db.y * db.y + db.z * db.z;
 175         }
 176
 177         Chunk::Pos base;
 178
 179 };
 180
 181 }
 182
 183 void ChunkLoader::Generate(const Chunk::Pos &from, const Chunk::Pos &to) {
 184         for (int z = from.z; z < to.z; ++z) {
 185                 for (int y = from.y; y < to.y; ++y) {
 186                         for (int x = from.x; x < to.x; ++x) {
 187                                 Chunk::Pos pos(x, y, z);
 188                                 if (Known(pos)) {
 189                                         continue;
 190                                 } else if (x == 0 && y == 0 && z == 0) {
 191                                         loaded.emplace_back(reg);
 192                                         loaded.back().Position(pos);
 193                                         gen(loaded.back());
 194                                 } else {
 195                                         to_generate.emplace_back(pos);
 196                                 }
 197                         }
 198                 }
 199         }
 200         to_generate.sort(ChunkLess(base));
 201 }
 202
 203 Chunk *ChunkLoader::Loaded(const Chunk::Pos &pos) {
 204         for (Chunk &chunk : loaded) {
 205                 if (chunk.Position() == pos) {
 206                         return &chunk;
 207                 }
 208         }
 209         return nullptr;
 210 }
 211
 212 bool ChunkLoader::Queued(const Chunk::Pos &pos) {
 213         for (const Chunk::Pos &chunk : to_generate) {
 214                 if (chunk == pos) {
 215                         return true;
 216                 }
 217         }
 218         return nullptr;
 219 }
 220
 221 bool ChunkLoader::Known(const Chunk::Pos &pos) {
 222         if (Loaded(pos)) return true;
 223         return Queued(pos);
 224 }
 225
 226 Chunk &ChunkLoader::ForceLoad(const Chunk::Pos &pos) {
 227         Chunk *chunk = Loaded(pos);
 228         if (chunk) {
 229                 return *chunk;
 230         }
 231
 232         for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end; ++iter) {
 233                 if (*iter == pos) {
 234                         to_generate.erase(iter);
 235                         break;
 236                 }
 237         }
 238
 239         loaded.emplace_back(reg);
 240         loaded.back().Position(pos);
 241         gen(loaded.back());
 242         return loaded.back();
 243 }
 244
 245 void ChunkLoader::Rebase(const Chunk::Pos &new_base) {
 246         if (new_base == base) {
 247                 return;
 248         }
 249         base = new_base;
 250
 251         // unload far away chunks
 252         for (auto iter(loaded.begin()), end(loaded.end()); iter != end;) {
 253                 if (std::abs(base.x - iter->Position().x) > unload_dist
 254                                 || std::abs(base.y - iter->Position().y) > unload_dist
 255                                 || std::abs(base.z - iter->Position().z) > unload_dist) {
 256                         auto saved = iter;
 257                         ++iter;
 258                         to_free.splice(to_free.end(), loaded, saved);
 259                 } else {
 260                         ++iter;
 261                 }
 262         }
 263         // abort far away queued chunks
 264         for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end;) {
 265                 if (std::abs(base.x - iter->x) > unload_dist
 266                                 || std::abs(base.y - iter->y) > unload_dist
 267                                 || std::abs(base.z - iter->z) > unload_dist) {
 268                         iter = to_generate.erase(iter);
 269                 } else {
 270                         ++iter;
 271                 }
 272         }
 273         // add missing new chunks
 274         const Chunk::Pos offset(load_dist, load_dist, load_dist);
 275         Generate(base - offset, base + offset);
 276 }
 277
 278 void ChunkLoader::Update() {
 279         bool reused = false;
 280         if (!to_generate.empty()) {
 281                 Chunk::Pos pos(to_generate.front());
 282
 283                 for (auto iter(to_free.begin()), end(to_free.end()); iter != end; ++iter) {
 284                         if (iter->Position() == pos) {
 285                                 loaded.splice(loaded.end(), to_free, iter);
 286                                 reused = true;
 287                                 break;
 288                         }
 289                 }
 290
 291                 if (!reused) {
 292                         if (to_free.empty()) {
 293                                 loaded.emplace_back(reg);
 294                         } else {
 295                                 loaded.splice(loaded.end(), to_free, to_free.begin());
 296                                 reused = true;
 297                         }
 298                         loaded.back().Position(pos);
 299                         gen(loaded.back());
 300                 }
 301                 to_generate.pop_front();
 302         }
 303
 304         if (!reused && !to_free.empty()) {
 305                 to_free.pop_front();
 306         }
 307 }
 308
 309 }