matrix.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_MATH_MATRIX_H
#define ARCHON_MATH_MATRIX_H

#include <archon/math/quaternion.H>

namespace Archon
{
  namespace Math
  {
    struct Matrix3x3
    {
      Vector3 x, y, z;

      static const Matrix3x3 &zero();
      static const Matrix3x3 &identity();

      Matrix3x3() {}
      Matrix3x3(const Vector3 &x, const Vector3 &y, const Vector3 &z): x(x), y(y), z(z) {}

      Matrix3x3(Vector3 y, Vector3 z): x(normalize(y*z)), y(normalize(z*x)), z(normalize(z)) {}

      explicit Matrix3x3(const Rotation3 &r)       { setRotation(r); }
      explicit Matrix3x3(const Quaternion &q)    { setRotation(q); }

      Vector3 getRow1() const                    { return Vector3(x[0], y[0], z[0]); }
      Vector3 getRow2() const                    { return Vector3(x[1], y[1], z[1]); }
      Vector3 getRow3() const                    { return Vector3(x[2], y[2], z[2]); }

      double dotRow1(const Vector3 &v) const     { return x[0]*v[0] + y[0]*v[1] + z[0]*v[2]; }
      double dotRow2(const Vector3 &v) const     { return x[1]*v[0] + y[1]*v[1] + z[1]*v[2]; }
      double dotRow3(const Vector3 &v) const     { return x[2]*v[0] + y[2]*v[1] + z[2]*v[2]; }

      Vector3 diag() const                       { return Vector3(x[0], y[1], z[2]); }
      double det() const                         { return x[0]*y[1]*z[2] + y[0]*z[1]*x[2] + z[0]*x[1]*y[2] -
                                                     x[0]*z[1]*y[2] - y[0]*x[1]*z[2] - z[0]*y[1]*x[2]; }

      Matrix3x3 operator+(const Matrix3x3 &m) const { Matrix3x3 n(*this); return n += m; }
      Matrix3x3 operator-(const Matrix3x3 &m) const { Matrix3x3 n(*this); return n -= m; }
      Matrix3x3 operator*(const Matrix3x3 &m) const { Matrix3x3 n(*this); return n *= m; }
      Matrix3x3 operator/(const Matrix3x3 &m) const { Matrix3x3 n(*this); return n /= m; }

      void map(Vector3 &v) const { v.set(dotRow1(v), dotRow2(v), dotRow3(v)); }
      Vector3 operator()(const Vector3 &v) const { Vector3 w(v); map(w); return w; }
      Vector3 operator*(const Vector3 &v) const  { return operator()(v); }

      Matrix3x3 operator*(double f) const        { Matrix3x3 m(*this); return m *= f; }
      Matrix3x3 operator/(double f) const        { Matrix3x3 m(*this); return m /= f; }

      Matrix3x3 operator-() const                { Matrix3x3 m(*this); m.negate(); return m; }


      Matrix3x3 &operator+=(const Matrix3x3 &m)  { x += m.x; y += m.y; z += m.z; return *this; }
      Matrix3x3 &operator-=(const Matrix3x3 &m)  { x -= m.x; y -= m.y; z -= m.z; return *this; }
      Matrix3x3 &operator*=(const Matrix3x3 &m)  { setRow1(dotRow1(m.x), dotRow1(m.y), dotRow1(m.z));
      setRow2(dotRow2(m.x), dotRow2(m.y), dotRow2(m.z));
      setRow3(dotRow3(m.x), dotRow3(m.y), dotRow3(m.z));
      return *this; }
      Matrix3x3 &operator/=(const Matrix3x3 &m)  { Matrix3x3 n; n.setInverseOf(m);
      operator*=(n); return *this; }
      Matrix3x3 &operator*=(double f)            { x *= f; y *= f; z *= f; return *this; }
      Matrix3x3 &operator/=(double f)            { x /= f; y /= f; z /= f; return *this; }

      bool operator==(const Matrix3x3 &m) const  { return x == m.x && y == m.y && z == m.z; }
      bool operator!=(const Matrix3x3 &m) const  { return x != m.x || y != m.y || z != m.z; }

      void set(const Vector3 &x, const Vector3 &y, const Vector3 &z)
      {
        this->x = x; this->y = y; this->z = z;
      }

      void setRow1(const Vector3 &v)             { x[0] = v[0]; y[0] = v[1]; z[0] = v[2]; }
      void setRow2(const Vector3 &v)             { x[1] = v[0]; y[1] = v[1]; z[1] = v[2]; }
      void setRow3(const Vector3 &v)             { x[2] = v[0]; y[2] = v[1]; z[2] = v[2]; }

      void setRow1(double x, double y, double z) { this->x[0] = x; this->y[0] = y; this->z[0] = z; }
      void setRow2(double x, double y, double z) { this->x[1] = x; this->y[1] = y; this->z[1] = z; }
      void setRow3(double x, double y, double z) { this->x[2] = x; this->y[2] = y; this->z[2] = z; }

      void setRotation(const Rotation3 &);

      void setRotation(const Quaternion &);

      void setInverseOf(const Matrix3x3 &);

      void negate()
      {
        x.negate();
        y.negate();
        z.negate();
      }

      void transpose()
      {
        double t;
        t = y[0]; y[0] = x[1]; x[1] = t;
        t = z[0]; z[0] = x[2]; x[2] = t;
        t = z[1]; z[1] = y[2]; y[2] = t;
      }

      void scale(const Vector3 &s)
      {
        x*=s[0];
        y*=s[1];
        z*=s[2];
      }

      void invScale(const Vector3 &s)
      {
        x/=s[0];
        y/=s[1];
        z/=s[2];
      }

      void rotate(const Rotation3 &r);

      void pitch(double angle);

      void yaw(double angle);

      void roll(double angle);

      void rotateRightHandedOrthoNormal(const Rotation3 &);

      void pitchRightHandedOrthoNormal(double angle);

      void yawRightHandedOrthoNormal(double angle);

      void rollRightHandedOrthoNormal(double angle);

    private:
      static Matrix3x3 makeZero();
      static Matrix3x3 makeIdentity();
    };

    inline Matrix3x3 transpose(const Matrix3x3 &m)
    {
      Matrix3x3 n(m); n.transpose(); return n;
    }

    inline Matrix3x3 operator*(double f, const Matrix3x3 &m)
    {
      Matrix3x3 n(m); return n *= f;
    }

    inline Matrix3x3 operator/(double f, const Matrix3x3 &m)
    {
      Matrix3x3 n; n.setInverseOf(m); return n *= f;
    }

    inline Vector3 &operator*=(Vector3 &v, const Matrix3x3 &m)
    {
      v.set(dot(v, m.x), dot(v, m.y), dot(v, m.z)); return v;
    }

    inline Vector3 operator*(const Vector3 &v, const Matrix3x3 &m)
    {
      Vector3 w(v); return w *= m;
    }

    std::ostream &operator<<(std::ostream &, const Matrix3x3 &);
  }
}

#endif // ARCHON_MATH_MATRIX_H

---