Matrix44.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "Matrix44.h"
using namespace OpenCAL::Utils;

#include <math.h>

using namespace std;


// Static members
const Matrix44 Matrix44::zero(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
const Matrix44 Matrix44::unity;


/******************************
* Constructors and destructor *
******************************/

Matrix44::Matrix44()
{
    identity();
}

Matrix44::Matrix44(const Matrix44 &source)
{
    memcpy(m_values, source.m_values, 16 * sizeof(float));
}

Matrix44::Matrix44(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
    m_values[0]  = m11; m_values[1]  = m12; m_values[2]  = m13; m_values[3]  = m14;
    m_values[4]  = m21; m_values[5]  = m22; m_values[6]  = m23; m_values[7]  = m24;
    m_values[8]  = m31; m_values[9]  = m32; m_values[10] = m33; m_values[11] = m34;
    m_values[12] = m41; m_values[13] = m42; m_values[14] = m43; m_values[15] = m44;
}

Matrix44::~Matrix44()
{
}


/************************
* Get and set functions *
************************/

void Matrix44::set(float *values)
{
    memcpy(m_values, values, 16 * sizeof(float));
}

/*********************
* Operator functions *
*********************/

void Matrix44::operator=(const Matrix44 &m)
{
    memcpy(m_values, m.m_values, 16 * sizeof(float));
}

Matrix44 Matrix44::operator*(const Matrix44 &m) const
{
    Matrix44 result;

    for(int i = 0; i < 4; i++)
    for(int j = 0; j < 4; j++)
        result.m_values[i * 4 + j] = m_values[i * 4] * m.m_values[j] +
        m_values[i * 4 + 1] * m.m_values[4 + j] +
        m_values[i * 4 + 2] * m.m_values[8 + j] +
        m_values[i * 4 + 3] * m.m_values[12 + j];

    return result;
}

Matrix44 Matrix44::operator*(float factor) const
{
    Matrix44 result;

    for(int i = 0; i < 16; i++)
        result.m_values[i] = m_values[i] * factor;

    return result;
}

Vector3 Matrix44::operator*(const Vector3 &v) const
{
    Vector3 result;

    result.setX(m_values[0] * v.getX() + m_values[1] * v.getY() + m_values[2] * v.getZ() + m_values[3]);
    result.setY(m_values[4] * v.getX() + m_values[5] * v.getY() + m_values[6] * v.getZ() + m_values[7]);
    result.setZ(m_values[8] * v.getX() + m_values[9] * v.getY() + m_values[10] * v.getZ() + m_values[11]);

    return result;
}

Matrix44 Matrix44::operator+(const Matrix44 &m) const
{
    Matrix44 result;

    for(int i = 0; i < 16; i++)
        result.m_values[i] = m_values[i] + m.m_values[i];

    return result;
}

Matrix44 Matrix44::operator-() const
{
    Matrix44 result;

    for(int i = 0; i < 16; i++)
        result.m_values[i] = -m_values[i];

    return result;
}

bool Matrix44::operator==(const Matrix44 &m) const
{
    for(int i = 0; i < 16; i++)
        if(m_values[i] != m.m_values[i])
            return false;

    return true;
}


// Friend functions
Matrix44 OpenCAL::Utils::operator*(float factor, const Matrix44 &m)
{
    Matrix44 result;

    for(int i = 0; i < 16; i++)
        result.m_values[i] = m.m_values[i] * factor;

    return result;
}


/**********************
* Transform functions *
**********************/

void Matrix44::translate(const Vector3 &translation)
{
/*
    float x = translation.getX();
    float y = translation.getY();
    float z = translation.getZ();

    m_values[12] += x * m_values[0] + y * m_values[4] + z * m_values[8];
    m_values[13] += x * m_values[1] + y * m_values[5] + z * m_values[9];
    m_values[14] += x * m_values[2] + y * m_values[6] + z * m_values[10];
*/

    m_values[12] += translation.getX();
    m_values[13] += translation.getY();
    m_values[14] += translation.getZ();
}

void Matrix44::rotateX(float angle)
{
    float rad = Math::degToRad(angle);
    float cosinus = cosf(rad);
    float sinus = sinf(rad);

    float m4 = m_values[4];
    float m5 = m_values[5];
    float m6 = m_values[6];
    float m7 = m_values[7];

    m_values[4] = cosinus * m4 + sinus * m_values[8];
    m_values[5] = cosinus * m5 + sinus * m_values[9];
    m_values[6] = cosinus * m6 + sinus * m_values[10];
    m_values[7] = cosinus * m7 + sinus * m_values[11];

    m_values[8] = cosinus * m_values[8] - sinus * m4;
    m_values[9] = cosinus * m_values[9] - sinus * m5;
    m_values[10] = cosinus * m_values[10] - sinus * m6;
    m_values[11] = cosinus * m_values[11] - sinus * m7;
}

void Matrix44::rotateY(float angle)
{
    float rad = Math::degToRad(angle);
    float cosinus = cosf(rad);
    float sinus = sinf(rad);

    float m0 = m_values[0];
    float m1 = m_values[1];
    float m2 = m_values[2];
    float m3 = m_values[3];

    m_values[0] = cosinus * m0 - sinus * m_values[8];
    m_values[1] = cosinus * m1 - sinus * m_values[9];
    m_values[2] = cosinus * m2 - sinus * m_values[10];
    m_values[3] = cosinus * m3 - sinus * m_values[11];

    m_values[8] = cosinus * m_values[8] + sinus * m0;
    m_values[9] = cosinus * m_values[9] + sinus * m1;
    m_values[10] = cosinus * m_values[10] + sinus * m2;
    m_values[11] = cosinus * m_values[11] + sinus * m3;
}

void Matrix44::rotateZ(float angle)
{
    float rad = Math::degToRad(angle);
    float cosinus = cosf(rad);
    float sinus = sinf(rad);

    float m0 = m_values[0];
    float m1 = m_values[1];
    float m2 = m_values[2];
    float m3 = m_values[3];

    m_values[0] = cosinus * m0 + sinus * m_values[4];
    m_values[1] = cosinus * m1 + sinus * m_values[5];
    m_values[2] = cosinus * m2 + sinus * m_values[6];
    m_values[3] = cosinus * m3 + sinus * m_values[7];

    m_values[4] = cosinus * m_values[4] - sinus * m0;
    m_values[5] = cosinus * m_values[5] - sinus * m1;
    m_values[6] = cosinus * m_values[6] - sinus * m2;
    m_values[7] = cosinus * m_values[7] - sinus * m3;
}


/******************
* Other functions *
******************/

void Matrix44::identity()
{
    // We don't need to zero out the last value, because it will be 1 later (one tiny bit faster :-D)
    memset(m_values, 0, 15 * sizeof(float));

    // Set the diagonal values to 1
    m_values[0] = m_values[5] = m_values[10] = m_values[15] = 1.0f;
}

/*
void Matrix44::zero()
{
    memset(m_values, 0, 16 * sizeof(float));
}
*/

void Matrix44::transpose()
{
    *this = transposed();
}

Matrix44 Matrix44::transposed()
{
    Matrix44 result;

    for(int i = 0; i < 4; i++)
    for(int j = 0; j < 4; j++)
        result.m_values[i * 4 + j] = m_values[j * 4 + i];

    return result;
}

void Matrix44::fill(float value)
{
    for(int i = 0; i < 16; ++i)
        m_values[i] = value;
}

void Matrix44::print()
{
    for(int i = 0; i < 16; i++)
    {
        cout << m_values[i] << " ";
        if((i + 1) % 4 == 0)
            cout << endl;
    }
    cout << endl;
}

---