3esmatrix4.h

//
// author: Kazys Stepanas
//
#ifndef _3ESMATRIX4_H_
#define _3ESMATRIX4_H_

#include "3es-core.h"

#include "3esvector3.h"
#include "3esvector4.h"

namespace tes
{
  template <typename T>
  class Matrix4
  {
  public:
    union
    {
      T rc[4][4]; 
      T m[16];    
    };

    static const Matrix4<T> zero; 
    static const Matrix4<T> identity; 

    inline Matrix4() {}
    Matrix4(const T *array16);
    Matrix4(const Matrix4<T> &other);
    template <typename Q>
    Matrix4(const Matrix4<Q> &other);

    Matrix4(const T &rc00, const T &rc01, const T &rc02, const T &rc03,
            const T &rc10, const T &rc11, const T &rc12, const T &rc13,
            const T &rc20, const T &rc21, const T &rc22, const T &rc23,
            const T &rc30, const T &rc31, const T &rc32, const T &rc33);

    inline T &operator()(int r, int c) { return rc[r][c]; }
    inline const T &operator()(int r, int c) const { return rc[r][c]; }

    inline T &operator[](int index) { return m[index]; }

    inline const T &operator[](int index) const { return m[index]; }

    static Matrix4<T> rotationX(const T &angle);

    inline Matrix4<T> &initRotationX(const T &angle) { *this = rotationX(angle); return *this; }

    static Matrix4<T> rotationY(const T &angle);

    inline Matrix4<T> &initRotationY(const T &angle) { *this = rotationY(angle); return *this; }

    static Matrix4<T> rotationZ(const T &angle);

    inline Matrix4<T> &initRotationZ(const T &angle) { *this = rotationZ(angle); return *this; }

    static Matrix4<T> rotation(const T &x, const T &y, const T &z);

    inline Matrix4<T> &initRotation(const T &x, const T &y, const T &z) { *this = rotation(x, y, z); return *this; }

    static Matrix4<T> translation(const Vector3<T> &trans);

    inline Matrix4<T> initTranslation(const Vector3<T> &trans) { *this = translation(trans); return *this; }

    static Matrix4<T> rotationTranslation(const T &x, const T &y, const T &z, const Vector3<T> &trans);
    inline Matrix4<T> &initRotationTranslation(const T &x, const T &y, const T &z, const Vector3<T> &trans) { *this = rotationTranslation(x, y, z, trans); return *this; }

    static Matrix4<T> scaling(const Vector3<T> &scale);

    inline Matrix4<T> &initScaling(const Vector3<T> &scale) { *this = scaling(scale); return *this; }

    static Matrix4<T> lookAt(const Vector3<T> &eye, const Vector3<T> &target, const Vector3<T> &axisUp, int forwardAxisIndex = 1, int upAxisIndex = 2);

    inline Matrix4<T> &initLookAt(const Vector3<T> &eye, const Vector3<T> &target, const Vector3<T> &axisUp, int forwardAxisIndex = 1, int upAxisIndex = 2)
    {
      *this = lookAt(eye, target, axisUp, forwardAxisIndex, upAxisIndex);
      return *this;
    }

    Matrix4<T> &transpose();

    Matrix4<T> transposed() const;

    Matrix4<T> &invert();

    Matrix4<T> inverse() const;

    Matrix4<T> &rigidBodyInvert();

    Matrix4<T> rigidBodyInverse() const;

    T determinant() const;

    Vector3<T> axisX() const;
    Vector3<T> axisY() const;
    Vector3<T> axisZ() const;

    Vector3<T> axisT() const;

    Vector3<T> translation() const;

    Vector3<T> axis(int index) const;

    Matrix4<T> &setAxisX(const Vector3<T> &axis);

    Matrix4<T> &setAxisY(const Vector3<T> &axis);

    Matrix4<T> &setAxisZ(const Vector3<T> &axis);

    Matrix4<T> &setAxisT(const Vector3<T> &axis);

    Matrix4<T> &setTranslation(const Vector3<T> &axis);

    Matrix4<T> &setAxis(int index, const Vector3<T> &axis);

    Vector3<T> scale() const;

    Vector3<T> removeScale();

    Matrix4<T> &scale(const Vector3<T> &scaling);

    Vector3<T> transform(const Vector3<T> &v) const;

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

    Vector3<T> rotate(const Vector3<T> &v) const;

    Vector4<T> rotate(const Vector4<T> &v) const;
  };

  typedef Matrix4<float> Matrix4f;
  typedef Matrix4<double> Matrix4d;

  template class _3es_coreAPI Matrix4<float>;
  template class _3es_coreAPI Matrix4<double>;

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

  template <typename T>
  Vector3<T> operator * (const Matrix4<T> &a, const Vector3<T> &v);

  template <typename T>
  Vector4<T> operator * (const Matrix4<T> &a, const Vector4<T> &v);
}

#include "3esmatrix4.inl"

#endif // _3ESMATRIX4_H_