+void Entity::UpdateHeading() noexcept {
+ speed = length(Velocity());
+ if (speed > std::numeric_limits<float>::epsilon()) {
+ heading = Velocity() / speed;
+ } else {
+ speed = 0.0f;
+ // use -Z (forward axis) of model transform (our "chest")
+ heading = -glm::vec3(model_transform[2]);
+ }
+}
+
+void Entity::UpdateModel(float dt) noexcept {
+ // first, sanitize the pitch and yaw fields of state (our input)
+ // those indicate the head orientation in the entity's local cosystem
+ state.AdjustHeading();
+ // TODO: this flickers horrible and also shouldn't be based on velocity, but on control force
+ //OrientBody(dt);
+ OrientHead(dt);
+}
+
+void Entity::OrientBody(float dt) noexcept {
+ // maximum body rotation per second (due to velocity orientation) (90°)
+ constexpr float max_body_turn_per_second = PI_0p5;
+ const float max_body_turn = max_body_turn_per_second * dt;
+ // minimum speed to apply body correction
+ constexpr float min_speed = 0.0625f;
+ // use local Y as up
+ const glm::vec3 up(model_transform[1]);
+ if (speed > min_speed) {
+ // check if our orientation and velocity are aligned
+ const glm::vec3 forward(-model_transform[2]);
+ // facing is local -Z rotated about local Y by yaw and transformed into world space
+ const glm::vec3 facing(normalize(glm::vec3(glm::vec4(rotateY(glm::vec3(0.0f, 0.0f, -1.0f), state.yaw), 0.0f) * transpose(model_transform))));
+ // only adjust if velocity isn't almost parallel to up
+ float vel_dot_up = dot(Velocity(), up);
+ if (std::abs(1.0f - std::abs(vel_dot_up)) > std::numeric_limits<float>::epsilon()) {
+ // get direction of velocity projected onto model plane
+ glm::vec3 direction(normalize(Velocity() - (Velocity() * vel_dot_up)));
+ // if velocity points away from our facing (with a little bias), flip it around
+ // (the entity is "walking backwards")
+ if (dot(facing, direction) < -0.1f) {
+ direction = -direction;
+ }
+ // calculate the difference between forward and direction
+ const float absolute_difference = std::acos(dot(forward, direction));
+ // if direction is clockwise with respect to up vector, invert the angle
+ const float relative_difference = dot(cross(forward, direction), up) < 0.0f
+ ? -absolute_difference
+ : absolute_difference;
+ // only correct by half the difference max
+ const float correction = glm::clamp(relative_difference * 0.5f, -max_body_turn, max_body_turn);
+ if (ID() == 1) {
+ std::cout << "orientation before: " << state.orient << std::endl;
+ std::cout << "up: " << up << std::endl;
+ std::cout << "forward: " << forward << std::endl;
+ std::cout << "facing: " << facing << std::endl;
+ std::cout << "direction: " << direction << std::endl;
+ std::cout << "difference: " << glm::degrees(relative_difference) << "°" << std::endl;
+ std::cout << "correction: " << glm::degrees(correction) << "°" << std::endl;
+ std::cout << std::endl;
+ }
+ // now rotate body by correction and head by -correction
+ state.orient = rotate(state.orient, correction, up);
+ state.yaw -= correction;
+ }
+ }
+}
+
+void Entity::OrientHead(float dt) noexcept {
+ // maximum yaw of head (90°)
+ constexpr float max_head_yaw = PI_0p5;
+ // use local Y as up
+ const glm::vec3 up(model_transform[1]);
+ // if yaw is bigger than max, rotate the body to accomodate
+ if (std::abs(state.yaw) > max_head_yaw) {
+ float deviation = state.yaw < 0.0f ? state.yaw + max_head_yaw : state.yaw - max_head_yaw;
+ // rotate the entity by deviation about local Y
+ state.orient = rotate(state.orient, deviation, up);
+ // and remove from head yaw
+ state.yaw -= deviation;
+ // shouldn't be necessary if max_head_yaw is < PI, but just to be sure :p
+ state.AdjustHeading();
+ }
+ // update model if any
+ if (model) {
+ model.EyesState().orientation = glm::quat(glm::vec3(state.pitch, state.yaw, 0.0f));
+ }
+}
+
+
+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;
+ }