transform.h

#ifndef OE_SCENE_TRANSFORM_H
#define OE_SCENE_TRANSFORM_H
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
#include <glm/gtx/quaternion.hpp>
 
#include <concepts>
#include "../util/angle.h"
 
namespace oe::scene
{
    template<class V>
    concept Vector3Type = requires(V v)
    {
        {v.x} -> std::convertible_to<float>;
        {v.y} -> std::convertible_to<float>;
        {v.z} -> std::convertible_to<float>;
    };
 
    template<class V>
    concept Vector4Type = requires(V v)
    {
        {v.x} -> std::convertible_to<float>;
        {v.y} -> std::convertible_to<float>;
        {v.z} -> std::convertible_to<float>;
        {v.w} -> std::convertible_to<float>;
    };
 
    template<class T>
    struct IsPosition : std::false_type {};
 
    template<class S>
    struct IsScale : std::false_type {};
 
    template<class R>
    struct IsRotation : std::false_type {};
 
    // Abstract compile time concepts to allow generic types to be used in Transform
    template<class T>
    concept TranslationType = IsPosition<T>::value == true && Vector3Type<T>;
 
    template<class R>
    concept RotationType = IsRotation<R>::value == true && Vector4Type<R>;
 
    template<class S>
    concept ScaleType = IsScale<S>::value == true && Vector3Type<S>;
 
    // Default specializations to allow glm types
    template<>struct IsPosition<glm::vec3> : std::true_type {};
    template<>struct IsRotation<glm::quat> : std::true_type {};
    template<>struct IsScale<glm::vec3> : std::true_type {};
 
    class Transform
    {
        public:
            Transform(
                const glm::vec3& translation = glm::vec3(0.f),
                const glm::quat& rotation = glm::quat(1.f, 0.f, 0.f, 0.f),
                const glm::vec3& scale = glm::vec3(1.f),
                const glm::vec3& skew = glm::vec3(0.f),
                const glm::vec4& perspective = glm::vec4(glm::vec3(0.f), 1.f)
            ):
                _translation(translation),
                _rotation(rotation),
                _scale(scale),
                _skew(skew),
                _perspective(perspective)
            {}
 
            Transform(const glm::mat4& model)
            {
                loadFromModel(model);
            }
 
            const glm::vec3& getTranslation() const noexcept
            {
                return _translation;
            }
 
            const glm::vec3& getPosition() const noexcept
            {
                return _translation;
            }
 
            const glm::quat& getRotation() const noexcept
            {
                return _rotation;
            }
 
            const glm::quat& getOrientation() const noexcept
            {
                return _rotation;
            }
 
            const glm::vec3& getScale() const noexcept
            {
                return _scale;
            }
 
            const glm::vec3& getSkew() const noexcept
            {
                return _skew;
            }
 
            const glm::vec4& getPerspective() const noexcept
            {
                return _perspective;
            }
 
            void setTranslation(const float x, const float y, const float z) noexcept
            {
                _translation.x = x;
                _translation.y = y;
                _translation.z = z;
 
                _is_dirty = true;
            }
 
            void setPosition(const float x, const float y, const float z) noexcept
            {
                setTranslation(x, y, z);
            }
 
            void setPosition(const glm::vec3& position) noexcept
            {
                setTranslation(position);
            }
 
            void setRotation(const lit::Angle& x, const lit::Angle& y, const lit::Angle& z) noexcept
            {
                _rotation = glm::quat(glm::vec3(x.getRadians(), y.getRadians(), z.getRadians()));
 
                _is_dirty = true;
            }
 
            void setRotation(const glm::quat& rotation) noexcept
            {
                _rotation = rotation;
 
                _is_dirty = true;
            }
 
            void setOrientation(const lit::Angle& x, const lit::Angle& y, const lit::Angle& z) noexcept
            {
                setRotation(x, y, z);
            }
 
            void setOrientation(const glm::quat& rotation) noexcept
            {
                setRotation(rotation);
            }
 
            void setScale(const float x, const float y, const float z) noexcept
            {
                _scale.x = x;
                _scale.y = y;
                _scale.z = z;
 
                _is_dirty = true;
            }
 
