Transform.h

Go to the documentation of this file.

#pragma once
 
#include <glm/glm.hpp>
#include <string>
#include <glm/gtc/quaternion.hpp>
 
#include <Engine/Serialization/Serializable.h>
#include <Engine/Serialization/RegistrarMacro.h>
 
namespace Ecs
{
    struct LocalTransform;
 
    class TransformOperators
    {
    private:
        struct MatrixTransformComponent {
            glm::vec3 skew;
            glm::vec4 perspective;
            glm::vec3 translation;
            glm::vec3 scale;
            glm::quat rotation;
        };
 
        static MatrixTransformComponent extractComponents(const glm::mat4& matrix);
 
    public:
        static glm::vec3 getPosition(const glm::mat4& matrix);
        static glm::quat getRotation(const glm::mat4& matrix);
        static glm::vec3 getRotationEuler(const glm::mat4& matrix);
        static glm::vec3 getScale(const glm::mat4& matrix);
 
        static void setPosition(Ecs::LocalTransform& transform, const glm::vec3& newPosition);
        static void setRotation(Ecs::LocalTransform& transform, const glm::vec3& newRotation);
        static void setRotation(Ecs::LocalTransform& transform, const glm::quat& newQuaternion);
        static void setScale(Ecs::LocalTransform& transform, const glm::vec3& newScale);
    };
}
 
namespace EngineCore {
 
    class Transform : public Serializable {
        friend class SceneGraph;
    public:
        Transform();
 
        explicit Transform(glm::vec3 location);
        Transform(glm::vec3 location, glm::vec3 rotation);
        Transform(glm::vec3 location, glm::vec3 rotation, glm::vec3 scale);
 
        explicit Transform(glm::mat4 matrix);
 
        explicit Transform(nlohmann::json object);
        ~Transform();
 
    private:
        struct MatrixTransformComponent {
            glm::vec3 skew;
            glm::vec4 perspective;
            glm::vec3 translation;
            glm::vec3 scale;
            glm::quat rotation;
        };
 
        // cached transform components
        mutable Transform::MatrixTransformComponent transform_components = {};
        mutable bool needsComponentRebuild = true;
        mutable bool isDirty = true;
        mutable bool inverseNeedsUpdate = true;
 
        MatrixTransformComponent generateTransformComponentsFromMatrix(const glm::mat4 &matrix) const;
        void regenerateTransformComponents() const;
 
        mutable glm::mat4 cachedInverse = glm::mat4(1.0f);
    public:
        glm::mat4 getInverse() const;
 
        MatrixTransformComponent getComponents() const;
 
        [[nodiscard]] glm::vec3 getLocation() const;
        void setLocation(const glm::vec3& newLocation);
 
        [[nodiscard]] glm::vec3 getRotation() const;
        void setRotation(const glm::vec3& newRotationEuler);
 
        void setRotationQuat(glm::quat newQuaternion);
        glm::quat getRotationQuat() const;
 
        [[nodiscard]] glm::vec3 getScale() const;
        void setScale(const glm::vec3& newScale);
 
        Transform matrixToTransform(glm::mat4 matrix) const;
        
        void overrideMatrix(glm::mat4 matrix);
        
        Transform combine(const Transform& parent) const;
        [[nodiscard]] glm::mat4 toMatrix() const;
 
        [[nodiscard]] std::string toString() const;
 
        void Serialize(nlohmann::json &archive) override;
        void Deserialize(nlohmann::json& archive) override;
        [[nodiscard]] std::string getClassName() const override;
 
        bool isTransformDirty() const;
 
        Transform operator*(const Transform& other) const;
 
        void markDirty() const;
        void markClean() const;
    private:
        class serial {
        public:
            inline static std::string LOCATION = "location";
            inline static std::string ROTATION = "rotation";
            inline static std::string SCALE = "scale";
        };
 
        glm::mat4 transform = glm::mat4(1.0f);
 
        REGISTER_SERIALIZABLE(Transform);
    };
}