Matrix4x4.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Matrix4x4.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 4-D matrix class.
> Created Time: 2017/03/06
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIX4X4_H
#define CUBBYFLOW_MATRIX4X4_H

#include <Core/Matrix/Matrix3x3.h>
#include <Core/Vector/Vector4.h>

#include <array>
#include <limits>

namespace CubbyFlow
{
    template <typename T>
    class Matrix<T, 4, 4>
    {
    public:
        static_assert(std::is_floating_point<T>::value, "Matrix only can be instantiated with floating point types");

        // MARK: Constructors
        Matrix();

        explicit Matrix(T s);

        Matrix(
            T m00, T m01, T m02,
            T m10, T m11, T m12,
            T m20, T m21, T m22);

        Matrix(
            T m00, T m01, T m02, T m03,
            T m10, T m11, T m12, T m13,
            T m20, T m21, T m22, T m23,
            T m30, T m31, T m32, T m33);

        template <typename U>
        Matrix(const std::initializer_list<std::initializer_list<U>>& list);

        explicit Matrix(const Matrix3x3<T>& m33);

        Matrix(const Matrix& m);

        explicit Matrix(const T* arr);

        // MARK: Basic setters
        void Set(T s);

        void Set(
            T m00, T m01, T m02,
            T m10, T m11, T m12,
            T m20, T m21, T m22);

        void Set(
            T m00, T m01, T m02, T m03,
            T m10, T m11, T m12, T m13,
            T m20, T m21, T m22, T m23,
            T m30, T m31, T m32, T m33);

        template <typename U>
        void Set(const std::initializer_list<std::initializer_list<U>>& list);

        void Set(const Matrix<T, 3, 3>& m33);

        void Set(const Matrix& m);

        void Set(const T* arr);

        void SetDiagonal(T s);

        void SetOffDiagonal(T s);

        void SetRow(size_t i, const Vector4<T>& row);

        void SetColumn(size_t i, const Vector4<T>& col);

        // MARK: Basic getters
        bool IsSimilar(const Matrix& m, double tol = std::numeric_limits<double>::epsilon()) const;

        bool IsSquare() const;

        size_t Rows() const;

        size_t Cols() const;

        T* data();

        const T* data() const;

        Matrix<T, 3, 3> Matrix3() const;

        // MARK: Binary operator methods - new instance = this instance (+) input
        Matrix Add(T s) const;

        Matrix Add(const Matrix& m) const;

        Matrix Sub(T s) const;

        Matrix Sub(const Matrix& m) const;

        Matrix Mul(T s) const;

        Vector4<T> Mul(const Vector4<T>& v) const;

        Matrix Mul(const Matrix& m) const;

        Matrix Div(T s) const;

        // MARK: Binary operator methods - new instance = input (+) this instance
        Matrix RAdd(T s) const;

        Matrix RAdd(const Matrix& m) const;

        Matrix RSub(T s) const;

        Matrix RSub(const Matrix& m) const;

        Matrix RMul(T s) const;

        Matrix RMul(const Matrix& m) const;

        Matrix RDiv(T s) const;

        // MARK: Augmented operator methods - this instance (+)= input
        void IAdd(T s);

        void IAdd(const Matrix& m);

        void ISub(T s);

        void ISub(const Matrix& m);

        void IMul(T s);

        void IMul(const Matrix& m);

        void IDiv(T s);

        // MARK: Modifiers
        void Transpose();

        void Invert();

        // MARK: Complex getters
        T Sum() const;

        T Avg() const;

        T Min() const;

        T Max() const;

        T AbsMin() const;

        T AbsMax() const;

        T Trace() const;

        T Determinant() const;

        Matrix Diagonal() const;

        Matrix OffDiagonal() const;

        Matrix StrictLowerTriangle() const;

        Matrix StrictUpperTriangle() const;

        Matrix LowerTriangle() const;

        Matrix UpperTriangle() const;

        Matrix Transposed() const;

        Matrix Inverse() const;

        template <typename U>
        Matrix<U, 4, 4> CastTo() const;

        // MARK: Setter operators
        Matrix& operator=(const Matrix& m);

        Matrix& operator+=(T s);

        Matrix& operator+=(const Matrix& m);

        Matrix& operator-=(T s);

        Matrix& operator-=(const Matrix& m);

        Matrix& operator*=(T s);

        Matrix& operator*=(const Matrix& m);

        Matrix& operator/=(T s);

        // MARK: Getter operators
        T& operator[](size_t i);

        const T& operator[](size_t i) const;

        T& operator()(size_t i, size_t j);

        const T& operator()(size_t i, size_t j) const;

        bool operator==(const Matrix& m) const;

        bool operator!=(const Matrix& m) const;

        // MARK: Helpers
        static Matrix MakeZero();

        static Matrix MakeIdentity();

        static Matrix MakeScaleMatrix(T sx, T sy, T sz);

        static Matrix MakeScaleMatrix(const Vector3<T>& s);

        static Matrix MakeRotationMatrix(const Vector3<T>& axis, T rad);

        static Matrix MakeTranslationMatrix(const Vector3<T>& t);

    private:
        std::array<T, 16> m_elements;
    };

    template <typename T> using Matrix4x4 = Matrix<T, 4, 4>;

    // Operator overloading
    template <typename T>
    Matrix<T, 4, 4> operator-(const Matrix<T, 4, 4>& a);

    template <typename T>
    Matrix<T, 4, 4> operator+(const Matrix<T, 4, 4>& a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Matrix<T, 4, 4> operator+(const Matrix<T, 4, 4>& a, T b);

    template <typename T>
    Matrix<T, 4, 4> operator+(T a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Matrix<T, 4, 4> operator-(const Matrix<T, 4, 4>& a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Matrix<T, 4, 4> operator-(const Matrix<T, 4, 4>& a, T b);

    template <typename T>
    Matrix<T, 4, 4> operator-(T a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Matrix<T, 4, 4> operator*(const Matrix<T, 4, 4>& a, T b);

    template <typename T>
    Matrix<T, 4, 4> operator*(T a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Vector3<T> operator*(const Matrix<T, 4, 4>& a, const Vector3<T>& b);

    template <typename T>
    Vector4<T> operator*(const Matrix<T, 4, 4>& a, const Vector4<T>& b);

    template <typename T>
    Matrix<T, 4, 4> operator*(const Matrix<T, 4, 4>& a, const Matrix<T, 4, 4>& b);

    template <typename T>
    Matrix<T, 4, 4> operator/(const Matrix<T, 4, 4>& a, T b);

    template <typename T>
    Matrix<T, 4, 4> operator/(const T& a, const Matrix<T, 4, 4>& b);

    using Matrix4x4F = Matrix4x4<float>;

    using Matrix4x4D = Matrix4x4<double>;
}

#include <Core/Matrix/Matrix4x4-Impl.h>

#endif