Transform.cpp

Go to the documentation of this file.

#include "Engine/World/Transform.h"
 
#include "Engine/Logging/TracyMacros.hpp"
 
#include <glm/ext/matrix_transform.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <glm/gtx/quaternion.hpp>
#include <iostream>
#include <tiny_gltf.h>
 
#include "Engine/Ecs/EcsData.h"
#include "Engine/Serialization/GlmSerialize.h"
 
namespace EngineCore {
    Transform::Transform() = default;
 
    Transform::Transform(glm::vec3 location)
    {
        setLocation(location);
    }
 
    Transform::Transform(glm::vec3 location, glm::vec3 rotation) {
        setLocation(location);
        setRotation(rotation);
    }
 
    Transform::Transform(glm::vec3 location, glm::vec3 rotation, glm::vec3 scale)
    {
        setLocation(location);
        setRotation(rotation);
        setScale(scale);
    }
 
    Transform::Transform(glm::mat4 matrix)
    {
        overrideMatrix(matrix);
        markDirty();
    }
 
    Transform::Transform(nlohmann::json object) {
        Transform::Deserialize(object);
    }
 
    Transform::~Transform() = default;
 
    /*
    *  TODO: implement instead of generateTransformComponentsFromMatrix
        Max Sander
        // taken from https://stackoverflow.com/a/68323550 :
        static void decomposeMatrix(const glm::mat4& m, glm::vec3& pos, glm::quat& rot, glm::vec3& scale)
        {
            pos = m[3];
            for(int i = 0; i < 3; i++)
                scale[i] = glm::length(glm::vec3(m[i]));
            const glm::mat3 rotMtx(
                glm::vec3(m[0]) / scale[0],
                glm::vec3(m[1]) / scale[1],
                glm::vec3(m[2]) / scale[2]);
            rot = glm::quat_cast(rotMtx);
        }    
    */
 
    Transform::MatrixTransformComponent Transform::generateTransformComponentsFromMatrix(const glm::mat4 &matrix) const {
        Transform::MatrixTransformComponent transform_component = {};
        const bool success = glm::decompose(matrix,
            transform_component.scale,
            transform_component.rotation,
            transform_component.translation,
            transform_component.skew,
            transform_component.perspective);
        if (!success) {
            std::cerr << "Failed to decompose transformation matrix.\n";
            // Handle decomposition failure as needed
        }
        return transform_component;
    }
 
    void Transform::regenerateTransformComponents() const {
        transform_components = generateTransformComponentsFromMatrix(transform);
        needsComponentRebuild = false;
    }
 
    glm::mat4 Transform::getInverse() const {
        if (inverseNeedsUpdate) {
            cachedInverse = glm::inverse(transform);
            inverseNeedsUpdate = false;
        }
        return cachedInverse;
    }
 
    Transform::MatrixTransformComponent Transform::getComponents() const {
        if (needsComponentRebuild) {
            regenerateTransformComponents();
            needsComponentRebuild = false;
        }
 
        return transform_components;
    }
 
 
 
    glm::vec3 Transform::getLocation() const {
        return getComponents().translation;
    }
 
    // Set Location
    void Transform::setLocation(const glm::vec3& newLocation) {
        // Directly set the translation part of the matrix (last column)
        transform[3] = glm::vec4(newLocation, 1.0f);
        markDirty();
    }
 
    glm::vec3 Transform::getRotation() const {
        return degrees(glm::eulerAngles(getComponents().rotation));
    }
 
    // Set Rotation using Quaternion
    void Transform::setRotationQuat(glm::quat newQuaternion) {
        // Extract current translation and scale
        const MatrixTransformComponent currentComponents = getComponents();
        const glm::vec3 currentTranslation = currentComponents.translation;
        const glm::vec3 currentScale = currentComponents.scale;
 
        // Create rotation matrix from quaternion
        const glm::mat4 rotationMatrix = glm::toMat4(newQuaternion);
 
        // Recompose the transformation matrix
        transform = glm::mat4(1.0f);
        transform = glm::translate(transform, currentTranslation);
        transform *= rotationMatrix;
        transform = glm::scale(transform, currentScale);
 
        markDirty();
    }
 
