transform.h

#pragma once
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
 
#include "core/math/rotation.h"
#include "core/reflect.h"
 
namespace Vkm::Engine {

struct Transform {
    glm::vec3 position = {0.0f, 0.0f, 0.0f};        
    glm::quat rotation = {1.0f, 0.0f, 0.0f, 0.0f};  
    glm::vec3 scale    = {1.0f, 1.0f, 1.0f};        

    static glm::mat4 computeModelMatrix(const Transform& transform) {
        const glm::mat4 rot = glm::mat4_cast(transform.rotation);
 
        glm::mat4 model;
        model[0] = rot[0] * transform.scale.x;
        model[1] = rot[1] * transform.scale.y;
        model[2] = rot[2] * transform.scale.z;
        model[3] = glm::vec4(transform.position, 1.0f);
 
        return model;
    }

    static Transform fromModelMatrix(const glm::mat4& model) {
        const glm::mat3 basis(model);
 
        Transform out;
        out.position = glm::vec3(model[3]);
        out.scale    = {glm::length(basis[0]), glm::length(basis[1]), glm::length(basis[2])};
 
        // No rotation reproduces a mirror, so the flip goes on the scale axis
        // Math::worldRotationOf takes it off.
        if (glm::determinant(basis) < 0.0f) out.scale.x = -out.scale.x;
 
        out.rotation = Math::worldRotationOf(model);
 
        return out;
    }

    static glm::mat4 computeView(const Transform& transform) {
        return glm::lookAt(
            transform.position,
            transform.position + Math::computeForward(transform.rotation),
            Math::computeUp(transform.rotation)
        );
    }
};
 
} // namespace Vkm::Engine
 
VKM_REFLECT_BEGIN(::Vkm::Engine::Transform)
    VKM_F(position)
    VKM_F(rotation)
    VKM_F(scale)
VKM_REFLECT_END()