Matrix3.h

/****************************************************************************
 * Copyright 2005 Evan Drumwright
 * This library is distributed under the terms of the GNU General Public 
 * License (found in COPYING).
 ****************************************************************************/

#ifndef _MATRIX3_H
#define _MATRIX3_H

#include <Physsim/Vector3.h>
#include <Physsim/MatrixNN.h>

namespace Physsim {

class Quat;
class AAngle;

class Matrix3 : public MatrixNN
{
        public:
                Matrix3();
                Matrix3(const boost::shared_array<Real> array);
                Matrix3(Real m00, Real m01, Real m02, Real m10, Real m11, Real m12, Real m20, Real m21, Real m22);
                Matrix3(const Quat* q);
                Matrix3(const Matrix3& source);
                Matrix3(const MatrixNN& source);
                Matrix3(const MatrixN& source);
                Matrix3(const AAngle* a);
                bool epsilon_equals(const Matrix3& m, Real epsilon) const;
                static bool epsilon_equals(const Matrix3& m1, const Matrix3& m2, Real epsilon);
                Real det() const;
                void invert();
                static Matrix3 invert(const Matrix3& m);
                void set_rot_X(Real angle);
                static Matrix3 rot_X(Real angle);
                void set_rot_Y(Real angle);
                static Matrix3 rot_Y(Real angle);
                void set_rot_Z(Real angle);
                static Matrix3 rot_Z(Real angle);
                void set(const AAngle* a);
                void set(Real scale);
                void set(const Quat* q);
                static Matrix3 skew_symmetric(Real a, Real b, Real c);
                static Matrix3 skew_symmetric(const Vector3& v);
                static bool valid_rotation(const Matrix3& R);
                void operator=(const Matrix3& source) { MatrixN::operator=(source); }
                virtual void operator=(const MatrixN& source) { assert(source.rows() == 3 && source.columns() == 3); MatrixN::operator=(source); }
                virtual void operator=(const MatrixNN& source) { assert(source.rows() == 3); MatrixN::operator=(source); }
                Vector3 operator*(const Vector3& v) const;
//              void operator+=(const Matrix3& m) { MatrixN::operator+=(m); }
//              void operator-=(const Matrix3& m) { MatrixN::operator-=(m); }
                Matrix3 operator*(const Matrix3& m) const { return Matrix3(MatrixN::operator*(m)); }
                Matrix3 operator*(Real scalar) const { return Matrix3((MatrixN::operator*(scalar))); }
                Matrix3 operator/(Real scalar) const { return Matrix3((MatrixN::operator/(scalar))); }          
}; // end class
} // end namespace

#endif

---