source: golgotha/src/max_plugin/sdk_inc/matrix3.h @ 80 Tweet

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

        DESCRIPTION: Class definitions for Matrix3

        CREATED BY: Dan Silva

        HISTORY:

 *>     Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/
#ifndef _MATRIX3_H 

#define _MATRIX3_H 

#include "ioapi.h"
#include "point3.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];

struct Point4 {
        float r[4];
        };

class Quat;

class Matrix3 {
        friend Matrix3 DllExport RotateXMatrix(float angle);   
        friend Matrix3 DllExport RotateYMatrix(float angle); 
        friend Matrix3 DllExport RotateZMatrix(float angle); 
        friend Matrix3 DllExport TransMatrix(const Point3& p);
        friend Matrix3 DllExport ScaleMatrix(const Point3& s);
        friend Matrix3 DllExport RotateYPRMatrix(float Yaw, float Pitch, float Roll);
        friend Matrix3 DllExport RotAngleAxisMatrix(Point3& axis, float angle);
        friend Matrix3 DllExport Inverse(const Matrix3& M);
        friend Point3 DllExport operator*(const Matrix3& A, const Point3& V);
        friend Point3 DllExport operator*(const Point3& V, const Matrix3& A);
        friend Point3 DllExport VectorTransform(const Matrix3& M, const Point3& V); 
        friend Matrix3 DllExport XFormMat(const Matrix3& xm, 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]));  }
        Point3& operator[](int i) const { return((Point3&)(*m[i])); }
        DWORD flags;

public:
        // 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() { return ((flags&MAT_IDENT)==MAT_IDENT); }

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

        // Constructors
        Matrix3(){ flags = 0; }  // NO INITIALIZATION done in this constructor!!                                 
        Matrix3(BOOL init) {flags=0; IdentityMatrix();} // RB: An option to initialize
        DllExport Matrix3(float (*fp)[3]); 

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

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


        DllExport Point4 Matrix3::GetColumn(int i);
        DllExport void Matrix3::SetColumn(int i,  Point4 col);

        // zero the translation part;
        DllExport void NoTrans();
        // null out the rotation part;
        DllExport void NoRot();
        // null out the scale part;
        DllExport void NoScale();
        
        // This is an "unbiased" orthogonalization
        // It seems to take a maximum of 4 iterations to converge.
        DllExport 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; }
        Point3 GetTrans() { return (*this)[3]; }
   
        void SetScale(const Point3 p);

        // Apply Incremental transformations to this matrix
        // Equivalent to multiplying on the RIGHT by transform
        DllExport void Translate(const Point3& p);
        DllExport void RotateX(float angle);  
        DllExport void RotateY(float angle);
        DllExport void RotateZ(float angle);
        // if trans = FALSE the translation component is unaffected:
        DllExport void Scale(const Point3& s, BOOL trans = FALSE);

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

        DllExport IOResult Save(ISave* isave);
        DllExport IOResult Load(ILoad* iload);
        };


// Build new matrices for transformations
Matrix3 DllExport RotateXMatrix(float angle);   
Matrix3 DllExport RotateYMatrix(float angle); 
Matrix3 DllExport RotateZMatrix(float angle); 
Matrix3 DllExport TransMatrix(const Point3& p);
Matrix3 DllExport ScaleMatrix(const Point3& s);
Matrix3 DllExport RotateYPRMatrix(float Yaw, float Pitch, float Roll);
Matrix3 DllExport RotAngleAxisMatrix(Point3& axis, float angle);
 
Matrix3 DllExport 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).
Point3 DllExport operator*(const Matrix3& A, const Point3& V); // Transform Point with matrix
Point3 DllExport operator*(const Point3& V, const Matrix3& A); // Transform Point with matrix


Point3 DllExport VectorTransform(const Matrix3& M, const Point3& V); 

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

#endif _MATRIX3_H