K3dMatrix.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#include "K3dMatrix.h"

K3dMatrix::K3dMatrix()
{
        // Reset matrix
        LoadIdentity();
}

K3dMatrix::K3dMatrix(const float afMatrix[16])
{
        for( int i=0; i<16; i++)
        {
                m_afMatrix[i] = afMatrix[i];
        }
}

K3dMatrix::~K3dMatrix()         
{
}



void K3dMatrix::SetMatrix( const float *_pfMatrix, const int _iSize )
{ 
        for(int i=0; i<_iSize; i++)
        {
                m_afMatrix[i] = _pfMatrix[i];
        }
}




void K3dMatrix::SetMatrix(const K3dMatrix &_rkMatrix, const int _iSize )
{
        K3dMatrix kM = _rkMatrix;
        for(int i=0; i<_iSize; i++)
        {
                m_afMatrix[i] = kM[i];
        }
}




void K3dMatrix::SetRow(const K3dVector4 &_rkRow, const int iRow)
{
        K3dVector4 kV = _rkRow;
        if(!(0 <= iRow) && (iRow < 4) ) 
        {
                cerr << "Error: K3dMatrix::SetRow() -- error index " << iRow << endl;
        }

        switch (iRow)
        {
        case 0:
                m_afMatrix[0] = kV[0];
                m_afMatrix[1] = kV[1];
                m_afMatrix[2] = kV[2];
                m_afMatrix[3] = kV[3];
                break;
        case 1:
                m_afMatrix[4] = kV[0];
                m_afMatrix[5] = kV[1];
                m_afMatrix[6] = kV[2];
                m_afMatrix[7] = kV[3];
                break;
        case 2:
                m_afMatrix[8] = kV[0];
                m_afMatrix[9] = kV[1];
                m_afMatrix[10] = kV[2];
                m_afMatrix[11] = kV[3];
                break;
        case 3:
                m_afMatrix[12] = kV[0];
                m_afMatrix[13] = kV[1];
                m_afMatrix[14] = kV[2];
                m_afMatrix[15] = kV[3];
                break;
        }
}



void K3dMatrix::GetRow(K3dVector4 &rkRow, const int iRow)
{
        if(!(0 <= iRow) && (iRow < 4) ) 
        {
                cerr << "Error - K3dMatrix::SetRow() -- error index " << iRow << endl;
        }

        switch (iRow)
        {
        case 0:
                rkRow[0] = m_afMatrix[0];
                rkRow[1] = m_afMatrix[1];
                rkRow[2] = m_afMatrix[2];
                rkRow[3] = m_afMatrix[3];
                break;
        case 1:
                rkRow[0] = m_afMatrix[4];
                rkRow[1] = m_afMatrix[5];
                rkRow[2] = m_afMatrix[6];
                rkRow[3] = m_afMatrix[7];
                break;
        case 2:
                rkRow[0] = m_afMatrix[8];
                rkRow[1] = m_afMatrix[9];
                rkRow[2] = m_afMatrix[10];
                rkRow[3] = m_afMatrix[11];
                break;
        case 3:
                rkRow[0] = m_afMatrix[12];
                rkRow[1] = m_afMatrix[13];
                rkRow[2] = m_afMatrix[14];
                rkRow[3] = m_afMatrix[15];
                break;
        }
}



void K3dMatrix::SetColumn(const K3dVector4 &_rkColumn, const int iColumn)
{       
        if(!(0 <= iColumn) && (iColumn < 4) ) 
        {
                cerr << "Error - K3dMatrix::SetColumn() -- error index " << iColumn << endl;
        }
        K3dVector4 kV = _rkColumn;
        switch (iColumn)
        {
        case 0:
                m_afMatrix[0] = kV[0];
                m_afMatrix[4] = kV[1];
                m_afMatrix[8] = kV[2];
                m_afMatrix[12] = kV[3];
                break;
        case 1:
                m_afMatrix[1] = kV[0];
                m_afMatrix[5] = kV[1];
                m_afMatrix[9] = kV[2];
                m_afMatrix[13] = kV[3];
                break;
        case 2:
                m_afMatrix[2] = kV[0];
                m_afMatrix[6] = kV[1];
                m_afMatrix[10] = kV[2];
                m_afMatrix[14] = kV[3];
                break;
        case 3:
                m_afMatrix[3] = kV[0];
                m_afMatrix[7] = kV[1];
                m_afMatrix[11] = kV[2];
                m_afMatrix[15] = kV[3];
                break;
        }
}



void K3dMatrix::GetColumn(K3dVector4 &rkColumn, const int iColumn)
{
        if(!(0 <= iColumn) && (iColumn < 4) ) 
        {
                cerr << "Error - K3dMatrix::SetColumn() -- error index " << iColumn << endl;
        }

        switch (iColumn)
        {
        case 0:
                rkColumn[0] = m_afMatrix[0];
                rkColumn[1] = m_afMatrix[4];
                rkColumn[2] = m_afMatrix[8];
                rkColumn[3] = m_afMatrix[12];
                break;
        case 1:
                rkColumn[0] = m_afMatrix[1];
                rkColumn[1] = m_afMatrix[5];
                rkColumn[2] = m_afMatrix[9];
                rkColumn[3] = m_afMatrix[13];
                break;
        case 2:
                rkColumn[0] = m_afMatrix[2];
                rkColumn[1] = m_afMatrix[6];
                rkColumn[2] = m_afMatrix[10];
                rkColumn[3] = m_afMatrix[14];
                break;
        case 3:
                rkColumn[0] = m_afMatrix[3];
                rkColumn[1] = m_afMatrix[7];
                rkColumn[2] = m_afMatrix[11];
                rkColumn[3] = m_afMatrix[15];
                break;
        }
}



