---

matrix.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "matrix.h"

#ifndef PI
#define PI 3.141529
#endif


#define EPSILON 0.000001

Matrix4x4::Matrix4x4() {
        
        for(int i = 0; i < 4; i++) {
                for(int j=0;j < 4; j++) {
                        mat[i][j] = 0.0;
                }
        }
}

Matrix4x4::Matrix4x4(Matrix4x4 *matrix) {
        for(int i =0;i <4;i++)
                for(int j=0;j <4; j++)
                        mat[i][j] = matrix->mat[i][j];
}

Matrix4x4::Matrix4x4(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) {
        
        mat[0][0] = m11;
        mat[0][1] = m21;
        mat[0][2] = m31;
        mat[0][3] = m41;
        mat[1][0] = m12;
        mat[1][1] = m22;
        mat[1][2] = m32;
        mat[1][3] = m42;
        mat[2][0] = m13;
        mat[2][1] = m23;
        mat[2][2] = m33;
        mat[2][3] = m43;
        mat[3][0] = m14;
        mat[3][1] = m24;
        mat[3][2] = m34;
        mat[3][3] = m44;

}

void
Matrix4x4::identity() {
        for(int i =0; i < 4; i++)
                for(int j= 0;j < 4; j++)
                        mat[i][j] = 0.0;
        mat[0][0] = 1.0;
        mat[1][1] = 1.0;
        mat[2][2] = 1.0;
        mat[3][3] = 1.0;
}

const VECTOR
Matrix4x4::operator * (const VECTOR& vec) const {
        VECTOR result;
        result.x = mat[0][0]*vec.x + mat[1][0]*vec.y + mat[2][0] * vec.z + mat[3][0];
        result.y = mat[0][1]*vec.x + mat[1][1]*vec.y + mat[2][1] * vec.z + mat[3][1];
        result.z = mat[0][2]*vec.x + mat[1][2]*vec.y + mat[2][2] * vec.z + mat[3][2];
        return result;
}

void
Matrix4x4::transpose() {
        float tmp;
        for(int i = 0; i < 4; i++) {
                for(int j = 0; j < 4; j++) {
                        tmp = mat[i][j];
                        mat[i][j] = mat[j][i];
                        mat[j][i] = tmp;
                }
        }
}

Matrix4x4
Matrix4x4::mul(Matrix4x4 m){
        Matrix4x4 *ret = new Matrix4x4();
        for(int i = 0;i < 4; i++) {
                for(int j = 0;j < 4;j++) {
                        for(int k = 0; k< 4; k++) {
                                ret->mat[i][j] = ret->mat[i][j]+mat[k][j]*m.mat[i][k];
                        }
                }
        }
        return *ret;
}

void
Matrix4x4::translate(VECTOR a) {
        for(int i = 0;i < 4;i++) {
                for(int j = 0; j <4;j++) {
                        mat[i][j] = 0.0;
                }
        }
        for(int j = 0;j <4; j++) {
                mat[j][j] = 1.0;
        }
        mat[3][0] = a.x;
        mat[3][1] = a.y;
        mat[3][2] = a.z;
}
/*
 * A function for creating a rotation matrix that rotates a vector called
 * "from" into another vector called "to".
 * Authors: Tomas Möller, John Hughes 1999
 */