    glm::quat Transform::getRotationQuat() const {
        return getComponents().rotation;
    }
 
    // Set Rotation using Euler Angles (Degrees)
    void Transform::setRotation(const glm::vec3& newRotationEuler) {
        // Convert Euler angles (in degrees) to radians and then to a quaternion
        glm::quat rotationQuat = glm::quat(glm::radians(newRotationEuler));
 
        // Extract current translation and scale
        MatrixTransformComponent currentComponents = getComponents();
        glm::vec3 currentTranslation = currentComponents.translation;
        glm::vec3 currentScale = currentComponents.scale;
 
        // Create rotation matrix from quaternion
        glm::mat4 rotationMatrix = glm::toMat4(rotationQuat);
 
        // Recompose the transformation matrix
        transform = glm::mat4(1.0f);
        transform = glm::translate(transform, currentTranslation);
        transform *= rotationMatrix;
        transform = glm::scale(transform, currentScale);
 
        markDirty();
    }
 
    glm::vec3 Transform::getScale() const {
        return getComponents().scale;
    }
 
    // Set Scale
    void Transform::setScale(const glm::vec3& newScale) {
        // Extract current translation and rotation
        MatrixTransformComponent currentComponents = getComponents();
        glm::vec3 currentTranslation = currentComponents.translation;
        glm::quat currentRotation = currentComponents.rotation;
 
        // Create rotation matrix from quaternion
        glm::mat4 rotationMatrix = glm::toMat4(currentRotation);
 
        // Recompose the transformation matrix with the new scale
        transform = glm::mat4(1.0f);
        transform = glm::translate(transform, currentTranslation);
        transform *= rotationMatrix;
        transform = glm::scale(transform, newScale);
 
        markDirty();
    }
 
    glm::mat4 Transform::toMatrix() const {
#ifdef ENABLE_TRACY
        TRACY_ZONE_SCOPED_FUNCTION;
#endif
        if (isTransformDirty()) {
            regenerateTransformComponents();
        }
        return transform;
    }
 
    Transform Transform::combine(const Transform &parent) const {
 
        // first apply the parent transform
        const glm::mat4 parentMatrix = parent.toMatrix();
        const glm::mat4 localMatrix = this->toMatrix();
 
        // calculate world matrix
        const glm::mat4 worldMatrix = parentMatrix * localMatrix;
 
        return matrixToTransform(worldMatrix);
    }
 
    Transform Transform::matrixToTransform(glm::mat4 matrix) const {
        Transform::MatrixTransformComponent transform_component = generateTransformComponentsFromMatrix(matrix);
 
        Transform transform = Transform();
        transform.setLocation(transform_component.translation);
        transform.setRotation(glm::degrees(glm::eulerAngles(transform_component.rotation)));
        transform.setScale(transform_component.scale);
 
        return transform;
    }
 
    void Transform::overrideMatrix(glm::mat4 matrix) {
        transform = matrix;
    }
 
    std::string Transform::toString() const {
        return "((x:" + std::to_string(getLocation().x) + ",y:" + std::to_string(getLocation().y) + ",z:" + std::to_string(getLocation().z) + ")" + "," +
            "(x:" + std::to_string(getRotation().x) + ",y:" + std::to_string(getRotation().y) + ",z:" + std::to_string(getRotation().z) + ")" + "," +
            "(x:" + std::to_string(getScale().x) + ",y:" + std::to_string(getScale().y) + ",z:" + std::to_string(getScale().z) + "))";
    }
 
    void Transform::Serialize(nlohmann::json &archive) {
        Serializable::Serialize(archive);
        GlmSerialize::Serialize(archive[serial::LOCATION], this->getComponents().translation);
        GlmSerialize::Serialize(archive[serial::ROTATION], this->getComponents().rotation);
        GlmSerialize::Serialize(archive[serial::SCALE], this->getComponents().scale);
    }
 
    void Transform::Deserialize(nlohmann::json &archive) {
 
        glm::vec3 location;
        GlmSerialize::deserialize(archive[serial::LOCATION], location);
        setLocation(location);
 
        glm::quat rotation;
        GlmSerialize::deserialize(archive[serial::ROTATION], rotation);
        setRotationQuat(rotation);
 
        glm::vec3 scale;
        GlmSerialize::deserialize(archive[serial::SCALE], scale);
        setScale(scale);
 
        regenerateTransformComponents();
    }
 
