cache some basic entity axes

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

diff --git a/src/world/world.cpp b/src/world/world.cpp
index ee5bf02c191ffcf3be293d0a4acda9b31289f751..4f73243c5d4ca61b87b0bd7ba92abca74c834287 100644 (file)
--- a/src/world/world.cpp
+++ b/src/world/world.cpp
@@ -30,6 +30,7 @@ Entity::Entity() noexcept
 , name("anonymous")
 , bounds()
 , state()
+, heading(0.0f, 0.0f, -1.0f)
 , max_vel(5.0f)
 , max_force(25.0f)
 , ref_count(0)
@@ -80,7 +81,7 @@ void Entity::UnsetController() noexcept {
 
 glm::vec3 Entity::ControlForce(const EntityState &s) const noexcept {
        if (HasController()) {
-               return GetController().ControlForce(s);
+               return GetController().ControlForce(*this, s);
        } else {
                return -s.velocity;
        }
@@ -112,20 +113,14 @@ glm::mat4 Entity::Transform(const glm::ivec3 &reference) const noexcept {
 }
 
 glm::mat4 Entity::ViewTransform(const glm::ivec3 &reference) const noexcept {
-       glm::mat4 transform = Transform(reference);
-       if (model) {
-               transform *= model.EyesTransform();
-       }
+       glm::mat4 transform = view_local;
+       transform[3] += glm::vec4(state.RelativePosition(reference), 0.0f);
        return transform;
 }
 
 Ray Entity::Aim(const Chunk::Pos &chunk_offset) const noexcept {
        glm::mat4 transform = ViewTransform(chunk_offset);
-       glm::vec4 from = transform * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
-       from /= from.w;
-       glm::vec4 to = transform * glm::vec4(0.0f, 0.0f, -1.0f, 1.0f);
-       to /= to.w;
-       return Ray{ glm::vec3(from), glm::normalize(glm::vec3(to - from)) };
+       return Ray{ glm::vec3(transform[3]), -glm::vec3(transform[2]) };
 }
 
 void Entity::UpdateModel() noexcept {
@@ -143,16 +138,61 @@ void Entity::UpdateModel() noexcept {
 }
 
 void Entity::Update(float dt) {
+       UpdateView();
+       UpdateHeading();
        if (HasController()) {
                GetController().Update(*this, dt);
        }
 }
 
+void Entity::UpdateView() noexcept {
+       // create local transform
+       view_local = Transform(ChunkCoords());
+       // clear the translation part
+       view_local[3] = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
+       // add the model's eyes translation, if any
+       if (model) {
+               view_local *= model.EyesTransform();
+       }
+}
+
+void Entity::UpdateHeading() noexcept {
+       if (Moving()) {
+               heading = normalize(Velocity());
+       } else {
+               // use -Z (forward axis) of local view transform
+               heading = -glm::vec3(view_local[2]);
+       }
+}
+
 
 EntityController::~EntityController() {
 
 }
 
+bool EntityController::MaxOutForce(
+       glm::vec3 &out,
+       const glm::vec3 &add,
+       float max
+) noexcept {
+       if (iszero(add) || any(isnan(add))) {
+               return false;
+       }
+       float current = iszero(out) ? 0.0f : length(out);
+       float remain = max - current;
+       if (remain <= 0.0f) {
+               return true;
+       }
+       float additional = length(add);
+       if (additional > remain) {
+               out += normalize(add) * remain;
+               return true;
+       } else {
+               out += add;
+               return false;
+       }
+}
+
 
 EntityState::EntityState()
 : chunk_pos(0)
@@ -192,26 +232,19 @@ void EntityState::AdjustPosition() noexcept {
 }
 
 void EntityState::AdjustHeading() noexcept {
-       while (pitch > PI / 2) {
-               pitch = PI / 2;
-       }
-       while (pitch < -PI / 2) {
-               pitch = -PI / 2;
-       }
+       glm::clamp(pitch, -PI_0p5, PI_0p5);
        while (yaw > PI) {
-               yaw -= PI * 2;
+               yaw -= PI_2p0;
        }
        while (yaw < -PI) {
-               yaw += PI * 2;
+               yaw += PI_2p0;
        }
 }
 
 glm::mat4 EntityState::Transform(const glm::ivec3 &reference) const noexcept {
        const glm::vec3 translation = RelativePosition(reference);
        glm::mat4 transform(toMat4(orient));
-       transform[3].x = translation.x;
-       transform[3].y = translation.y;
-       transform[3].z = translation.z;
+       transform[3] = glm::vec4(translation, 1.0f);
        return transform;
 }