matrix4x4.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Stephen Bridges                                 *
 *   widget@widget.dynu.com                                                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
// $Id$

#ifndef MATRIX4X4_H
#define MATRIX4X4_H

#include "maths.h"
#include "vec4.h"

class Matrix4x4
{
public:
    float m[16];
    Matrix4x4();

    ~Matrix4x4();
    // Copy time
    Matrix4x4(const Matrix4x4& other);
    Matrix4x4& operator=(const Matrix4x4& other);
    // Add
    Matrix4x4 operator+(const Matrix4x4& other) const;
    Matrix4x4 &operator+=(const Matrix4x4& other);
    // Minus
    Matrix4x4 operator-(const Matrix4x4& other) const;
    Matrix4x4 &operator-=(const Matrix4x4& other);
    // Multiply by scalar
    Matrix4x4 operator*(const float other) const;
    Matrix4x4 &operator*=(const float other);
    // Multiply by Matrix
    Matrix4x4 operator*(const Matrix4x4 &o) const;
    Matrix4x4 &operator*=(const Matrix4x4 &o);
    // The accessing functions
    float &operator()(unsigned int i, unsigned int j);
    float operator()(unsigned int i, unsigned int j) const;
    // Comparisions
    bool operator==(Matrix4x4 &other);
    bool operator!=(Matrix4x4 &other);
    // Matrix functions
    bool isAffine(void);
    
    void scale(float xin, float yin, float zin);
    void trans(float xin, float yin, float zin);
    void rotate(float xin, float yin, float zin);
    void scale(Vec4 in);
    void trans(Vec4 in);
    void rotate(Vec4 in);
    void rotX(float in);
    void rotY(float in);
    void rotZ(float in);
    
    void makeScale(float xin, float yin, float zin);
    void makeTrans(float xin, float yin, float zin);
    void makeRotate(float xin, float yin, float zin);
    void makeScale(Vec4 in);
//     void makeTrans(Vec4 in); NOT DEFINED YET
    void makeRotate(Vec4 in);
    void makeRotX(float in);
    void makeRotY(float in);
    void makeRotZ(float in);
    
    void invert(void);
    void transpose(void);
    // Default matrices
    void Identity(void);
    void Zero(void);
    void Print(void);
    void Clean(void);
//     Matrix4x4 &onlyTrans(void);
//     Matrix4x4 &onlyRot(void);
//     Matrix4x4 &onlyScale(void);
};

Matrix4x4 makeInverse(const Matrix4x4 &in);

inline float &Matrix4x4::operator()(unsigned int i, unsigned int j)
{
    return m[i + 4*j];
}

inline float Matrix4x4::operator ()(unsigned int i, unsigned int j) const
{
    return m[i + 4*j];
}

/*
 * $Log$
 */ 

#endif

// EOF

---