Transform.h

#pragma once
 
#include "krpch.h"
 
#include "glm/glm.hpp"
#include <glm/gtc/quaternion.hpp>
 
#include <glm/gtx/euler_angles.hpp>
 
namespace Karma
{
#define KR_SMALL_NUMBER         (1.e-8f)
 
    struct KARMA_API TQuaternion
    {
    public:
        glm::vec1 X;
 
        glm::vec1 Y;
 
        glm::vec1 Z;
 
        glm::vec1 W;
    };
 
    struct KARMA_API TRotator
    {
        TRotator();
        TRotator(glm::vec3 EulerAngles);
 
        float m_Pitch;
 
        float m_Yaw;
 
        float m_Roll;
 
        inline TRotator Inverse() const;
 
        inline TRotator operator*(const TRotator& Other) const
        {
            return TRotator(glm::vec3(m_Pitch + Other.m_Pitch, m_Yaw + Other.m_Yaw, m_Roll + Other.m_Roll));
        }
 
        inline glm::vec3 operator*(const glm::vec3& Translation) const
        {
            glm::mat4 transform = glm::eulerAngleYXZ(m_Pitch, m_Yaw, m_Roll);
            glm::vec4 tempResult = transform * glm::vec4(Translation.x, Translation.y, Translation.z, 1.0f);
 
            glm::vec3 returnVector(tempResult.x, tempResult.y, tempResult.z);
            return returnVector;
            
        }
    };
 
    class KARMA_API FTransform
    {
    public:
        FTransform();
        FTransform(glm::vec3 rotation, glm::vec3 translation, glm::vec3 scale3D);
 
        inline const glm::vec3& GetLocation() { return GetTranslation(); }
        inline const TRotator& GetRotation() const { return m_Rotation; }
        inline const glm::vec3& GetTranslation() const { return m_Translation; }
        inline const glm::vec3& GetScale3D() const { return m_Scale3D; }
 
        static FTransform Identity();
 
        inline void SetScale3D(const glm::vec3& newScale)
        {
            m_Scale3D = newScale;
        }
 
        inline void SetRotation(const TRotator& newRotation)
        {
            m_Rotation = newRotation;
        }
 
        inline void SetTranslation(const glm::vec3& newTranslation)
        {
            m_Translation = newTranslation;
        }
 
        FTransform GetRelativeTransform(const FTransform& RelativeToWhat) const;
 
        FTransform operator*(const FTransform& Other) const;
 
        inline static void Multiply(FTransform* OutTransform, const FTransform* A, const FTransform* B);
 
        inline bool AnyHasNegativeScale(const glm::vec3& InScale3D, const glm::vec3& InOtherScale3D) const
        {
            return  (InScale3D.x < 0.f || InScale3D.y < 0.f || InScale3D.z < 0.f
                || InOtherScale3D.x < 0.f || InOtherScale3D.y < 0.f || InOtherScale3D.z < 0.f);
        }
 
        inline glm::vec3 GetSafeScaleReciprocal(const glm::vec3& InScale, float Tolerance) const
        {
            glm::vec3 SafeReciprocalScale;
 
            if (glm::abs(InScale.x) <= Tolerance)
            {
                SafeReciprocalScale.x = 0.f;
            }
            else
            {
                SafeReciprocalScale.x = 1 / InScale.x;
            }
 
            if (glm::abs(InScale.y) <= Tolerance)
            {
                SafeReciprocalScale.y = 0.f;
            }
            else
            {
                SafeReciprocalScale.y = 1 / InScale.y;
            }
 
            if (glm::abs(InScale.z) <= Tolerance)
            {
                SafeReciprocalScale.z = 0.f;
            }
            else
            {
                SafeReciprocalScale.z = 1 / InScale.z;
            }
 
            return SafeReciprocalScale;
        }
 
        FORCEINLINE void CopyTranslation(const FTransform& Other)
        {
            m_Translation = Other.GetTranslation();
        }
 
        FORCEINLINE void CopyRotation(const FTransform& Other)
        {
            m_Rotation = Other.GetRotation();
        }
 
        FORCEINLINE void CopyScale3D(const FTransform Other)
        {
            m_Scale3D = Other.GetScale3D();
        }
 
    public:
        static FTransform m_Identity;
 
    private:
        TRotator m_Rotation;
        glm::vec3 m_Translation;
        glm::vec3 m_Scale3D;
    };
}