try to cleanly destruct world

[blank.git] / src / world / world.cpp

diff --git a/src/world/world.cpp b/src/world/world.cpp
index 937203190ff1b3879b64a5339f5e540b222e3ff8..738fa4ad9b06bb7256f66886bfeca86bd5e3bd2c 100644 (file)
--- a/src/world/world.cpp
+++ b/src/world/world.cpp
@@ -33,6 +33,7 @@ Entity::Entity() noexcept
 , id(-1)
 , name("anonymous")
 , bounds()
+, radius(0.0f)
 , state()
 , heading(0.0f, 0.0f, -1.0f)
 , max_vel(5.0f)
@@ -96,12 +97,12 @@ glm::vec3 Entity::ControlForce(const EntityState &s) const noexcept {
 }
 
 void Entity::Position(const glm::ivec3 &c, const glm::vec3 &b) noexcept {
-       state.chunk_pos = c;
-       state.block_pos = b;
+       state.pos.chunk = c;
+       state.pos.block = b;
 }
 
 void Entity::Position(const glm::vec3 &pos) noexcept {
-       state.block_pos = pos;
+       state.pos.block = pos;
        state.AdjustPosition();
 }
 
@@ -115,14 +116,14 @@ void Entity::SetHead(float p, float y) noexcept {
 }
 
 glm::mat4 Entity::Transform(const glm::ivec3 &reference) const noexcept {
-       return glm::translate(glm::vec3((state.chunk_pos - reference) * Chunk::Extent())) * model_transform;
+       return glm::translate(glm::vec3((state.pos.chunk - reference) * ExactLocation::Extent())) * model_transform;
 }
 
 glm::mat4 Entity::ViewTransform(const glm::ivec3 &reference) const noexcept {
        return Transform(reference) * view_transform;
 }
 
