TMatrix44.h

Go to the documentation of this file.

 
#pragma once
#include <math/TVector3D.h>
#include <string>
 
namespace sf
{
 
// Forward declaration.
template<typename T>
class TQuaternion;

template<typename T>
class TMatrix44
{
  public:
    typedef T value_type;

    TMatrix44() = default;

    TMatrix44(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);

    TMatrix44(std::initializer_list<T[4]> list);

    // ReSharper disable once CppNonExplicitConvertingConstructor
    TMatrix44(const std::string& str);

    explicit TMatrix44(const T[4][4]);

    explicit TMatrix44(const T*);

    explicit TMatrix44(const TVector3D<T>& v);

    TMatrix44(T tilt, T pan, T roll);

    TMatrix44(const TMatrix44&);

    TMatrix44(TMatrix44&&) noexcept;

    TMatrix44& unit();

    T determinant(bool only_3x3 = true) const;

    TMatrix44& invert();

    TMatrix44 inverse() const;

    TMatrix44 transposed() const;

    TMatrix44& transpose();

    TMatrix44& assign(const T[4][4]);

    TMatrix44& assign(const T*);

    TMatrix44& transposeAssign(const T[4][4]);

    TMatrix44& operator=(const TMatrix44&);
    TMatrix44& operator=(TMatrix44&& m) noexcept;

    TMatrix44& operator*=(const TMatrix44&);

    TVector3D<T> operator^(const TVector3D<T>&) const;

    TVector3D<T> operator*(const TVector3D<T>&) const;

    value_type* data();

    const value_type* data() const;

    // ReSharper disable once CppNonExplicitConversionOperator
    operator T*();

    // ReSharper disable once CppNonExplicitConversionOperator
    operator const T*() const;

    bool isEqual(const TMatrix44& m, T tol = tolerance) const;

    bool isRotational() const;

    bool operator==(const TMatrix44&) const;

    bool operator!=(const TMatrix44&) const;

    void copyTo(T[4][4], bool column_order = false) const;

    void copyTo(T*, bool column_order = false) const;

    TMatrix44& setTiltPanRoll(T tilt, T pan, T roll);

    void getTiltPanRoll(T& tilt, T& pan, T& roll) const;

    TMatrix44& rotate(T angle, const TVector3D<T>& vec, bool only = true);

    TMatrix44& rotate(T angle, T x, T y, T z, bool only = true);

    TMatrix44 rotated(T angle, T x, T y, T z, bool only = true) const;

    TMatrix44 rotated(T angle, const TVector3D<T>& vec, bool only = true) const;

    void setPerspectiveProjection(T near_plane, T far_plane, T fov);

    TMatrix44& multiply(const TMatrix44& m);

    TMatrix44 multiplied(const TMatrix44& m) const;

    TMatrix44& rotate(const TMatrix44& m);

    TMatrix44 rotated(const TMatrix44& m) const;

    TVector3D<T> transformed(const TVector3D<T>& v, bool translate) const;

    TMatrix44& clearTranslation();

    TMatrix44& translate(const TVector3D<T>& v, bool only = true);

    TMatrix44& translate(T x, T y, T z, bool only = true);

    TMatrix44 translated(const TVector3D<T>& v, bool only = true) const;

    TMatrix44 translated(T x, T y, T z, bool only = true) const;

    TVector3D<T> getTranslation() const;

    TMatrix44& setTranslation(const TVector3D<T>& v);

    TMatrix44& setTranslation(T x, T y, T z);

    TMatrix44& scale(T factor, bool translation = true);

    TMatrix44& scale(T x, T y, T z, bool translation = true);

    TMatrix44& scale(TVector3D<T> factor, bool translation = true);

    enum EAxis : unsigned int
    {
      axisX = 0,
      axisY = 1,
      axisZ = 2,
      axisT = 3
    };

    TVector3D<T> getAxis(EAxis axis) const;

    TMatrix44 orbit(T horizontal, T vertical) const;

    TMatrix44 orientation() const;

    void setElement(unsigned int row, unsigned int column, T value);

    T element(unsigned int row, unsigned int column) const;

    T& element(unsigned int row, unsigned int column);

    T& operator()(int row, int column);

    T operator()(int row, int column) const;

    template<typename R>
    void toOpenGL(R* matrix) const;

    template<typename R>
    std::array<R, 16> toOpenGL() const;

    template<typename R>
    TMatrix44& fromOpenGL(const R* matrix);

    TQuaternion<T> quaternion() const;

    TMatrix44& resetOrientation();

    TMatrix44& setOrientationXY(const TVector3D<T>& x_axis, const TVector3D<T>& y_axis, bool x_dominant = false);

    TMatrix44& setOrientationZY(const TVector3D<T>& z_axis, const TVector3D<T>& y_axis, bool z_dominant = false);

    TMatrix44& insertGIGRotXYZ(T rx, T ry, T rz);

    std::string toString(int digits = 0) const;

    TMatrix44& fromString(const std::string& s, bool ignore_err = false) noexcept(false);

    static constexpr auto tolerance = TVector3D<T>::tolerance;
 
  protected:
    union data_type
    {
        T array[4 * 4];
        T mtx[4][4];
    } _data = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
};

template<typename T>
TMatrix44<T> operator*(const TMatrix44<T>& lm, const TMatrix44<T>& rm);

template<typename T>
std::ostream& operator<<(std::ostream& os, const TMatrix44<T>& mtx);

template<typename T>
std::istream& operator>>(std::istream& is, TMatrix44<T>& mtx) noexcept(false);
 
}// namespace sf
 
#ifndef __JETBRAINS_IDE__
  // Include all inlined functions and template implementations.
  #include <math/TMatrix44.hpp>
#endif