transform.h

#ifndef OE_SCENE_TRANSFORM_H
#define OE_SCENE_TRANSFORM_H
 
#include "../common.h"
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
#include <glm/gtx/quaternion.hpp>
 
#include "../util/concept.h"
#include "../util/angle.h"
 
namespace oe::scene
{
    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)
            );
 
            Transform(const glm::mat4& model);
 
            const glm::vec3& getTranslation() const
            {
                return _translation;
            }
 
            const glm::vec3& getPosition() const
            {
                return _translation;
            }
 
            const glm::quat& getRotation() const
            {
                return _rotation;
            }
 
            const glm::vec3& getScale() const
            {
                return _scale;
            }
 
            const glm::vec3& getSkew() const
            {
                return _skew;
            }
 
            const glm::vec4& getPerspective() const
            {
                return _perspective;
            }
 
            void setTranslation(const float x, const float y, const float z);
 
            void setPosition(const glm::vec3& position)
            {
                setTranslation(position);
            }
 
            void setPosition(const float x, const float y, const float z)
            {
                setTranslation(x, y, z);
            }
 
            void setRotation(const float x, const float y, const float z);
 
            void setRotation(const lit::Angle& x, const lit::Angle& y, const lit::Angle& z);
 
            void setScale(const float x, const float y, const float z);
 
            void relativeTranslate(const glm::vec3& translation);
 
            void relativeTranslate(const float x, const float y, const float z);
 
            void loadFromModel(const glm::mat4& model);
 
            void relativeMove(const glm::vec3& translation);
 
            void relativeRotate(const glm::quat& quaternion);
 
            void relativeRotate(const float x, const float y, const float z);
 
            void relativeRotate(const lit::Angle& x, const lit::Angle& y, const lit::Angle& z);
 
            void relativeScale(const glm::vec3& scale);
 
            void setSkew(const glm::vec3& skew);
 
            void setPerspective(const glm::vec4& perspective);
 
            void interpolateWith(const float ratio, const Transform& target);
 
            void fillFrom(const Transform& transform);
 
            template<TranslationType T>
            void setTranslation(const T& translation)
            {
                _translation.x = translation.x;
                _translation.y = translation.y;
                _translation.z = translation.z;
 
                _is_dirty = true;
            }
 
            template<RotationType R>
            void setRotation(const R& rotation)
            {
                _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)
            {
                _scale.x = scale.x;
                _scale.y = scale.y;
                _scale.z = scale.z;
 
                _is_dirty = true;
            }
 
            template<TranslationType T>
            void getTranslationAs(T& result) const
            {
                result.x = _translation.x;
                result.y = _translation.y;
                result.z = _translation.z;
            }
 
            template<RotationType R>
            void getRotationAs(R& result) const
            {
                result.x = _rotation.x;
                result.y = _rotation.y;
                result.z = _rotation.z;
                result.w = _rotation.w;
            }
 
            template<ScaleType S>
            void getScaleAs(S& result) const
            {
                result.x = _scale.x;
                result.y = _scale.y;
                result.z = _scale.z;
            }
 
            glm::mat4 getModelMatrix() const;
 
            inline bool isDirty() const
            {
                return _is_dirty;
            }
 
        protected:
            void forceDirty(const bool is_dirty) const
            {
                _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