            void relativeTranslate(const glm::vec3& translation) noexcept
            {
                _translation += translation;
                _is_dirty = true;
            }
 
            void relativeTranslate(const float x, const float y, const float z) noexcept
            {
                relativeTranslate(glm::vec3(x, y, z));
                _is_dirty = true;
            }
 
            void loadFromModel(const glm::mat4& model) noexcept;
 
            void relativeMove(const glm::vec3& translation) noexcept
            {
                relativeTranslate(translation);
                _is_dirty = true;
            }
 
            void relativeRotate(const glm::quat& quaternion) noexcept
            {
                _rotation = quaternion * _rotation;
                _is_dirty = true;
            }
 
            void relativeRotate(const float x, const float y, const float z) noexcept
            {
                relativeRotate(glm::quat(glm::radians(glm::vec3(x, y, z))));
                _is_dirty = true;
            }
 
            void relativeRotate(const lit::Angle& x, const lit::Angle& y, const lit::Angle& z) noexcept
            {
                relativeRotate(glm::quat(glm::vec3(x.getRadians(), y.getRadians(), z.getRadians())));
                _is_dirty = true;
            }
 
            void relativeScale(const glm::vec3& scale) noexcept
            {
                _scale *= scale;
                _is_dirty = true;
            }
 
            void setSkew(const glm::vec3& skew) noexcept
            {
                _skew = skew;
 
                _is_dirty = true;
            }
 
            void setPerspective(const glm::vec4& perspective) noexcept
            {
                _perspective = perspective;
 
                _is_dirty = true;
            }
 
            void interpolateWith(const float ratio, const Transform& target) noexcept
            {
                _translation = glm::mix(_translation, target._translation, ratio);
                _rotation = glm::slerp(_rotation, target._rotation, ratio);
                _scale = glm::mix(_scale, target._scale, ratio);
                _skew = glm::mix(_skew, target._skew, ratio);
                _perspective = glm::mix(_perspective, target._perspective, ratio);
 
                _is_dirty = true;
            }
 
            void fillFrom(const Transform& transform) noexcept
            {
                _translation = transform._translation;
                _rotation = transform._rotation;
                _scale = transform._scale;
                _skew = transform._skew;
                _perspective = transform._perspective;
 
                _is_dirty = true;
            }
 
            template<TranslationType T>
            void setTranslation(const T& translation) noexcept
            {
                _translation.x = translation.x;
                _translation.y = translation.y;
                _translation.z = translation.z;
 
                _is_dirty = true;
            }
 
            template<RotationType R>
            void setRotation(const R& rotation) noexcept
            {
                _rotation.x = rotation.x;
                _rotation.y = rotation.y;
                _rotation.z = rotation.z;
                _rotation.w = rotation.w;
 
                _is_dirty = true;
            }
 
            template<ScaleType S>
            void setScale(const S& scale) noexcept
            {
                _scale.x = scale.x;
                _scale.y = scale.y;
                _scale.z = scale.z;
 
                _is_dirty = true;
            }
 
            template<TranslationType T>
            void getTranslationAs(T& result) const noexcept
            {
                result.x = _translation.x;
                result.y = _translation.y;
                result.z = _translation.z;
            }
 
            template<RotationType R>
            void getRotationAs(R& result) const noexcept
            {
                result.x = _rotation.x;
                result.y = _rotation.y;
                result.z = _rotation.z;
                result.w = _rotation.w;
            }
 
            template<ScaleType S>
            void getScaleAs(S& result) const noexcept
            {
                result.x = _scale.x;
                result.y = _scale.y;
                result.z = _scale.z;
            }
 
            glm::mat4 getModelMatrix() const noexcept;
 
            inline bool isDirty() const noexcept
            {
                return _is_dirty;
            }
 
        protected:
            void forceDirty(const bool is_dirty) const noexcept
            {
                _is_dirty = is_dirty;
            }
 
        private:
            glm::vec3 _translation;
            glm::quat _rotation;
            glm::vec3 _scale;
            glm::vec3 _skew;
            glm::vec4 _perspective;
 
            mutable bool _is_dirty = true;
    };
}
#endif