matrix4x4.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_MATRIX4X4_H_
#define INCLUDE_JET_MATRIX4X4_H_
 
#include <jet/matrix3x3.h>
#include <jet/vector4.h>
 
#include <array>
#include <limits>
 
namespace jet {
 
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>>& lst);
 
    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>>& lst);
 
    void set(const Matrix3x3<T>& 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 Matrix3x3<T>& m33);
 
    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 strictLowerTri() const;
 
    Matrix strictUpperTri() const;
 
    Matrix lowerTri() const;
 
    Matrix upperTri() 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*=(const Matrix3x3<T>& 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> _elements;
};
 
template <typename T>
using Matrix4x4 = Matrix<T, 4, 4>;
 
// Operator overloadings
template <typename T>
Matrix4x4<T> operator-(const Matrix4x4<T>& a);
 
template <typename T>
Matrix4x4<T> operator+(const Matrix4x4<T>& a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator+(const Matrix4x4<T>& a, T b);
 
template <typename T>
Matrix4x4<T> operator+(T a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator-(const Matrix4x4<T>& a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator-(const Matrix4x4<T>& a, T b);
 
template <typename T>
Matrix4x4<T> operator-(T a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator*(const Matrix4x4<T>& a, T b);
 
template <typename T>
Matrix4x4<T> operator*(T a, const Matrix4x4<T>& b);
 
template <typename T>
Vector3<T> operator*(const Matrix4x4<T>& a, const Vector3<T>& b);
 
template <typename T>
Vector4<T> operator*(const Matrix4x4<T>& a, const Vector4<T>& b);
 
template <typename T>
Matrix4x4<T> operator*(const Matrix4x4<T>& a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix4x4<T> operator*(const Matrix3x3<T>& a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator*(const Matrix4x4<T>& a, const Matrix4x4<T>& b);
 
template <typename T>
Matrix4x4<T> operator/(const Matrix4x4<T>& a, T b);
 
template <typename T>
Matrix4x4<T> operator/(const T& a, const Matrix4x4<T>& b);
 
typedef Matrix4x4<float> Matrix4x4F;
 
typedef Matrix4x4<double> Matrix4x4D;
 
}  // namespace jet
 
#include "detail/matrix4x4-inl.h"
 
#endif  // INCLUDE_JET_MATRIX4X4_H_