src/world/world.cpp

   1 #include "Entity.hpp"
   2 #include "EntityState.hpp"
   3 #include "World.hpp"
   4
   5 #include "ChunkIndex.hpp"
   6 #include "EntityCollision.hpp"
   7 #include "WorldCollision.hpp"
   8 #include "../app/Assets.hpp"
   9 #include "../graphics/Format.hpp"
  10 #include "../graphics/Viewport.hpp"
  11
  12 #include <algorithm>
  13 #include <cmath>
  14 #include <limits>
  15 #include <glm/gtx/io.hpp>
  16 #include <glm/gtx/quaternion.hpp>
  17 #include <glm/gtx/transform.hpp>
  18
  19
  20 namespace blank {
  21
  22 Entity::Entity() noexcept
  23 : model()
  24 , id(-1)
  25 , name("anonymous")
  26 , bounds()
  27 , state()
  28 , ref_count(0)
  29 , world_collision(false)
  30 , dead(false) {
  31
  32 }
  33
  34
  35 void Entity::Position(const glm::ivec3 &c, const glm::vec3 &b) noexcept {
  36         state.chunk_pos = c;
  37         state.block_pos = b;
  38 }
  39
  40 void Entity::Position(const glm::vec3 &pos) noexcept {
  41         state.block_pos = pos;
  42         state.AdjustPosition();
  43 }
  44
  45 Ray Entity::Aim(const Chunk::Pos &chunk_offset) const noexcept {
  46         glm::mat4 transform = Transform(chunk_offset);
  47         glm::vec4 from = transform * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
  48         from /= from.w;
  49         glm::vec4 to = transform * glm::vec4(0.0f, 0.0f, -1.0f, 1.0f);
  50         to /= to.w;
  51         return Ray{ glm::vec3(from), glm::normalize(glm::vec3(to - from)) };
  52 }
  53
  54 namespace {
  55
  56 glm::quat delta_rot(const glm::vec3 &av, float dt) {
  57         glm::vec3 half(av * dt * 0.5f);
  58         float mag = length(half);
  59         if (mag > 0.0f) {
  60                 float smag = std::sin(mag) / mag;
  61                 return glm::quat(std::cos(mag), half * smag);
  62         } else {
  63                 return glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
  64         }
  65 }
  66
  67 }
  68
  69 void Entity::Update(int dt) noexcept {
  70         state.Update(dt);
  71 }
  72
  73
  74 EntityState::EntityState()
  75 : chunk_pos(0)
  76 , block_pos(0.0f)
  77 , velocity(0.0f)
  78 , orient(1.0f, 0.0f, 0.0f, 0.0f)
  79 , ang_vel(0.0f) {
  80
  81 }
  82
  83 void EntityState::Update(int dt) noexcept {
  84         float fdt = float(dt);
  85         block_pos += velocity * fdt;
  86         orient = delta_rot(ang_vel, fdt) * orient;
  87         AdjustPosition();
  88 }
  89
  90 void EntityState::AdjustPosition() noexcept {
  91         while (block_pos.x >= Chunk::width) {
  92                 block_pos.x -= Chunk::width;
  93                 ++chunk_pos.x;
  94         }
  95         while (block_pos.x < 0) {
  96                 block_pos.x += Chunk::width;
  97                 --chunk_pos.x;
  98         }
  99         while (block_pos.y >= Chunk::height) {
 100                 block_pos.y -= Chunk::height;
 101                 ++chunk_pos.y;
 102         }
 103         while (block_pos.y < 0) {
 104                 block_pos.y += Chunk::height;
 105                 --chunk_pos.y;
 106         }
 107         while (block_pos.z >= Chunk::depth) {
 108                 block_pos.z -= Chunk::depth;
 109                 ++chunk_pos.z;
 110         }
 111         while (block_pos.z < 0) {
 112                 block_pos.z += Chunk::depth;
 113                 --chunk_pos.z;
 114         }
 115 }
 116
 117 glm::mat4 EntityState::Transform(const glm::ivec3 &reference) const noexcept {
 118         const glm::vec3 translation = RelativePosition(reference);
 119         glm::mat4 transform(toMat4(orient));
 120         transform[3].x = translation.x;
 121         transform[3].y = translation.y;
 122         transform[3].z = translation.z;
 123         return transform;
 124 }
 125
 126
 127 World::World(const BlockTypeRegistry &types, const Config &config)
 128 : config(config)
 129 , block_type(types)
 130 , chunks(types)
 131 // TODO: set spawn base and extent from config
 132 , spawn_index(chunks.MakeIndex(Chunk::Pos(0, 0, 0), 3))
 133 , players()
 134 , entities()
 135 , light_direction(config.light_direction)
 136 , fog_density(config.fog_density) {
 137
 138 }
 139
 140 World::~World() {
 141         chunks.UnregisterIndex(spawn_index);
 142 }
 143
 144
 145 Player World::AddPlayer(const std::string &name) {
 146         for (Player &p : players) {
 147                 if (p.entity->Name() == name) {
 148                         return { nullptr, nullptr };
 149                 }
 150         }
 151         Entity &entity = AddEntity();
 152         entity.Name(name);
 153         // TODO: load from save file here
 154         entity.Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
 155         entity.WorldCollidable(true);
 156         entity.Position(config.spawn);
 157         ChunkIndex *index = &chunks.MakeIndex(entity.ChunkCoords(), 6);
 158         players.emplace_back(&entity, index);
 159         return players.back();
 160 }
 161
 162 Player World::AddPlayer(const std::string &name, std::uint32_t id) {
 163         for (Player &p : players) {
 164                 if (p.entity->Name() == name) {
 165                         return { nullptr, nullptr };
 166                 }
 167         }
 168         Entity *entity = AddEntity(id);
 169         if (!entity) {
 170                 return { nullptr, nullptr };
 171         }
 172         entity->Name(name);
 173         // TODO: load from save file here
 174         entity->Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
 175         entity->WorldCollidable(true);
 176         entity->Position(config.spawn);
 177         ChunkIndex *index = &chunks.MakeIndex(entity->ChunkCoords(), 6);
 178         players.emplace_back(entity, index);
 179         return players.back();
 180 }
 181
 182 Entity &World::AddEntity() {
 183         if (entities.empty()) {
 184                 entities.emplace_back();
 185                 entities.back().ID(1);
 186                 return entities.back();
 187         }
 188         if (entities.back().ID() < std::numeric_limits<std::uint32_t>::max()) {
 189                 std::uint32_t id = entities.back().ID() + 1;
 190                 entities.emplace_back();
 191                 entities.back().ID(id);
 192                 return entities.back();
 193         }
 194         std::uint32_t id = 1;
 195         auto position = entities.begin();
 196         auto end = entities.end();
 197         while (position != end && position->ID() == id) {
 198                 ++id;
 199                 ++position;
 200         }
 201         auto entity = entities.emplace(position);
 202         entity->ID(id);
 203         return *entity;
 204 }
 205
 206 Entity *World::AddEntity(std::uint32_t id) {
 207         if (entities.empty() || entities.back().ID() < id) {
 208                 entities.emplace_back();
 209                 entities.back().ID(id);
 210                 return &entities.back();
 211         }
 212
 213         auto position = entities.begin();
 214         auto end = entities.end();
 215         while (position != end && position->ID() < id) {
 216                 ++position;
 217         }
 218         if (position != end && position->ID() == id) {
 219                 return nullptr;
 220         }
 221         auto entity = entities.emplace(position);
 222         entity->ID(id);
 223         return &*entity;
 224 }
 225
 226 Entity &World::ForceAddEntity(std::uint32_t id) {
 227         if (entities.empty() || entities.back().ID() < id) {
 228                 entities.emplace_back();
 229                 entities.back().ID(id);
 230                 return entities.back();
 231         }
 232
 233         auto position = entities.begin();
 234         auto end = entities.end();
 235         while (position != end && position->ID() < id) {
 236                 ++position;
 237         }
 238         if (position != end && position->ID() == id) {
 239                 return *position;
 240         }
 241         auto entity = entities.emplace(position);
 242         entity->ID(id);
 243         return *entity;
 244 }
 245
 246
 247 namespace {
 248
 249 struct Candidate {
 250         Chunk *chunk;
 251         float dist;
 252 };
 253
 254 bool CandidateLess(const Candidate &a, const Candidate &b) {
 255         return a.dist < b.dist;
 256 }
 257
 258 std::vector<Candidate> candidates;
 259
 260 }
 261
 262 bool World::Intersection(
 263         const Ray &ray,
 264         const glm::mat4 &M,
 265         const Chunk::Pos &reference,
 266         WorldCollision &coll
 267 ) {
 268         candidates.clear();
 269
 270         for (Chunk &cur_chunk : chunks) {
 271                 float cur_dist;
 272                 if (cur_chunk.Intersection(ray, M * cur_chunk.Transform(reference), cur_dist)) {
 273                         candidates.push_back({ &cur_chunk, cur_dist });
 274                 }
 275         }
 276
 277         if (candidates.empty()) return false;
 278
 279         std::sort(candidates.begin(), candidates.end(), CandidateLess);
 280
 281         coll.chunk = nullptr;
 282         coll.block = -1;
 283         coll.depth = std::numeric_limits<float>::infinity();
 284
 285         for (Candidate &cand : candidates) {
 286                 if (cand.dist > coll.depth) continue;
 287                 WorldCollision cur_coll;
 288                 if (cand.chunk->Intersection(ray, M * cand.chunk->Transform(reference), cur_coll)) {
 289                         if (cur_coll.depth < coll.depth) {
 290                                 coll = cur_coll;
 291                         }
 292                 }
 293         }
 294
 295         return coll.chunk;
 296 }
 297
 298 bool World::Intersection(
 299         const Ray &ray,
 300         const glm::mat4 &M,
 301         const Entity &reference,
 302         EntityCollision &coll
 303 ) {
 304         coll.entity = nullptr;
 305         coll.depth = std::numeric_limits<float>::infinity();
 306         for (Entity &cur_entity : entities) {
 307                 if (&cur_entity == &reference) {
 308                         continue;
 309                 }
 310                 float cur_dist;
 311                 glm::vec3 cur_normal;
 312                 if (blank::Intersection(ray, cur_entity.Bounds(), M * cur_entity.Transform(reference.ChunkCoords()), &cur_dist, &cur_normal)) {
 313                         // TODO: fine grained check goes here? maybe?
 314                         if (cur_dist < coll.depth) {
 315                                 coll.entity = &cur_entity;
 316                                 coll.depth = cur_dist;
 317                                 coll.normal = cur_normal;
 318                         }
 319                 }
 320         }
 321
 322         return coll.entity;
 323 }
 324
 325 bool World::Intersection(const Entity &e, std::vector<WorldCollision> &col) {
 326         AABB box = e.Bounds();
 327         Chunk::Pos reference = e.ChunkCoords();
 328         glm::mat4 M = e.Transform(reference);
 329         bool any = false;
 330         for (Chunk &cur_chunk : chunks) {
 331                 if (manhattan_radius(cur_chunk.Position() - e.ChunkCoords()) > 1) {
 332                         // chunk is not one of the 3x3x3 surrounding the entity
 333                         // since there's no entity which can extent over 16 blocks, they can be skipped
 334                         continue;
 335                 }
 336                 if (cur_chunk.Intersection(box, M, cur_chunk.Transform(reference), col)) {
 337                         any = true;
 338                 }
 339         }
 340         return any;
 341 }
 342
 343
 344 namespace {
 345
 346 std::vector<WorldCollision> col;
 347
 348 }
 349
 350 void World::Update(int dt) {
 351         for (Entity &entity : entities) {
 352                 entity.Update(dt);
 353         }
 354         for (Entity &entity : entities) {
 355                 col.clear();
 356                 if (entity.WorldCollidable() && Intersection(entity, col)) {
 357                         // entity collides with the world
 358                         Resolve(entity, col);
 359                 }
 360         }
 361         for (Player &player : players) {
 362                 player.chunks->Rebase(player.entity->ChunkCoords());
 363         }
 364         for (auto iter = entities.begin(), end = entities.end(); iter != end;) {
 365                 if (iter->CanRemove()) {
 366                         iter = RemoveEntity(iter);
 367                 } else {
 368                         ++iter;
 369                 }
 370         }
 371 }
 372
 373 void World::Resolve(Entity &e, std::vector<WorldCollision> &col) {
 374         // determine displacement for each cardinal axis and move entity accordingly
 375         glm::vec3 min_disp(0.0f);
 376         glm::vec3 max_disp(0.0f);
 377         for (const WorldCollision &c : col) {
 378                 if (!c.Blocks()) continue;
 379                 glm::vec3 local_disp(c.normal * c.depth);
 380                 // swap if neccessary (normal may point away from the entity)
 381                 if (dot(c.normal, e.Position() - c.BlockCoords()) < 0) {
 382                         local_disp *= -1;
 383                 }
 384                 min_disp = min(min_disp, local_disp);
 385                 max_disp = max(max_disp, local_disp);
 386         }
 387         // for each axis
 388         // if only one direction is set, use that as the final
 389         // if both directions are set, use average
 390         glm::vec3 final_disp(0.0f);
 391         for (int axis = 0; axis < 3; ++axis) {
 392                 if (std::abs(min_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 393                         if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 394                                 final_disp[axis] = (min_disp[axis] + max_disp[axis]) * 0.5f;
 395                         } else {
 396                                 final_disp[axis] = min_disp[axis];
 397                         }
 398                 } else if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 399                         final_disp[axis] = max_disp[axis];
 400                 }
 401         }
 402         e.Position(e.Position() + final_disp);
 403 }
 404
 405 World::EntityHandle World::RemoveEntity(EntityHandle &eh) {
 406         // check for player
 407         for (auto player = players.begin(), end = players.end(); player != end;) {
 408                 if (player->entity == &*eh) {
 409                         chunks.UnregisterIndex(*player->chunks);
 410                         player = players.erase(player);
 411                         end = players.end();
 412                 } else {
 413                         ++player;
 414                 }
 415         }
 416         return entities.erase(eh);
 417 }
 418
 419
 420 void World::Render(Viewport &viewport) {
 421         DirectionalLighting &entity_prog = viewport.EntityProgram();
 422         entity_prog.SetLightDirection(light_direction);
 423         entity_prog.SetFogDensity(fog_density);
 424
 425         for (Entity &entity : entities) {
 426                 entity.Render(entity.Transform(players[0].entity->ChunkCoords()), entity_prog);
 427         }
 428 }
 429
 430 }