Matrix16.cpp

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//    Scorched3D (c) 2000-2009
//
//    This file is part of Scorched3D.
//
//    Scorched3D 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.
//
//    Scorched3D 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 Scorched3D; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
////////////////////////////////////////////////////////////////////////////////

#include <common/Matrix16.h>

static float IDENTITY_MATRIX[16] = 
{
   1.0, 0.0, 0.0, 0.0,
   0.0, 1.0, 0.0, 0.0,
   0.0, 0.0, 1.0, 0.0,
   0.0, 0.0, 0.0, 1.0
};

Matrix16::Matrix16(float *init)
{
        if (!init) init = IDENTITY_MATRIX;
        for (int i=0; i<16; i++) M[i] = init[i];
}

Matrix16::~Matrix16()
{
}

void Matrix16::identity()
{
        for (int i=0; i<16; i++) M[i] = IDENTITY_MATRIX[i];
}

#define A(row,col)  a[(col<<2)+row]
#define B(row,col)  b[(col<<2)+row]
#define P(row,col)  product[(col<<2)+row]

void Matrix16::multiply(float *b)
{
        static float product[16];
        float *a = M;

        int i;
        for (i = 0; i < 4; i++) 
        {
                const float ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
                P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0) + ai3 * B(3,0);
                P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1) + ai3 * B(3,1);
                P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2) + ai3 * B(3,2);
                P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3 * B(3,3);
        }

        for (int i=0; i<16; i++) M[i] = product[i];
}

void Matrix16::scale(float x, float y, float z)
{
        float *m = M;
        m[0] *= x;   m[4] *= y;   m[8]  *= z;
        m[1] *= x;   m[5] *= y;   m[9]  *= z;
        m[2] *= x;   m[6] *= y;   m[10] *= z;
        m[3] *= x;   m[7] *= y;   m[11] *= z;
}

void Matrix16::translate(float x, float y, float z)
{
        float *m = M;
        m[12] = m[0] * x + m[4] * y + m[8]  * z + m[12];
        m[13] = m[1] * x + m[5] * y + m[9]  * z + m[13];
        m[14] = m[2] * x + m[6] * y + m[10] * z + m[14];
        m[15] = m[3] * x + m[7] * y + m[11] * z + m[15];
}

---