matrix3.h

Go to the documentation of this file.

/**********************************************************************
 *<
   FILE: matrix3.h

   DESCRIPTION: Class definitions for Matrix3

   CREATED BY: Dan Silva

   HISTORY:

 *>   Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/
#pragma once

#include "GeomExport.h"
#include "maxheap.h"
#include "ioapi.h"
#include "point3.h"
#include "point4.h"

//Flags
#define POS_IDENT  1
#define ROT_IDENT  2
#define SCL_IDENT  4
#define MAT_IDENT (POS_IDENT|ROT_IDENT|SCL_IDENT)

typedef float MRow[3];

class Quat;
class AngAxis;

class Matrix3;

class Matrix3: public MaxHeapOperators {
   friend Matrix3 GEOMEXPORT RotateXMatrix(float angle);   
   friend Matrix3 GEOMEXPORT RotateYMatrix(float angle); 
   friend Matrix3 GEOMEXPORT RotateZMatrix(float angle); 
   friend Matrix3 GEOMEXPORT TransMatrix(const Point3& p);
   friend Matrix3 GEOMEXPORT ScaleMatrix(const Point3& s);
   friend Matrix3 GEOMEXPORT RotateYPRMatrix(float Yaw, float Pitch, float Roll);
   friend Matrix3 GEOMEXPORT RotAngleAxisMatrix(Point3& axis, float angle);
   friend Matrix3 GEOMEXPORT Inverse(const Matrix3& M);
   friend Point3 GEOMEXPORT operator*(const Matrix3& A, const Point3& V);
   friend Point3 GEOMEXPORT operator*(const Point3& V, const Matrix3& A);
   friend Point3 GEOMEXPORT VectorTransform(const Matrix3& M, const Point3& V); 
   friend Matrix3 GEOMEXPORT XFormMat(const Matrix3& xm, const Matrix3& m);
    friend Point3 GEOMEXPORT VectorTransform(const Point3& V, const Matrix3& M);
   friend class Quat;
   float m[4][3];
   // Access i-th row as Point3 for read or assignment:
   Point3& operator[](int i) { return((Point3&)(*m[i]));  }
   DWORD flags;

public:
   const Point3& operator[](int i) const { return((Point3&)(*m[i])); }
   // if change any components directly via GetAddr, must call this
   void SetNotIdent() { flags &= ~MAT_IDENT; }
   void SetIdentFlags(DWORD f) { flags &= ~MAT_IDENT; flags |= f; }
   DWORD GetIdentFlags() const { return flags; }
   void ClearIdentFlag(DWORD f) { flags &= ~f; }
   BOOL IsIdentity() const { return ((flags&MAT_IDENT)==MAT_IDENT); }
   GEOMEXPORT void ValidateFlags(); // recomputes the IDENT flags

   // CAUTION: if you change the matrix via this pointer, you MUST clear the
   // proper IDENT flags !!!
   MRow* GetAddr() { return (MRow *)(m); }   
   const MRow* GetAddr() const { return (MRow *)(m); }

   // Constructors
   Matrix3(){ flags = 0; }  // NO INITIALIZATION done in this constructor!!             
   Matrix3(BOOL /*init*/) {flags=0; IdentityMatrix();}
   GEOMEXPORT Matrix3(float (*fp)[3]);
    Matrix3(const Point3& U, const Point3& V, const Point3& N, const Point3& T) {
        flags = 0; SetRow(0, U); SetRow(1, V); SetRow(2, N); SetRow(3, T); 
        ValidateFlags(); }

    Matrix3& Set(const Point3& U, const Point3& V, const Point3& N, const Point3& T) {
        flags = 0; SetRow(0, U); SetRow(1, V); SetRow(2, N); SetRow(3, T);
        ValidateFlags(); return *this; }

    // Data member
    static const Matrix3 Identity;

    // Comparison operators
    GEOMEXPORT int operator==(const Matrix3& M) const;
    GEOMEXPORT int Equals(const Matrix3& M, float epsilon = 1E-6f) const;

   // Assignment operators
   GEOMEXPORT Matrix3& operator-=( const Matrix3& M);
   GEOMEXPORT Matrix3& operator+=( const Matrix3& M); 
   GEOMEXPORT Matrix3& operator*=( const Matrix3& M);     // Matrix multiplication
   GEOMEXPORT Matrix3& operator*=( float a);

   // Operations on matrix
   GEOMEXPORT void IdentityMatrix();       // Make into the Identity Matrix
   GEOMEXPORT void Zero();     // set all elements to 0
   
   Point3 GetRow(int i) const { return (*this)[i]; }  
   GEOMEXPORT void SetRow(int i, Point3 p);

   GEOMEXPORT Point4 GetColumn(int i) const;
   GEOMEXPORT void SetColumn(int i, Point4 col);
   GEOMEXPORT Point3 GetColumn3(int i) const;

   // zero the translation part;
   GEOMEXPORT void NoTrans();
   // null out the rotation part;
   GEOMEXPORT void NoRot();
   // null out the scale part;
   GEOMEXPORT void NoScale();
   
   // This is an "unbiased" orthogonalization
   // It seems to take a maximum of 4 iterations to converge.
   GEOMEXPORT void Orthogonalize();

   // Access the translation row
   void SetTrans(const Point3 p) { (*this)[3] = p;  flags &= ~POS_IDENT; }
   void SetTrans(int i, float v) { (*this)[3][i] = v; flags &= ~POS_IDENT; }
   const Point3& GetTrans() const { return (*this)[3]; }
   
   // Apply Incremental transformations to this matrix
   // Equivalent to multiplying on the RIGHT by transform
   GEOMEXPORT void Translate(const Point3& p);
   GEOMEXPORT void RotateX(float angle);  
   GEOMEXPORT void RotateY(float angle);
   GEOMEXPORT void RotateZ(float angle);
   // if trans = FALSE the translation component is unaffected:
   GEOMEXPORT void Scale(const Point3& s, BOOL trans = FALSE);

   // Apply Incremental transformations to this matrix
   // Equivalent to multiplying on the LEFT by transform 
   GEOMEXPORT void PreTranslate(const Point3& p);
   GEOMEXPORT void PreRotateX(float angle);  
   GEOMEXPORT void PreRotateY(float angle);
   GEOMEXPORT void PreRotateZ(float angle);
   // if trans = FALSE the translation component is unaffected:
   GEOMEXPORT void PreScale(const Point3& s, BOOL trans = FALSE);

    // set matrix as described
    GEOMEXPORT void SetTranslate(const Point3& p);     // makes translation matrix
    GEOMEXPORT void SetRotateX(float angle);           // makes rotation matrix
    GEOMEXPORT void SetRotateY(float angle);
    GEOMEXPORT void SetRotateZ(float angle);
    GEOMEXPORT void SetRotate(const Quat& q);
    GEOMEXPORT void SetRotate(const AngAxis& aa);
    GEOMEXPORT void SetRotate(float yaw, float pitch, float roll);
    GEOMEXPORT void SetAngleAxis(const Point3& axis, float angle);
    GEOMEXPORT void SetScale(const Point3& s);          // makes scale matrix
    GEOMEXPORT void SetFromToUp(const Point3& from, const Point3& to, const Point3& up);
    GEOMEXPORT void Invert();                          // in place
      
    //binary operators
   GEOMEXPORT Matrix3 operator*(const Matrix3&) const;
   GEOMEXPORT Matrix3 operator+(const Matrix3&) const;
   GEOMEXPORT Matrix3 operator-(const Matrix3&) const;

    GEOMEXPORT Point3 PointTransform(const Point3& p) const;
    GEOMEXPORT Point3 VectorTransform(const Point3& p) const;
    GEOMEXPORT void TransformPoints(Point3 *array, int n,
                int stride = sizeof(Point3));
    GEOMEXPORT void TransformPoints(const Point3 *array, Point3 *to, int n,
                int stride = sizeof(Point3), int strideTo = sizeof(Point3));
    GEOMEXPORT void TransformVectors(Point3 *array, int n,
                int stride = sizeof(Point3));
    GEOMEXPORT void TransformVectors(const Point3 *array, Point3 *to, int n,
                int stride = sizeof(Point3), int strideTo = sizeof(Point3));

    // Property function
    GEOMEXPORT void GetYawPitchRoll(float *yaw, float *pitch, float *roll);

    // I/O
   GEOMEXPORT IOResult Save(ISave* isave);
   GEOMEXPORT IOResult Load(ILoad* iload);

   GEOMEXPORT BOOL Parity() const;
   };

