Transform.hpp

#pragma once
#ifndef __H__OCULAR_MATH_TRANSFORM__H__
#define __H__OCULAR_MATH_TRANSFORM__H__

#include "Vector3.hpp"
#include "Quaternion.hpp"
#include "Matrix4x4.hpp"

#include "Utilities/Types.hpp"
#include "ObjectIO/ObjectIO.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        class Transform : public Core::ObjectIO
        {
        public:

            enum class DirtyFlags
            {
                None     = 0,
                Position = 1,
                Rotation = 2,
                Scale    = 4
            };

            Transform();
            Transform(Vector3f const& position, Quaternion const& rotation, Vector3f const& scale);

            ~Transform();

            void refresh();

            //------------------------------------------------------------
            // Getters and Setters
            //------------------------------------------------------------

            uint32_t getDirtyFlags(bool clearFlags = true);

            void setPosition(Vector3f const& position);

            void setPosition(float const x, float const y, float const z);

            Vector3f const& getPosition() const;
            
            void setRotation(Quaternion const& rotation);
            
            Quaternion const& getRotation() const;
            
            void setScale(Vector3f const& scale);
            
            Vector3f const& getScale() const;
            
            Vector3f getForwards() const;
            
            Vector3f getUp() const;
            
            Vector3f getRight() const;
            
            Matrix4x4 const&  getModelMatrix() const;

            //------------------------------------------------------------
            // Movement
            //------------------------------------------------------------

            void translate(Vector3f const& translation, bool local = true);
            
            void moveForward(float const delta);
            
            void moveUp(float const delta);
            
            void moveRight(float const delta);
            
            //------------------------------------------------------------
            // Rotation
            //------------------------------------------------------------

            void rotate(float angle, Vector3f const& axis);

            void rotate(Math::Quaternion const& rotation);

            void lookAt(Vector3f const& point, Vector3f const& upVector = Vector3f::Up());

            //------------------------------------------------------------
            // Inherited Methods
            //------------------------------------------------------------

            virtual void onLoad(Core::BuilderNode const* node) override;
            virtual void onVariableModified(std::string const& varName) override;

        protected:

        private:

            Vector3f   m_Position;
            Quaternion m_Rotation;
            Vector3f   m_Scale;

            Matrix4x4  m_ModelMatrix;

            uint32_t   m_DirtyFlags;
        };
    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Transform, "Transform");

//------------------------------------------------------------------------------------------

#endif