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);
 
    explicit TMatrix44(const T[4][4]);
 
    explicit TMatrix44(const T*);
 
    explicit TMatrix44(const TVector3D<T>& tv);
 
    TMatrix44(T tilt, T pan, T roll);
 
    explicit TMatrix44(const TQuaternion<T>& q);
 
    TMatrix44(const TMatrix44&);
 
    TMatrix44(TMatrix44&&) noexcept;
 
    TMatrix44& unit();
 
    T determinant() 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;
 
    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]) const;
 
    void copyTo(T*) const;
 
    void transposeCopyTo(T[4][4]) 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) const;
 
    void clearTranslation();
 
    TMatrix44& translate(const TVector3D<T>& v);
 
    TMatrix44& translate(T x, T y, T z);
 
    TMatrix44 translated(const TVector3D<T>& v) const;
 
    TMatrix44 translated(T x, T y, T z) const;
 
    TVector3D<T> getTranslation() const;
 
    TMatrix44 setTranslation(const TVector3D<T>& v);
 
    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 column, unsigned int row, T value);
 
    T element(unsigned int column, unsigned int row) const;
 
    T& element(unsigned int column, unsigned int row);
 
    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& assignOpenGL(const R* matrix);
 
    template<typename R>
    static TMatrix44 fromOpenGL(const R* matrix);
 
    TQuaternion<T> quaternion() const;
 
    TMatrix44& resetOrientation();
 
    TMatrix44& setOrientationXY(const TVector3D<T>& x_axis, const TVector3D<T>& y_axis);
 
    TMatrix44& setOrientationZY(const TVector3D<T>& z_axis, const TVector3D<T>& y_axis);
 
    TMatrix44& insertGIGRotXYZ(T rx, T ry, T rz);
 
    std::string toString() const;
 
    TMatrix44& fromString(const std::string& s) 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
 
// Include all inlined functions and template implementations.
#include <math/TMatrix44.hpp>