src/Matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H
#define MATRIX_H

#include <cassert>
#include <iosfwd>

#include "Vec3f.h"
#include "Ray.h"


class Matrix
{
    // friends
    friend Matrix operator*(const Matrix &  m,  const float     f);
    friend Matrix operator*(const float     f,  const Matrix &  m);
    friend Vec3f  operator*(const Matrix &  m,  const Vec3f &   v);
    friend Vec3f  operator*(const Vec3f &   v,  const Matrix &  m);
    friend Ray    operator*(const Matrix &  m,  const Ray &     r);
    friend Ray    operator*(const Ray &     r,  const Matrix &  m);
    friend Matrix operator*(const Matrix &  m1, const Matrix &  m2);
    friend std::ostream & operator<<(std::ostream & o, const Matrix & m);

public:     
    Matrix()
    {
        // initialize by identity matrix
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                if (i != j)
                    mValues[i][j] = 0.0f;
                else
                    mValues[i][j] = 1.0f;
            }
        }
    }

    Matrix(const float f)
    {
        for(int i=0; i<4; i++)
        {
            for(int j=0; j<4; j++)
            {
                mValues[i][j] = f;
            }
        }
    }

    Matrix(const float x, const float y, const float z)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                if (i != j)
                    mValues[i][j] = 0.0f;
            }
        }
        mValues[0][0] = x;
        mValues[1][1] = y;
        mValues[2][2] = z;
        mValues[3][3] = 1.0f;
    }

    Matrix(const Vec3f & t)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                if (i != j)
                    mValues[i][j] = 0.0f;
                else
                    mValues[i][j] = 1.0f;
            }
        }
        mValues[0][3] = t.x();
        mValues[1][3] = t.y();
        mValues[2][3] = t.z();
        mValues[3][3] = 1.0f;
    }

    Matrix(const float angle, const Vec3f & axis)
    {
        const Vec3f a(axis.normal());
        const float c = cosf(angle);
        const float s = sinf(angle);

        mValues[0][0] = a.x()*a.x()*(1.0f - c) + c;
        mValues[0][1] = a.x()*a.y()*(1.0f - c) - a.z()*s;
        mValues[0][2] = a.x()*a.z()*(1.0f - c) + a.y()*s;
        mValues[0][3] = 0.0f;

        mValues[1][0] = a.y()*a.x()*(1.0f - c) + a.z()*s;
        mValues[1][1] = a.y()*a.y()*(1.0f - c) + c;
        mValues[1][2] = a.y()*a.z()*(1.0f - c) - a.x()*s;
        mValues[1][3] = 0.0f;

        mValues[2][0] = a.x()*a.z()*(1.0f - c) - a.y()*s;
        mValues[2][1] = a.y()*a.z()*(1.0f - c) + a.x()*s;
        mValues[2][2] = a.z()*a.z()*(1.0f - c) + c;
        mValues[2][3] = 0.0f;

        mValues[3][0] = 0.0f;
        mValues[3][1] = 0.0f;
        mValues[3][2] = 0.0f;
        mValues[3][3] = 1.0f;
    }

    void set(int x, int y, float value)
    {
        assert(x>=0 && x<4);
        assert(y>=0 && y<4);
        
        mValues[x][y] = value;
    }

    float get(int x, int y) const
    {
        assert(x>=0 && x<4);
        assert(y>=0 && y<4);

        return mValues[x][y];
    }

    inline Matrix & operator*=(const Matrix & m)
    {
        *this = (*this) * m;
        return *this;
    }

    inline Vec3f transformVector(const Vec3f & vector) const
    {
        float result[3];
        for(int i=0; i<3; i++)
        {
            result[i] = 0.0f;
            for(int j=0; j<3; j++)
            {
                result[i] += (mValues[i][j] * vector[j]);
            }
            // 4-th dimension is set to 0
        }
        return Vec3f( result[0], result[1], result[2] );
    }

private:
    float mValues[4][4];  
};


inline Matrix operator*(const Matrix & m, const float f)
{
    Matrix result;
    for(int x=0; x<4; x++)
    {
        for(int y=0; y<4; y++)
        {
            result.mValues[x][y] = m.mValues[x][y] * f;
        }
    }
    return result;
}


inline Matrix operator*(const float f, const Matrix & m)
{
    Matrix result;
    for(int x=0; x<4; x++)
    {
        for(int y=0; y<4; y++)
        {
            result.mValues[x][y] = m.mValues[x][y] * f;
        }
    }
    return result;
}


inline Vec3f operator*(const Matrix & m, const Vec3f & point)
{
    float result[4];
    for(int i=0; i<4; i++)
    {
        result[i] = 0.0f;
        for(int j=0; j<3; j++)
        {
            result[i] += (m.mValues[i][j] * point[j]);
        }
        result[i] += (m.mValues[i][3]);  //emulating v has 4 dimensions with v[3]=1;
    }

    return Vec3f( result[0]/result[3], result[1]/result[3], result[2]/result[3] ); 
}


inline Vec3f operator*(const Vec3f & point, const Matrix & m)
{
    LOG("Multiplying a 3D-point with the matrix should not be used unless you really know what you're doing");
    assert(false);
    float result[4];
    for(int i=0; i<4; i++)
    {
        result[i] = 0.0f;
        for(int j=0; j<3; j++)
        {
            result[i] += (point[i] * m.mValues[i][j]);
        }
        result[i] += m.mValues[i][3];
    }
    return Vec3f( result[0]/result[3], result[1]/result[3], result[2]/result[3] );
}


inline Ray operator*(const Matrix & m, const Ray & r)
{
    Vec3f   org = m * r.org();
    Vec3f   dir = m.transformVector(r.dir());

    // transform t accordingly
    float   t = dir.length() * r.t();

    Ray result;
    result.init(org, dir);
    result.setHit(r.hit(), t);
    result.setObj(r.obj());
    result.setUV(r.u(), r.v()); // barycentric coordinates are invariant under affine transformations
    result.setInfluence(r.influence(), r.recDeep());
    return result;
}


inline Ray operator*(const Ray & /*r*/, const Matrix & /*m*/)
{
    LOG("Left-sided multiplication of Ray and Matrix does not make any sense");
    assert(false);
    return Ray();
}


inline Matrix operator*(const Matrix & m1, const Matrix & m2)
{
    Matrix result;
    for(int i=0; i<4; i++)
    {
        for(int j=0; j<4; j++)
        {
            float f = 0.0f;
            for(int k = 0; k<4; k++)
            {
                f += m1.mValues[i][k] * m2.mValues[k][j];
            }
            result.mValues[i][j] = f;
        }
    }
    return result;
}


std::ostream & operator<<(std::ostream & o, const Matrix & m);


#endif

---