    std::string Transform::getClassName() const {
        return typeid(*this).name();
    }
 
    bool Transform::isTransformDirty() const
    {
        return isDirty;
    }
 
    Transform Transform::operator*(const Transform& other) const
    {
        return Transform(this->toMatrix() * other.toMatrix());
    }
 
    void Transform::markDirty() const {
        needsComponentRebuild = true;
        isDirty = true;
        inverseNeedsUpdate = true;
    }
 
    void Transform::markClean() const {
        isDirty = false;
    }
} // namespace EngineCore
 
namespace Ecs
{
    TransformOperators::MatrixTransformComponent TransformOperators::extractComponents( const glm::mat4 & matrix )
    {
        MatrixTransformComponent transform_component = {};
        const bool success = glm::decompose(matrix,
            transform_component.scale,
            transform_component.rotation,
            transform_component.translation,
            transform_component.skew,
            transform_component.perspective);
        if (!success) {
            std::cerr << "Failed to decompose transformation matrix.\n";
            // Handle decomposition failure as needed
        }
        return transform_component;
    }
 
    glm::vec3 TransformOperators::getPosition(const glm::mat4& matrix)
    {
        return glm::vec3(matrix[3]);
    }
 
    glm::quat TransformOperators::getRotation(const glm::mat4& matrix)
    {
        glm::mat3 rotMat(
            glm::normalize(glm::vec3(matrix[0])),
            glm::normalize(glm::vec3(matrix[1])),
            glm::normalize(glm::vec3(matrix[2]))
        );
        return glm::quat_cast(rotMat);
    }
 
    glm::vec3 TransformOperators::getRotationEuler( const glm::mat4 & matrix )
    {
        return glm::degrees(glm::eulerAngles(getRotation(matrix)));
    }
 
    glm::vec3 TransformOperators::getScale(const glm::mat4& matrix)
    {
        return glm::vec3(
            glm::length(glm::vec3(matrix[0])),
            glm::length(glm::vec3(matrix[1])),
            glm::length(glm::vec3(matrix[2]))
        );
    }
 
    void TransformOperators::setPosition( Ecs::LocalTransform & transform, const glm::vec3 & newPosition )
    {
        transform.matrix[3] = glm::vec4(newPosition, 1.0f);
    }
 
    void TransformOperators::setRotation( Ecs::LocalTransform & transform, const glm::vec3 & newRotation )
    {
        setRotation(transform, glm::quat(glm::radians(newRotation)));
    }
 
    void TransformOperators::setRotation( Ecs::LocalTransform & transform, const glm::quat & newQuaternion )
    {
        // Extract current scale from column lengths
        glm::vec3 currentScale;
        currentScale.x = glm::length(glm::vec3(transform.matrix[0]));
        currentScale.y = glm::length(glm::vec3(transform.matrix[1]));
        currentScale.z = glm::length(glm::vec3(transform.matrix[2]));
 
        // Get rotation as mat3, apply scale to each column
        glm::mat3 rotMat = glm::mat3_cast(newQuaternion);
 
        transform.matrix[0] = glm::vec4(rotMat[0] * currentScale.x, 0.f);
        transform.matrix[1] = glm::vec4(rotMat[1] * currentScale.y, 0.f);
        transform.matrix[2] = glm::vec4(rotMat[2] * currentScale.z, 0.f);
        // column 3 (translation) remains untouched
    }
 
    void TransformOperators::setScale( Ecs::LocalTransform & transform, const glm::vec3 & newScale )
    {
        transform.matrix[0] = glm::vec4(glm::normalize(glm::vec3(transform.matrix[0])) * newScale.x, 0.f);
        transform.matrix[1] = glm::vec4(glm::normalize(glm::vec3(transform.matrix[1])) * newScale.y, 0.f);
        transform.matrix[2] = glm::vec4(glm::normalize(glm::vec3(transform.matrix[2])) * newScale.z, 0.f);
    }
}  // namespace Ecs