src/world/World.cpp

   1 #include "World.hpp"
   2
   3 #include "ChunkIndex.hpp"
   4 #include "EntityCollision.hpp"
   5 #include "WorldCollision.hpp"
   6 #include "../app/Assets.hpp"
   7 #include "../graphics/Format.hpp"
   8 #include "../graphics/Viewport.hpp"
   9
  10 #include <algorithm>
  11 #include <limits>
  12 #include <glm/gtx/io.hpp>
  13 #include <glm/gtx/transform.hpp>
  14
  15
  16 namespace blank {
  17
  18 World::World(const BlockTypeRegistry &types, const Config &config)
  19 : config(config)
  20 , block_type(types)
  21 , chunks(types)
  22 // TODO: set spawn base and extent from config
  23 , spawn_index(chunks.MakeIndex(Chunk::Pos(0, 0, 0), 3))
  24 , players()
  25 , entities()
  26 , light_direction(config.light_direction)
  27 , fog_density(config.fog_density) {
  28
  29 }
  30
  31 World::~World() {
  32         chunks.UnregisterIndex(spawn_index);
  33 }
  34
  35
  36 Player World::AddPlayer(const std::string &name) {
  37         for (Player &p : players) {
  38                 if (p.entity->Name() == name) {
  39                         return { nullptr, nullptr };
  40                 }
  41         }
  42         Entity &entity = AddEntity();
  43         entity.Name(name);
  44         // TODO: load from save file here
  45         entity.Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
  46         entity.WorldCollidable(true);
  47         entity.Position(config.spawn);
  48         ChunkIndex *index = &chunks.MakeIndex(entity.ChunkCoords(), 6);
  49         players.emplace_back(&entity, index);
  50         return players.back();
  51 }
  52
  53 Player World::AddPlayer(const std::string &name, std::uint32_t id) {
  54         for (Player &p : players) {
  55                 if (p.entity->Name() == name) {
  56                         return { nullptr, nullptr };
  57                 }
  58         }
  59         Entity *entity = AddEntity(id);
  60         if (!entity) {
  61                 return { nullptr, nullptr };
  62         }
  63         entity->Name(name);
  64         // TODO: load from save file here
  65         entity->Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
  66         entity->WorldCollidable(true);
  67         entity->Position(config.spawn);
  68         ChunkIndex *index = &chunks.MakeIndex(entity->ChunkCoords(), 6);
  69         players.emplace_back(entity, index);
  70         return players.back();
  71 }
  72
  73 Entity &World::AddEntity() {
  74         if (entities.empty()) {
  75                 entities.emplace_back();
  76                 entities.back().ID(1);
  77                 return entities.back();
  78         }
  79         if (entities.back().ID() < std::numeric_limits<std::uint32_t>::max()) {
  80                 std::uint32_t id = entities.back().ID() + 1;
  81                 entities.emplace_back();
  82                 entities.back().ID(id);
  83                 return entities.back();
  84         }
  85         std::uint32_t id = 1;
  86         auto position = entities.begin();
  87         auto end = entities.end();
  88         while (position != end && position->ID() == id) {
  89                 ++id;
  90                 ++position;
  91         }
  92         auto entity = entities.emplace(position);
  93         entity->ID(id);
  94         return *entity;
  95 }
  96
  97 Entity *World::AddEntity(std::uint32_t id) {
  98         if (entities.empty() || entities.back().ID() < id) {
  99                 entities.emplace_back();
 100                 entities.back().ID(id);
 101                 return &entities.back();
 102         }
 103
 104         auto position = entities.begin();
 105         auto end = entities.end();
 106         while (position != end && position->ID() < id) {
 107                 ++position;
 108         }
 109         if (position != end && position->ID() == id) {
 110                 return nullptr;
 111         }
 112         auto entity = entities.emplace(position);
 113         entity->ID(id);
 114         return &*entity;
 115 }
 116
 117
 118 namespace {
 119
 120 struct Candidate {
 121         Chunk *chunk;
 122         float dist;
 123 };
 124
 125 bool CandidateLess(const Candidate &a, const Candidate &b) {
 126         return a.dist < b.dist;
 127 }
 128
 129 std::vector<Candidate> candidates;
 130
 131 }
 132
 133 bool World::Intersection(
 134         const Ray &ray,
 135         const glm::mat4 &M,
 136         const Chunk::Pos &reference,
 137         WorldCollision &coll
 138 ) {
 139         candidates.clear();
 140
 141         for (Chunk &cur_chunk : chunks) {
 142                 float cur_dist;
 143                 if (cur_chunk.Intersection(ray, M * cur_chunk.Transform(reference), cur_dist)) {
 144                         candidates.push_back({ &cur_chunk, cur_dist });
 145                 }
 146         }
 147
 148         if (candidates.empty()) return false;
 149
 150         std::sort(candidates.begin(), candidates.end(), CandidateLess);
 151
 152         coll.chunk = nullptr;
 153         coll.block = -1;
 154         coll.depth = std::numeric_limits<float>::infinity();
 155
 156         for (Candidate &cand : candidates) {
 157                 if (cand.dist > coll.depth) continue;
 158                 WorldCollision cur_coll;
 159                 if (cand.chunk->Intersection(ray, M * cand.chunk->Transform(reference), cur_coll)) {
 160                         if (cur_coll.depth < coll.depth) {
 161                                 coll = cur_coll;
 162                         }
 163                 }
 164         }
 165
 166         return coll.chunk;
 167 }
 168
 169 bool World::Intersection(
 170         const Ray &ray,
 171         const glm::mat4 &M,
 172         const Entity &reference,
 173         EntityCollision &coll
 174 ) {
 175         coll.entity = nullptr;
 176         coll.depth = std::numeric_limits<float>::infinity();
 177         for (Entity &cur_entity : entities) {
 178                 if (&cur_entity == &reference) {
 179                         continue;
 180                 }
 181                 float cur_dist;
 182                 glm::vec3 cur_normal;
 183                 if (blank::Intersection(ray, cur_entity.Bounds(), M * cur_entity.Transform(reference.ChunkCoords()), &cur_dist, &cur_normal)) {
 184                         // TODO: fine grained check goes here? maybe?
 185                         if (cur_dist < coll.depth) {
 186                                 coll.entity = &cur_entity;
 187                                 coll.depth = cur_dist;
 188                                 coll.normal = cur_normal;
 189                         }
 190                 }
 191         }
 192
 193         return coll.entity;
 194 }
 195
 196 bool World::Intersection(const Entity &e, std::vector<WorldCollision> &col) {
 197         AABB box = e.Bounds();
 198         Chunk::Pos reference = e.ChunkCoords();
 199         glm::mat4 M = e.Transform(reference);
 200         bool any = false;
 201         for (Chunk &cur_chunk : chunks) {
 202                 if (manhattan_radius(cur_chunk.Position() - e.ChunkCoords()) > 1) {
 203                         // chunk is not one of the 3x3x3 surrounding the entity
 204                         // since there's no entity which can extent over 16 blocks, they can be skipped
 205                         continue;
 206                 }
 207                 if (cur_chunk.Intersection(box, M, cur_chunk.Transform(reference), col)) {
 208                         any = true;
 209                 }
 210         }
 211         return any;
 212 }
 213
 214
 215 namespace {
 216
 217 std::vector<WorldCollision> col;
 218
 219 }
 220
 221 void World::Update(int dt) {
 222         for (Entity &entity : entities) {
 223                 entity.Update(dt);
 224         }
 225         for (Entity &entity : entities) {
 226                 col.clear();
 227                 if (entity.WorldCollidable() && Intersection(entity, col)) {
 228                         // entity collides with the world
 229                         Resolve(entity, col);
 230                 }
 231         }
 232         for (Player &player : players) {
 233                 player.chunks->Rebase(player.entity->ChunkCoords());
 234         }
 235         for (auto iter = entities.begin(), end = entities.end(); iter != end;) {
 236                 if (iter->CanRemove()) {
 237                         iter = RemoveEntity(iter);
 238                 } else {
 239                         ++iter;
 240                 }
 241         }
 242 }
 243
 244 void World::Resolve(Entity &e, std::vector<WorldCollision> &col) {
 245         // determine displacement for each cardinal axis and move entity accordingly
 246         glm::vec3 min_disp(0.0f);
 247         glm::vec3 max_disp(0.0f);
 248         for (const WorldCollision &c : col) {
 249                 if (!c.Blocks()) continue;
 250                 glm::vec3 local_disp(c.normal * c.depth);
 251                 // swap if neccessary (normal may point away from the entity)
 252                 if (dot(c.normal, e.Position() - c.BlockCoords()) < 0) {
 253                         local_disp *= -1;
 254                 }
 255                 min_disp = min(min_disp, local_disp);
 256                 max_disp = max(max_disp, local_disp);
 257         }
 258         // for each axis
 259         // if only one direction is set, use that as the final
 260         // if both directions are set, use average
 261         glm::vec3 final_disp(0.0f);
 262         for (int axis = 0; axis < 3; ++axis) {
 263                 if (std::abs(min_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 264                         if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 265                                 final_disp[axis] = (min_disp[axis] + max_disp[axis]) * 0.5f;
 266                         } else {
 267                                 final_disp[axis] = min_disp[axis];
 268                         }
 269                 } else if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
 270                         final_disp[axis] = max_disp[axis];
 271                 }
 272         }
 273         e.Move(final_disp);
 274 }
 275
 276 World::EntityHandle World::RemoveEntity(EntityHandle &eh) {
 277         // check for player
 278         for (auto player = players.begin(), end = players.end(); player != end;) {
 279                 if (player->entity == &*eh) {
 280                         chunks.UnregisterIndex(*player->chunks);
 281                         player = players.erase(player);
 282                 } else {
 283                         ++player;
 284                 }
 285         }
 286         return entities.erase(eh);
 287 }
 288
 289
 290 void World::Render(Viewport &viewport) {
 291         DirectionalLighting &entity_prog = viewport.EntityProgram();
 292         entity_prog.SetLightDirection(light_direction);
 293         entity_prog.SetFogDensity(fog_density);
 294
 295         for (Entity &entity : entities) {
 296                 entity.Render(entity.ChunkTransform(players[0].entity->ChunkCoords()), entity_prog);
 297         }
 298 }
 299
 300 }