// Build new matrices for transformations
GEOMEXPORT Matrix3 RotateXMatrix(float angle);   
GEOMEXPORT Matrix3 RotateYMatrix(float angle); 
GEOMEXPORT Matrix3 RotateZMatrix(float angle); 
GEOMEXPORT Matrix3 TransMatrix(const Point3& p);
GEOMEXPORT Matrix3 ScaleMatrix(const Point3& s);
GEOMEXPORT Matrix3 RotateYPRMatrix(float Yaw, float Pitch, float Roll);
GEOMEXPORT Matrix3 RotAngleAxisMatrix(Point3& axis, float angle);
 
GEOMEXPORT Matrix3 Inverse(const Matrix3& M);  // return Inverse of matrix

// These two versions of transforming a point with a matrix do the same thing,
// regardless of the order of operands (linear algebra rules notwithstanding).
GEOMEXPORT Point3 operator*(const Matrix3& A, const Point3& V); // Transform Point with matrix
GEOMEXPORT Point3 operator*(const Point3& V, const Matrix3& A); // Transform Point with matrix

// ditto
GEOMEXPORT Point3 VectorTransform(const Matrix3& M, const Point3& V); 
GEOMEXPORT Point3 VectorTransform(const Point3& V, const Matrix3& M); 

// transform a plane: this only works if M is orthogonal
GEOMEXPORT Point4 TransformPlane(const Matrix3& M, const Point4& plin); 

// transformats matrix m so it is applied in the space of matrix xm:
//  returns xm*m*Inverse(xm)
GEOMEXPORT Matrix3 XFormMat(const Matrix3& xm, const Matrix3& m);