Matrix4x4.hpp

#pragma once
#ifndef __H__OCULAR_MATH_MATRIX_4X4_TEMP__H__
#define __H__OCULAR_MATH_MATRIX_4X4_TEMP__H__

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

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

namespace Ocular
{
    namespace Math
    {
        template<typename T> class Vector3;
        template<typename T> class Vector4;
        class Matrix3x3;
        class Quaternion;

        struct Matrix4x4_Internal;

        class Matrix4x4
        {
        public:

            //------------------------------------------------------------------------------
            // CONSTRUCTORS
            //------------------------------------------------------------------------------

            Matrix4x4(float x0, float y0, float z0, float w0,
                      float x1, float y1, float z1, float w1,
                      float x2, float y2, float z2, float w2,
                      float x3, float y3, float z3, float w3);

            Matrix4x4(Matrix3x3 const& matrix);

            Matrix4x4(float const* values);

            Matrix4x4(Vector4<float> const& col0, Vector4<float> const& col1, Vector4<float> const& col2, Vector4<float> const& col3);

            Matrix4x4(Vector3<float> const& position, Quaternion const& rotation);

            Matrix4x4(Vector3<float> const& position, Vector3<float> const& eulerRotation);

            Matrix4x4(Vector3<float> const& position, Quaternion const& rotation, Vector3<float> const& scale);

            Matrix4x4(Matrix4x4_Internal const& data);

            Matrix4x4(Matrix4x4 const& other);

            Matrix4x4();

            ~Matrix4x4();

            //------------------------------------------------------------------------------
            // OPERATORS
            //------------------------------------------------------------------------------

            float operator[](uint32_t index);

            Matrix4x4& operator=(Matrix4x4 const& rhs);
            Matrix4x4& operator+=(Matrix4x4 const& rhs);
            Matrix4x4& operator-=(Matrix4x4 const& rhs);
            Matrix4x4& operator*=(Matrix4x4 const& rhs);
            Matrix4x4& operator*=(Vector4<float> const& rhs);
            Matrix4x4& operator*=(float rhs);

            //------------------------------------------------------------------------------
            // GETTERS / SETTERS
            //------------------------------------------------------------------------------
            
            void setElement(uint32_t index, float value);

            float getElement(uint32_t index) const;
            
            void setRow(uint32_t index, Vector4<float> const& row);

            void setRow(uint32_t index, Vector3<float> const& row);

            void getRow(uint32_t index, Vector4<float>& row) const;

            Vector4<float> getRow(uint32_t index) const;

            void setCol(uint32_t index, Vector4<float> const& col);

            void setCol(uint32_t index, Vector3<float> const& col);

            void getCol(uint32_t index, Vector4<float>& col) const;

            Vector4<float> getCol(uint32_t index) const;

            void setData(float const* data);

            void getData(float* data) const;

            //------------------------------------------------------------------------------
            // MISC OPERATIONS
            //------------------------------------------------------------------------------
            
            void invert();

            Matrix4x4 getInverse() const;

            float getDeterminant() const;

            Matrix4x4 getTranspose() const;

            bool isIdentity() const;

            //------------------------------------------------------------------------------
            // STATIC OPERATIONS
            //------------------------------------------------------------------------------

            static Matrix4x4 CreateTranslationMatrix(Vector3<float> const& translate, Matrix4x4 const& matrix = Matrix4x4());

            static Matrix4x4 CreateScaleMatrix(Vector3<float> const& scale, Matrix4x4 const& matrix = Matrix4x4());

            static Matrix4x4 CreateLookAtMatrix(Vector3<float> const& from, Vector3<float> const& to, Vector3<float> const& up);

            static Matrix4x4 CreateOrthographicMatrix(float xMin, float xMax, float yMin, float yMax, float nearClip, float farClip);

            static Matrix4x4 CreatePerspectiveMatrix(float fov, float aspectRatio, float nearClip, float farClip);

            //------------------------------------------------------------------------------
            // MISC
            //------------------------------------------------------------------------------
           
            Matrix4x4_Internal* getInternal() const;

        protected:

        private:

            Matrix4x4_Internal* m_Internal;
        };

        bool operator==(Matrix4x4 const& lhs, Matrix4x4 const& rhs);
        bool operator!=(Matrix4x4 const& lhs, Matrix4x4 const& rhs);

        Matrix4x4 operator+(Matrix4x4 const& lhs, Matrix4x4 const& rhs);
        Matrix4x4 operator-(Matrix4x4 const& lhs, Matrix4x4 const& rhs);
        Matrix4x4 operator*(Matrix4x4 const& lhs, Matrix4x4 const& rhs);
        Matrix4x4 operator*(Matrix4x4 const& lhs, float rhs);
        
        Vector4<float> operator*(Matrix4x4 const& lhs, Vector4<float> const& rhs);
        Vector3<float> operator*(Matrix4x4 const& lhs, Vector3<float> const& rhs);
    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Matrix4x4, "Matrix4x4");

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

#endif