-Ray Entity::Aim(const Chunk::Pos &chunk_offset) const noexcept {
+Ray Entity::Aim(const ExactLocation::Coarse &chunk_offset) const noexcept {
        glm::mat4 transform = ViewTransform(chunk_offset);
        return Ray{ glm::vec3(transform[3]), -glm::vec3(transform[2]) };
 }
@@ -138,7 +139,7 @@ void Entity::Update(float dt) {
 
 void Entity::UpdateTransforms() noexcept {
        // model transform is the one given by current state
-       model_transform = state.Transform(state.chunk_pos);
+       model_transform = state.Transform(state.pos.chunk);
        // view transform is either the model's eyes transform or,
        // should the entity have no model, the pitch (yaw already is
        // in model transform)
@@ -268,8 +269,7 @@ bool EntityController::MaxOutForce(
 
 
 EntityState::EntityState()
-: chunk_pos(0)
-, block_pos(0.0f)
+: pos()
 , velocity(0.0f)
 , orient(1.0f, 0.0f, 0.0f, 0.0f)
 , pitch(0.0f)
@@ -278,30 +278,7 @@ EntityState::EntityState()
 }
 
 void EntityState::AdjustPosition() noexcept {
-       while (block_pos.x >= Chunk::width) {
-               block_pos.x -= Chunk::width;
-               ++chunk_pos.x;
-       }
-       while (block_pos.x < 0) {
-               block_pos.x += Chunk::width;
-               --chunk_pos.x;
-       }
-       while (block_pos.y >= Chunk::height) {
-               block_pos.y -= Chunk::height;
-               ++chunk_pos.y;
-       }
-       while (block_pos.y < 0) {
-               block_pos.y += Chunk::height;
-               --chunk_pos.y;
-       }
-       while (block_pos.z >= Chunk::depth) {
-               block_pos.z -= Chunk::depth;
-               ++chunk_pos.z;
-       }
-       while (block_pos.z < 0) {
-               block_pos.z += Chunk::depth;
-               --chunk_pos.z;
-       }
+       pos.Correct();
 }
 
 void EntityState::AdjustHeading() noexcept {
@@ -363,7 +340,20 @@ World::World(const BlockTypeRegistry &types, const Config &config)
 }
 
 World::~World() {
-
+       for (Entity &e : entities) {
+               e.Kill();
+       }
+       std::size_t removed = 0;
+       do {
+               removed = 0;
+               for (auto e = entities.begin(), end = entities.end(); e != end; ++e) {
+                       if (e->CanRemove()) {
+                               e = RemoveEntity(e);
+                               end = entities.end();
+                               ++removed;
+                       }
+               }
+       } while (removed > 0 && !entities.empty());
 }
 
 
@@ -482,15 +472,14 @@ std::vector<Candidate> candidates;
 
 bool World::Intersection(
        const Ray &ray,
-       const glm::mat4 &M,
-       const Chunk::Pos &reference,
+       const ExactLocation::Coarse &reference,
        WorldCollision &coll
 ) {
        candidates.clear();
 
        for (Chunk &cur_chunk : chunks) {
                float cur_dist;
-               if (cur_chunk.Intersection(ray, M * cur_chunk.Transform(reference), cur_dist)) {
+               if (cur_chunk.Intersection(ray, reference, cur_dist)) {
                        candidates.push_back({ &cur_chunk, cur_dist });
                }
        }
@@ -506,7 +495,7 @@ bool World::Intersection(
        for (Candidate &cand : candidates) {
                if (cand.dist > coll.depth) continue;
                WorldCollision cur_coll;
-               if (cand.chunk->Intersection(ray, M * cand.chunk->Transform(reference), cur_coll)) {
+               if (cand.chunk->Intersection(ray, reference, cur_coll)) {
                        if (cur_coll.depth < coll.depth) {
                                coll = cur_coll;
                        }
@@ -518,7 +507,6 @@ bool World::Intersection(
 
 bool World::Intersection(
        const Ray &ray,
-       const glm::mat4 &M,
        const Entity &reference,
        EntityCollision &coll
 ) {
@@ -530,7 +518,7 @@ bool World::Intersection(
                }
                float cur_dist;
                glm::vec3 cur_normal;
-               if (blank::Intersection(ray, cur_entity.Bounds(), M * cur_entity.Transform(reference.ChunkCoords()), &cur_dist, &cur_normal)) {
+               if (blank::Intersection(ray, cur_entity.Bounds(), cur_entity.Transform(reference.ChunkCoords()), &cur_dist, &cur_normal)) {
                        // TODO: fine grained check goes here? maybe?
                        if (cur_dist < coll.depth) {
                                coll.entity = &cur_entity;
@@ -544,10 +532,26 @@ bool World::Intersection(
 }
 
 bool World::Intersection(const Entity &e, const EntityState &s, std::vector<WorldCollision> &col) {
-       AABB box = e.Bounds();
-       Chunk::Pos reference = s.chunk_pos;
+       // TODO: make special case for entities here and in Chunk::Intersection so entity's bounding radius
+       //       doesn't have to be calculated over and over again (sqrt)
+       glm::ivec3 reference = s.pos.chunk;
        glm::mat4 M = s.Transform(reference);
-       return Intersection(box, M, reference, col);
+
+       ExactLocation::Coarse begin(reference - 1);
+       ExactLocation::Coarse end(reference + 2);
+
+       bool any = false;
+       for (ExactLocation::Coarse pos(begin); pos.z < end.y; ++pos.z) {
+               for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
+                       for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
+                               Chunk *chunk = chunks.Get(pos);
+                               if (chunk && chunk->Intersection(e, M, chunk->Transform(reference), col)) {
+                                       any = true;
+                               }
+                       }
+               }
+       }
+       return any;
 }
 
 bool World::Intersection(
@@ -603,7 +607,7 @@ void World::Update(Entity &entity, float dt) {
        f.position = sixth * ((a.position + 2.0f * (b.position + c.position)) + d.position);
        f.velocity = sixth * ((a.velocity + 2.0f * (b.velocity + c.velocity)) + d.velocity);
 
-       state.block_pos += f.position * dt;
+       state.pos.block += f.position * dt;
        state.velocity += f.velocity * dt;
        state.AdjustPosition();
 
@@ -617,7 +621,7 @@ EntityDerivative World::CalculateStep(
        const EntityDerivative &delta
 ) {
        EntityState next(cur);
-       next.block_pos += delta.position * dt;
+       next.pos.block += delta.position * dt;
        next.velocity += delta.velocity * dt;
        next.AdjustPosition();