Matrix4x4.h

Go to the documentation of this file.

#pragma once
#include <cstring>
#include <array>
#include <ostream>
 
namespace Eule
{
    template <class T>
    class Vector3;
    typedef Vector3<double> Vector3d;
 
    class Matrix4x4
    {
    public:
        Matrix4x4();
        Matrix4x4(const Matrix4x4& other);
        Matrix4x4(Matrix4x4&& other) noexcept;
 
        std::array<std::array<double, 4>, 4> v;
 
        Matrix4x4 operator*(const Matrix4x4& other) const;
        void operator*=(const Matrix4x4& other);
 
        Matrix4x4 operator/(const Matrix4x4& other) const;
        void operator/=(const Matrix4x4& other);
 
        Matrix4x4 operator*(const double scalar) const;
        void operator*=(const double scalar);
 
        Matrix4x4 operator/(const double denominator) const;
        void operator/=(const double denominator);
 
        Matrix4x4 operator+(const Matrix4x4& other) const;
        void operator+=(const Matrix4x4& other);
 
        Matrix4x4 operator-(const Matrix4x4& other) const;
        void operator-=(const Matrix4x4& other);
 
 
        std::array<double, 4>& operator[](std::size_t y);
        const std::array<double, 4>& operator[](std::size_t y) const;
 
        void operator=(const Matrix4x4& other);
        void operator=(Matrix4x4&& other) noexcept;
 
        bool operator==(const Matrix4x4& other);
        bool operator!=(const Matrix4x4& other);
 
        const Vector3d GetTranslationComponent() const;
        void SetTranslationComponent(const Vector3d& trans);
 
        Matrix4x4 DropTranslationComponents() const;
 
        Matrix4x4 Transpose3x3() const;
 
        Matrix4x4 Transpose4x4() const;
 
        Matrix4x4 Multiply4x4(const Matrix4x4& o) const;
 
        Matrix4x4 GetCofactors(std::size_t p, std::size_t q, std::size_t n) const;
 
        double Determinant(std::size_t n) const;
 
        Matrix4x4 Adjoint(std::size_t n) const;
 
        Matrix4x4 Inverse3x3() const;
 
        Matrix4x4 Inverse4x4() const;
 
        bool IsInversible3x3() const;
 
        bool IsInversible4x4() const;
 
        bool Similar(const Matrix4x4& other, double epsilon = 0.00001) const;
 
        friend std::ostream& operator<<(std::ostream& os, const Matrix4x4& m);
        friend std::wostream& operator<<(std::wostream& os, const Matrix4x4& m);
 
        // Shorthands
        double& a = v[0][0];
        double& b = v[0][1];
        double& c = v[0][2];
        double& d = v[0][3];
        double& e = v[1][0];
        double& f = v[1][1];
        double& g = v[1][2];
        double& h = v[1][3];
        double& i = v[2][0];
        double& j = v[2][1];
        double& k = v[2][2];
        double& l = v[2][3];
        double& m = v[3][0];
        double& n = v[3][1];
        double& o = v[3][2];
        double& p = v[3][3];
    };
}