transform.h

#pragma once
 
#define GLM_ENABLE_EXPERIMENTAL
#include "pixelbullet/serialization/glm_node.h"
 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <glm/gtx/quaternion.hpp>
 
namespace pixelbullet
{
struct Transform
{
    glm::vec3 position = glm::vec3(0.0f);
    glm::vec3 rotation = glm::vec3(0.0f);
    glm::vec3 scale = glm::vec3(1.0f);
 
    Transform() = default;
    Transform(const glm::vec3& pos)
        : position(pos)
    {
    }
    Transform(const glm::vec3& pos, const glm::vec3& rot, const glm::vec3& scl)
        : position(pos)
        , rotation(rot)
        , scale(scl)
    {
    }
 
    [[nodiscard]] glm::mat4 GetMatrix() const
    {
        glm::mat4 rotMat = glm::toMat4(glm::quat(glm::radians(rotation)));
        return glm::translate(glm::mat4(1.0f), position) * rotMat * glm::scale(glm::mat4(1.0f), scale);
    }
};
 
inline bool TryDecomposeTransform(const glm::mat4& matrix, Transform& transform)
{
    glm::vec3 scale(1.0f);
    glm::quat orientation = glm::quat(glm::vec3(0.0f));
    glm::vec3 translation(0.0f);
    glm::vec3 skew(0.0f);
    glm::vec4 perspective(0.0f);
 
    if (!glm::decompose(matrix, scale, orientation, translation, skew, perspective))
    {
        return false;
    }
 
    orientation = glm::normalize(orientation);
    transform.position = translation;
    transform.rotation = glm::degrees(glm::eulerAngles(orientation));
    transform.scale = scale;
    return true;
}
 
inline bool operator==(const Transform& lhs, const Transform& rhs) noexcept
{
    return glm::all(glm::equal(lhs.position, rhs.position)) && glm::all(glm::equal(lhs.rotation, rhs.rotation)) &&
           glm::all(glm::equal(lhs.scale, rhs.scale));
}
 
inline bool operator!=(const Transform& lhs, const Transform& rhs) noexcept
{
    return !(lhs == rhs);
}
 
inline Node& operator<<(Node& node, const Transform& t)
{
    node["position"] << t.position;
    node["rotation"] << t.rotation;
    node["scale"] << t.scale;
    return node;
}
 
inline const Node& operator>>(const Node& node, Transform& t)
{
    node["position"] >> t.position;
    node["rotation"] >> t.rotation;
    node["scale"] >> t.scale;
    return node;
}
} // namespace pixelbullet