Matrix33.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 "Matrix33.h"
#include <OpenCAL/Vector3.h>
using namespace OpenCAL::Utils;

#include <math.h>

using namespace std;


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


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

Matrix33::Matrix33()
{
    identity();
}

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

Matrix33::Matrix33(float m11, float m12, float m13, float m21, float m22, float m23, float m31, float m32, float m33)
{
    m_values[0]  = m11; m_values[1]  = m12; m_values[2]  = m13;
    m_values[3]  = m21; m_values[4]  = m22; m_values[5]  = m23;
    m_values[6]  = m31; m_values[7]  = m32; m_values[8]  = m33;
}

Matrix33::~Matrix33()
{
}


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

void Matrix33::set(float *values)
{
    memcpy(m_values, values, 9 * sizeof(float));
}

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

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

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

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

    return result;
}

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

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

    return result;
}

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

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

    return result;
}

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

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

    return result;
}

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

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

    return result;
}

void Matrix33::operator*=(float factor)
{
    for(int i = 0; i < 9; ++i)
        m_values[i] *= factor;
}

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

    return true;
}


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

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

    return result;
}

Matrix33 OpenCAL::Utils::operator/(float factor, const Matrix33 &m)
{
    Matrix33 result;

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

    return result;
}


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

void Matrix33::rotateX(float angle)
{
/*
    float rad = angle * DEGTORAD;
    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 Matrix33::rotateY(float angle)
{
/*
    float rad = angle * DEGTORAD;
    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 Matrix33::rotateZ(float angle)
{
/*
    float rad = angle * DEGTORAD;
    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 Matrix33::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, 8 * sizeof(float));

    // Set the diagonal values to 1
    m_values[0] = m_values[4] = m_values[8] = 1.0f;
}

void Matrix33::clear()
{
    memset(m_values, 0, 9 * sizeof(float));
}

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

Matrix33 Matrix33::transposed()
{
    Matrix33 result;

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

    return result;
}

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

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

---