3esmatrix3.h

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

#include "3es-core.h"

#include "3esvector3.h"

namespace tes
{
  template <typename T>
  class Matrix3
  {
  public:
    union
    {
      T rc[3][3]; 
      T m[9];     
    };
    static const Matrix3<T> zero; 
    static const Matrix3<T> identity; 

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

    Matrix3(const T &rc00, const T &rc01, const T &rc02,
            const T &rc10, const T &rc11, const T &rc12,
            const T &rc20, const T &rc21, const T &rc22);

    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 Matrix3<T> rotationX(const T &angle);
    inline Matrix3<T> &initRotationX(const T &angle) { *this = rotationX(angle); return *this; }

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

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

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

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

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

    inline Matrix3<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;
    }

    Matrix3<T> &transpose();

    Matrix3<T> transposed() const;

    Matrix3<T> &invert();

    Matrix3<T> inverse() const;

    T getAdjoint(Matrix3<T> &adj) const;

    Matrix3<T> &rigidBodyInvert();

    Matrix3<T> rigidBodyInverse() const;

    T determinant() const;

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

    Vector3<T> axis(int index) const;

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

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

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

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

    Vector3<T> scale() const;

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

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

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

  typedef Matrix3<float> Matrix3f;
  typedef Matrix3<double> Matrix3d;

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

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

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

#include "3esmatrix3.inl"

#endif  // _3ESMATRIX3_H