rotation.h

#pragma once
 
#include <cmath>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include "core/math/axes.h"
 
namespace Vkm::Engine::Math {

inline glm::vec3 computeForward(const glm::quat& rotation) {
    return glm::normalize(rotation * WORLD_FORWARD);
}

inline glm::vec3 computeUp(const glm::quat& rotation) {
    return glm::normalize(rotation * WORLD_AXIS_Y);
}

inline glm::vec3 computeRight(const glm::quat& rotation) {
    return glm::normalize(rotation * WORLD_RIGHT);
}

inline glm::quat worldRotationOf(const glm::mat4& worldMatrix) {
    glm::mat3 basis(worldMatrix);
    const bool mirrored = glm::determinant(basis) < 0.0f;
 
    for (int axis = 0; axis < 3; ++axis) {
        const float length = glm::length(basis[axis]);
        basis[axis] = length != 0.0f ? basis[axis] / length : glm::vec3(0.0f);
    }
    // Otherwise quat_cast reads the reflection as a rotation.
    if (mirrored) basis[0] = -basis[0];
 
    for (int axis = 0; axis < 3; ++axis) {
        if (glm::dot(basis[axis], basis[axis]) > 0.0f) continue;
 
        const glm::vec3 implied = glm::cross(basis[(axis + 1) % 3], basis[(axis + 2) % 3]);
        basis[axis] = glm::dot(implied, implied) > 0.0f ? implied : glm::mat3(1.0f)[axis];
    }
 
    return glm::normalize(glm::quat_cast(basis));
}

inline glm::quat lookRotation(const glm::vec3& direction, const glm::vec3& up = {0.0f, 1.0f, 0.0f}) {
    return glm::quatLookAt(glm::normalize(direction), up);
}

inline glm::quat fromYawPitch(float yaw, float pitch) {
    return glm::angleAxis(yaw, WORLD_AXIS_Y) * glm::angleAxis(pitch, WORLD_AXIS_X);
}

inline void toYawPitch(const glm::vec3& direction, float& yaw, float& pitch) {
    const glm::vec3 d = glm::normalize(direction);
    pitch = std::asin(glm::clamp(d.y, -1.0f, 1.0f));
    // Negated: yaw 0 is -Z, so the angle is measured from there.
    yaw = std::atan2(-d.x, -d.z);
}
 
} // namespace Vkm::Engine::Math