X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2Fworld.cpp;h=dfcf7217f99372d1ea4ada491d55ffa409ec2336;hb=ee3fee8a4bf3e77b17c940fb8f3daf30ede46cce;hp=c43747a8c89f60089e560d54dbb49b01ce97a930;hpb=e20be973f6ef23164ae54398088e1b14d9bac3ab;p=blank.git

diff --git a/src/world/world.cpp b/src/world/world.cpp
index c43747a..dfcf721 100644
--- a/src/world/world.cpp
+++ b/src/world/world.cpp
@@ -20,6 +20,7 @@
 #include <limits>
 #include <glm/gtx/euler_angles.hpp>
 #include <glm/gtx/io.hpp>
+#include <glm/gtx/projection.hpp>
 #include <glm/gtx/quaternion.hpp>
 #include <glm/gtx/rotate_vector.hpp>
 #include <glm/gtx/transform.hpp>
@@ -219,8 +220,8 @@ void Entity::OrientBody(float dt) noexcept {
 }
 
 void Entity::OrientHead(float dt) noexcept {
-	// maximum yaw of head (90°)
-	constexpr float max_head_yaw = PI_0p5;
+	// maximum yaw of head (60°)
+	constexpr float max_head_yaw = PI / 3.0f;
 	// use local Y as up
 	const glm::vec3 up(model_transform[1]);
 	// if yaw is bigger than max, rotate the body to accomodate
@@ -340,7 +341,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());
 }
 
 
@@ -459,7 +473,6 @@ std::vector<Candidate> candidates;
 
 bool World::Intersection(
 	const Ray &ray,
-	const glm::mat4 &M,
 	const ExactLocation::Coarse &reference,
 	WorldCollision &coll
 ) {
@@ -467,7 +480,7 @@ bool World::Intersection(
 
 	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 });
 		}
 	}
@@ -483,7 +496,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;
 			}
@@ -495,7 +508,6 @@ bool World::Intersection(
 
 bool World::Intersection(
 	const Ray &ray,
-	const glm::mat4 &M,
 	const Entity &reference,
 	EntityCollision &coll
 ) {
@@ -507,7 +519,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;
@@ -526,15 +538,18 @@ bool World::Intersection(const Entity &e, const EntityState &s, std::vector<Worl
 	glm::ivec3 reference = s.pos.chunk;
 	glm::mat4 M = s.Transform(reference);
 
+	ExactLocation::Coarse begin(reference - 1);
+	ExactLocation::Coarse end(reference + 2);
+
 	bool any = false;
-	for (Chunk &cur_chunk : chunks) {
-		if (manhattan_radius(cur_chunk.Position() - reference) > 1) {
-			// chunk is not one of the 3x3x3 surrounding the entity
-			// since there's no entity which can extent over 16 blocks, they can be skipped
-			continue;
-		}
-		if (cur_chunk.Intersection(e, M, cur_chunk.Transform(reference), col)) {
-			any = true;
+	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;
@@ -652,38 +667,19 @@ glm::vec3 World::CollisionForce(
 ) {
 	col.clear();
 	if (entity.WorldCollidable() && Intersection(entity, state, col)) {
-		// determine displacement for each cardinal axis and move entity accordingly
-		glm::vec3 min_pen(0.0f);
-		glm::vec3 max_pen(0.0f);
-		for (const WorldCollision &c : col) {
-			if (!c.Blocks()) continue;
-			glm::vec3 local_pen(c.normal * c.depth);
-			// swap if neccessary (normal may point away from the entity)
-			if (dot(c.normal, state.RelativePosition(c.ChunkPos()) - c.BlockCoords()) > 0) {
-				local_pen *= -1;
-			}
-			min_pen = min(min_pen, local_pen);
-			max_pen = max(max_pen, local_pen);
-		}
-		glm::vec3 correction(0.0f);
-		// only apply correction for axes where penetration is only in one direction
-		for (std::size_t i = 0; i < 3; ++i) {
-			if (min_pen[i] < -std::numeric_limits<float>::epsilon()) {
-				if (max_pen[i] < std::numeric_limits<float>::epsilon()) {
-					correction[i] = -min_pen[i];
-				}
-			} else {
-				correction[i] = -max_pen[i];
-			}
-		}
+		glm::vec3 correction = -CombinedInterpenetration(state, col);
 		// correction may be zero in which case normalize() returns NaNs
-		if (dot(correction, correction) < std::numeric_limits<float>::epsilon()) {
+		if (iszero(correction)) {
+			return glm::vec3(0.0f);
+		}
+		// if entity is already going in the direction of correction,
+		// let the problem resolve itself
+		if (dot(state.velocity, correction) >= 0.0f) {
 			return glm::vec3(0.0f);
 		}
-		glm::vec3 normal(normalize(correction));
-		glm::vec3 normal_velocity(normal * dot(state.velocity, normal));
+		glm::vec3 normal_velocity(proj(state.velocity, correction));
 		// apply force proportional to penetration
-		// use velocity projected onto normal as damper
+		// use velocity projected onto correction as damper
 		constexpr float k = 1000.0f; // spring constant
 		constexpr float b = 10.0f; // damper constant
 		const glm::vec3 x(-correction); // endpoint displacement from equilibrium in m
@@ -694,6 +690,37 @@ glm::vec3 World::CollisionForce(
 	}
 }
 
+glm::vec3 World::CombinedInterpenetration(
+	const EntityState &state,
+	const std::vector<WorldCollision> &col
+) noexcept {
+	// determine displacement for each cardinal axis and move entity accordingly
+	glm::vec3 min_pen(0.0f);
+	glm::vec3 max_pen(0.0f);
+	for (const WorldCollision &c : col) {
+		if (!c.Blocks()) continue;
+		glm::vec3 local_pen(c.normal * c.depth);
+		// swap if neccessary (normal may point away from the entity)
+		if (dot(c.normal, state.RelativePosition(c.ChunkPos()) - c.BlockCoords()) > 0) {
+			local_pen *= -1;
+		}
+		min_pen = min(min_pen, local_pen);
+		max_pen = max(max_pen, local_pen);
+	}
+	glm::vec3 pen(0.0f);
+	// only apply correction for axes where penetration is only in one direction
+	for (std::size_t i = 0; i < 3; ++i) {
+		if (min_pen[i] < -std::numeric_limits<float>::epsilon()) {
+			if (max_pen[i] < std::numeric_limits<float>::epsilon()) {
+				pen[i] = min_pen[i];
+			}
+		} else {
+			pen[i] = max_pen[i];
+		}
+	}
+	return pen;
+}
+
 glm::vec3 World::Gravity(
 	const Entity &entity,
 	const EntityState &state