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                                 if (Type(blocks[id]).shape->Intersects(ray, M * ToTransform(id), cur_dist, cur_norm)) {
  86                                         if (cur_dist < closest_dist) {
  87                                                 closest_id = id;
  88                                                 closest_dist = cur_dist;
  89                                                 closest_normal = cur_norm;
  90                                         }
  91                                 }
  92                         }
  93                 }
  94         }
  95
  96         if (closest_id < 0) {
  97                 return false;
  98         }
  99
 100         if (blkid) {
 101                 *blkid = closest_id;
 102         }
 103         if (dist) {
 104                 *dist = closest_dist;
 105         }
 106         if (normal) {
 107                 *normal = closest_normal;
 108         }
 109         return true;
 110 }
 111
 112 void Chunk::Position(const Pos &pos) {
 113         position = pos;
 114 }
 115
 116 glm::mat4 Chunk::Transform(const Pos &offset) const {
 117         return glm::translate((position - offset) * Extent());
 118 }
 119
 120
 121 void Chunk::CheckUpdate() {
 122         if (dirty) {
 123                 Update();
 124         }
 125 }
 126
 127 void Chunk::Update() {
 128         int vtx_count = 0, idx_count = 0;
 129         for (const auto &block : blocks) {
 130                 const Shape *shape = Type(block).shape;
 131                 vtx_count += shape->VertexCount();
 132                 idx_count += shape->VertexIndexCount();
 133         }
 134         buf.Clear();
 135         buf.Reserve(vtx_count, idx_count);
 136
 137         Model::Index vtx_counter = 0;
 138         for (size_t i = 0; i < Size(); ++i) {
 139                 if (Obstructed(i)) continue;
 140
 141                 const BlockType &type = Type(blocks[i]);
 142                 type.FillModel(buf, ToTransform(i), vtx_counter);
 143                 vtx_counter += type.shape->VertexCount();
 144         }
 145
 146         model.Update(buf);
 147         dirty = false;
 148 }
 149
 150 bool Chunk::Obstructed(int idx) const {
 151         if (IsBorder(idx)) return false;
 152
 153         // not checking neighbor visibility here, so all
 154         // invisible blocks must have their fill set to 6x false
 155         // (the default, so should be okay)
 156
 157         const BlockType &right = Type(blocks[idx + 1]);
 158         if (!right.fill.left) return false;
 159
 160         const BlockType &left = Type(blocks[idx - 1]);
 161         if (!left.fill.right) return false;
 162
 163         const BlockType &top = Type(blocks[idx + Width()]);
 164         if (!top.fill.bottom) return false;
 165
 166         const BlockType &bottom = Type(blocks[idx - Width()]);
 167         if (!bottom.fill.top) return false;
 168
 169         const BlockType &front = Type(blocks[idx + Width() * Height()]);
 170         if (!front.fill.back) return false;
 171
 172         const BlockType &back = Type(blocks[idx - Width() * Height()]);
 173         if (!back.fill.front) return false;
 174
 175         return true;
 176 }
 177
 178 glm::mat4 Chunk::ToTransform(int idx) const {
 179         return glm::translate(glm::mat4(1.0f), ToCoords(idx)) * blocks[idx].Transform();
 180 }
 181
 182
 183 ChunkLoader::ChunkLoader(const BlockTypeRegistry &reg, const Generator &gen)
 184 : base(0, 0, 0)
 185 , reg(reg)
 186 , gen(gen)
 187 , loaded()
 188 , to_generate()
 189 , to_free()
 190 , load_dist(4)
 191 , unload_dist(5) {
 192
 193 }
 194
 195 namespace {
 196
 197 struct ChunkLess {
 198
 199         explicit ChunkLess(const Chunk::Pos &base)
 200         : base(base) { }
 201
 202         bool operator ()(const Chunk::Pos &a, const Chunk::Pos &b) const {
 203                 Chunk::Pos da(base - a);
 204                 Chunk::Pos db(base - b);
 205                 return
 206                         da.x * da.x + da.y * da.y + da.z * da.z <
 207                         db.x * db.x + db.y * db.y + db.z * db.z;
 208         }
 209
 210         Chunk::Pos base;
 211
 212 };
 213
 214 }
 215
 216 void ChunkLoader::Generate(const Chunk::Pos &from, const Chunk::Pos &to) {
 217         for (int z = from.z; z < to.z; ++z) {
 218                 for (int y = from.y; y < to.y; ++y) {
 219                         for (int x = from.x; x < to.x; ++x) {
 220                                 Chunk::Pos pos(x, y, z);
 221                                 if (Known(pos)) {
 222                                         continue;
 223                                 } else if (x == 0 && y == 0 && z == 0) {
 224                                         loaded.emplace_back(reg);
 225                                         loaded.back().Position(pos);
 226                                         gen(loaded.back());
 227                                 } else {
 228                                         to_generate.emplace_back(pos);
 229                                 }
 230                         }
 231                 }
 232         }
 233         to_generate.sort(ChunkLess(base));
 234 }
 235
 236 Chunk *ChunkLoader::Loaded(const Chunk::Pos &pos) {
 237         for (Chunk &chunk : loaded) {
 238                 if (chunk.Position() == pos) {
 239                         return &chunk;
 240                 }
 241         }
 242         return nullptr;
 243 }
 244
 245 bool ChunkLoader::Queued(const Chunk::Pos &pos) {
 246         for (const Chunk::Pos &chunk : to_generate) {
 247                 if (chunk == pos) {
 248                         return true;
 249                 }
 250         }
 251         return nullptr;
 252 }
 253
 254 bool ChunkLoader::Known(const Chunk::Pos &pos) {
 255         if (Loaded(pos)) return true;
 256         return Queued(pos);
 257 }
 258
 259 Chunk &ChunkLoader::ForceLoad(const Chunk::Pos &pos) {
 260         Chunk *chunk = Loaded(pos);
 261         if (chunk) {
 262                 return *chunk;
 263         }
 264
 265         for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end; ++iter) {
 266                 if (*iter == pos) {
 267                         to_generate.erase(iter);
 268                         break;
 269                 }
 270         }
 271
 272         loaded.emplace_back(reg);
 273         loaded.back().Position(pos);
 274         gen(loaded.back());
 275         return loaded.back();
 276 }
 277
 278 void ChunkLoader::Rebase(const Chunk::Pos &new_base) {
 279         if (new_base == base) {
 280                 return;
 281         }
 282         base = new_base;
 283
 284         // unload far away chunks
 285         for (auto iter(loaded.begin()), end(loaded.end()); iter != end;) {
 286                 if (std::abs(base.x - iter->Position().x) > unload_dist
 287                                 || std::abs(base.y - iter->Position().y) > unload_dist
 288                                 || std::abs(base.z - iter->Position().z) > unload_dist) {
 289                         auto saved = iter;
 290                         ++iter;
 291                         to_free.splice(to_free.end(), loaded, saved);
 292                 } else {
 293                         ++iter;
 294                 }
 295         }
 296         // abort far away queued chunks
 297         for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end;) {
 298                 if (std::abs(base.x - iter->x) > unload_dist
 299                                 || std::abs(base.y - iter->y) > unload_dist
 300                                 || std::abs(base.z - iter->z) > unload_dist) {
 301                         iter = to_generate.erase(iter);
 302                 } else {
 303                         ++iter;
 304                 }
 305         }
 306         // add missing new chunks
 307         const Chunk::Pos offset(load_dist, load_dist, load_dist);
 308         Generate(base - offset, base + offset);
 309 }
 310
 311 void ChunkLoader::Update() {
 312         bool reused = false;
 313         if (!to_generate.empty()) {
 314                 Chunk::Pos pos(to_generate.front());
 315
 316                 for (auto iter(to_free.begin()), end(to_free.end()); iter != end; ++iter) {
 317                         if (iter->Position() == pos) {
 318                                 loaded.splice(loaded.end(), to_free, iter);
 319                                 reused = true;
 320                                 break;
 321                         }
 322                 }
 323
 324                 if (!reused) {
 325                         if (to_free.empty()) {
 326                                 loaded.emplace_back(reg);
 327                         } else {
 328                                 loaded.splice(loaded.end(), to_free, to_free.begin());
 329                                 reused = true;
 330                         }
 331                         loaded.back().Position(pos);
 332                         gen(loaded.back());
 333                 }
 334                 to_generate.pop_front();
 335         }
 336
 337         if (!reused && !to_free.empty()) {
 338                 to_free.pop_front();
 339         }
 340 }
 341
 342 }