void
Matrix4x4::rotation(VECTOR from, VECTOR to) {
        VECTOR v;
        float e, h, f;
        
        v = from.cross(to);
        e = from.dot(to);
        f = (e < 0)? -e:e;
        if (f > 1.0 - EPSILON) {
                VECTOR x;

                x.x = (from.x > 0.0) ? from.x : -from.x;
                x.y = (from.y > 0.0) ? from.y : -from.y;
                x.z = (from.z > 0.0) ? from.z : -from.z;

                if(x.x < x.y) {
                        if(x.x < x.z) {
                                x.x = 1.0;
                                x.y = x.z = 0.0;
                        } else {
                                x.z = 1.0; x.x = x.y = 0.0;
                        }
                }
                else {
                        if(x.y < x.z) {
                                x.y = 1.0; x.x = x.z = 0.0;
                        } else {
                                x.z = 1.0; x.x = x.y = 0.0;
                        }
                }

                VECTOR u = x - from;
                VECTOR w = x - to;

                float c1 = 2.0 / u.dot(u);
                float c2 = 2.0 / w.dot(w);
                float c3 = c1 * c2 * u.dot(w);

                float u_h[3];
                float w_h[3];

                u_h[0] = u.x;
                u_h[1] = u.y;
                u_h[2] = u.z;

                w_h[0] = w.x;
                w_h[1] = w.y;
                w_h[2] = w.z;


                for(int i = 0; i < 3; i++) {
                        for(int j = 0; j < 3; j++) {
                                mat[i][j] = -c1 * u_h[i] * u_h[j] - c2 * w_h[i]*w_h[j] + c3 * w_h[i] * u_h[j];
                        }
                        mat[i][i] += 1.0;
                }
        }
        else
        {
                h = (1.0 - e)/(v.dot(v));
    
                mat[0][0] = e + h*v.x * v.x; 
                mat[0][1] = h*v.x*v.y - v.z;     
                mat[0][2] = h*v.x*v.z + v.y;
                mat[0][3] = 0.0f;

                mat[1][0] = h*v.x*v.y + v.z;  
                mat[1][1] = e + h * v.y * v.y; 
                mat[1][2] = h*v.y*v.z - v.x;
                mat[1][3] = 0.0f;

                mat[2][0] = h*v.x*v.z - v.y;  
                mat[2][1] = h*v.y*v.z + v.x;     
                mat[2][2] = e + h*v.z * v.z;
                mat[2][3] = 0.0f;

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

void
Matrix4x4::rotateX(float alpha) {
        double rad = alpha / 180 * PI;
        float cosa = cos(rad);
        float sina;// = sin(PI);

        sina = sqrt((1 - cosa * cosa));

        mat[0][0] = 1.0f;
        mat[0][1] = 0.0f;
        mat[0][2] = 0.0f;
        mat[0][3] = 0.0f;

        mat[1][0] = 0.0f;
        mat[1][1] = cosa;
        mat[1][2] = sina;
        mat[1][3] = 0.0f;

        mat[2][0] = 1.0f;
        mat[2][1] = -sina;
        mat[2][2] = cosa;
        mat[2][3] = 0.0f;

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

void
Matrix4x4::rotateY(float alpha) {
        double rad = alpha / 180 * PI;
        float cosa = cos(rad);
        float sina;// = sin(PI);

        sina = sqrt((1 - cosa * cosa));

        mat[0][0] = cosa;
        mat[0][1] = 0.0f;
        mat[0][2] = -sina;
        mat[0][3] = 0.0f;

        mat[1][0] = 0.0f;
        mat[1][1] = 1.0f;
        mat[1][2] = 0.0f;
        mat[1][3] = 0.0f;

        mat[2][0] = sina;
        mat[2][1] = 0.0f;
        mat[2][2] = cosa;
        mat[2][3] = 0.0f;

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

void
Matrix4x4::rotateZ(float alpha) {
        double rad = alpha / 180 * PI;
        float cosa = cos(rad);
        float sina;// = sin(PI);

        sina = sqrt((1 - cosa * cosa));

        mat[0][0] = cosa;
        mat[0][1] = sina;
        mat[0][2] = 0.0f;
        mat[0][3] = 0.0f;

        mat[1][0] = -sina;
        mat[1][1] = cosa;
        mat[1][2] = 0.0f;
        mat[1][3] = 0.0f;

        mat[2][0] = 0.0f;
        mat[2][1] = 0.0f;
        mat[2][2] = 1.0f;
        mat[2][3] = 0.0f;

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

---