// Assignment
K3dMatrix& K3dMatrix::operator= (const K3dMatrix& rkM)
{
        for(int i=0; i<16; i++)
        {
                m_afMatrix[i] = rkM.m_afMatrix[i];
        }
        return *this;
}



// Compare arrays for comparison operators
int K3dMatrix::CompareArrays(K3dMatrix& rkV)
{
        unsigned int uiTest0;
        unsigned int uiTest1;

        for (int i = 0; i < 16; i++)
        {
                uiTest0 = *(unsigned int*)&m_afMatrix[i];
                uiTest1 = *(unsigned int*)&rkV.m_afMatrix[i];
                if ( uiTest0 < uiTest1 )
                        return -1;
                if ( uiTest0 > uiTest1 )
                        return +1;
        }
        return 0;

}



K3dMatrix K3dMatrix::operator+ (K3dMatrix& rkM)
{
        K3dMatrix kSum;
        for (int i = 0; i < 16; i++)
                kSum.m_afMatrix[i] = m_afMatrix[i] + rkM.m_afMatrix[i];
        return kSum;
}



K3dMatrix K3dMatrix::operator- (K3dMatrix& rkM)
{
        K3dMatrix kSum;
        for (int i = 0; i < 16; i++)
                kSum.m_afMatrix[i] = m_afMatrix[i] - rkM.m_afMatrix[i];
        return kSum;
}



K3dMatrix K3dMatrix::operator* (float fScalar)
{
        K3dMatrix kM;
        for (int i = 0; i < 16; i++)
                kM.m_afMatrix[i] = m_afMatrix[i] * fScalar;

        return kM;
}



K3dMatrix K3dMatrix::operator- ()
{
        K3dMatrix kNeg;
        for (int i = 0; i < 16; i++)
                kNeg.m_afMatrix[i] = -m_afMatrix[i];
        return kNeg;
}



K3dMatrix& K3dMatrix::operator+= ( K3dMatrix& rkM)
{
        for (int i=0; i<16; i++)                                        
        {
                this->m_afMatrix[i] += rkM.m_afMatrix[i]; 
        }

        return *this;
}



K3dMatrix& K3dMatrix::operator-= ( K3dMatrix& rkM)
{
        for (int i=0; i<16; i++)                                        
        {
                this->m_afMatrix[i] -= rkM.m_afMatrix[i]; 
        }

        return *this;
}



K3dMatrix& K3dMatrix::operator*= (float fScalar)
{
        for (int i=0; i<16; i++)                                        
        {
                this->m_afMatrix[i] *= fScalar; 
        }

        return *this;
}



K3dMatrix& K3dMatrix::operator/= (float fScalar)
{
        float fInvScalar;

        if(fScalar)
        {
                fInvScalar = 1.0f / fScalar;
                for (int i=0; i<3; i++)                                 
                {
                        m_afMatrix[i] *= fInvScalar;    
                }
        }
        else
        {
                this->LoadIdentity();
        }


        return *this;
}



// Multiply row by scalar
void K3dMatrix::MultiplyRow(const float fScalar, const int iRow)
{
        int i;

        if(!(0 <= iRow) && (iRow < 4) ) 
        {
                cerr << "Error - K3dMatrix::SetColumn() -- error index -" << iRow << endl;
        }

        switch (iRow)
        {
        case 0:
                for(i=0; i<=3; i++)
                {
                        m_afMatrix[i] *= fScalar;
                }
                break;
        case 1:
                for(i=4; i<=7; i++)
                {
                        m_afMatrix[i] *= fScalar;
                }
                break;
        case 2:
                for(i=8; i<=11; i++)
                {
                        m_afMatrix[i] *= fScalar;
                }
                break;
        case 3:
                for(i=12; i<=15; i++)
                {
                        m_afMatrix[i] *= fScalar;
                }
                break;
        }

}



// Multiply column by scalar
void K3dMatrix::MultiplyColumn(const float fScalar, const int iColumn)
{
        if(!(0 <= iColumn) && (iColumn < 4) )
        {
                cerr << "Error - K3dMatrix::MultiplyColumn() -- error index" << iColumn << endl;
        }

        switch (iColumn)
        {
        case 0:
                m_afMatrix[0] *= fScalar;
                m_afMatrix[4] *= fScalar;
                m_afMatrix[8] *= fScalar;
                m_afMatrix[12] *= fScalar;
                break;
        case 1:
                m_afMatrix[1] *= fScalar;
                m_afMatrix[5] *= fScalar;
                m_afMatrix[9] *= fScalar;
                m_afMatrix[13] *= fScalar;
                break;
        case 2:
                m_afMatrix[2] *= fScalar;
                m_afMatrix[6] *= fScalar;
                m_afMatrix[10] *= fScalar;
                m_afMatrix[14] *= fScalar;
                break;
        case 3:
                m_afMatrix[3] *= fScalar;
                m_afMatrix[7] *= fScalar;
                m_afMatrix[11] *= fScalar;
                m_afMatrix[15] *= fScalar;
                break;
        }       
}

---