---

Matrix4.h

/*
  File: Matrix4.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef MATRIX4_H
#define MATRIX4_H

#include<Vertex3.h>
#include<Vertex4.h>

#include<real.h>
#include<iostream.h>

class Matrix3;
class ObjectFile;

// Matrix representation is transposed
#define INDEX4(r, c) (c*4 + r)

class Matrix4
{
    friend ostream &operator<<(ostream &stream, Matrix4 &m);
    friend ObjectFile &operator>>(ObjectFile &f, Matrix4 &m);
private:
    class MatrixRow {
    public:
        MatrixRow(real *d, unsigned int r) : m(d), row(r) {}
        real &operator [](unsigned int col) {
            m[INDEX4(row, col)];
        }
    private:
        unsigned int row;
        real *m;
    };
public:
    // Constructors
    Matrix4() {};
    Matrix4(const Matrix4 &m) {
        memcpy(this, &m, sizeof(Matrix4));
    }
    void identity();
    void transpose();
    bool inverse();
    void perspective(float fovy, float aspect, float zNear, float zFar);
    Matrix4 &setXAxis(Vertex3 &x);
    Matrix4 &setYAxis(Vertex3 &y);
    Matrix4 &setZAxis(Vertex3 &z);
    Matrix4 &setOrigin(Vertex3 &o);

    // Get
    MatrixRow operator [](unsigned int row) {
        MatrixRow r(m, row);
        return r;
    }
    const real *data() const { return m; }

    // Assignment operators
    Matrix4 &operator =(const Matrix4 &right) {
        memcpy(this, &right, sizeof(Matrix4));
        return *this;
    }
    Matrix4 &operator =(const Matrix3 &right);
    void operator *=(const Matrix4 &right);

    // Operators
    Matrix4 operator *(const Matrix4 &right) const;
    Matrix3 operator *(const Matrix3 &right) const;
    Vertex3 operator *(const Vertex3 &v) const;
    Vertex4 operator *(const Vertex4 &v) const;
    Matrix4 operator ~() const {
        Matrix4 m(*this);
        m.transpose();
        return m;
    }

    real det() const;
    real lipschitz() const;

    // 3D Transfomations, righthanded
    Vertex3 apply(const Vertex3 &v) const {
        return *this * v;
    }
    Vertex4 apply(const Vertex4 &v) const {
        return *this * v;
    }
    Vertex3 applyHomogenous(const Vertex3 &v) const;
    Vertex3 applyM3(const Vertex3 &v) const;
    void scale(real x, real y, real z);
    void scale(Vertex3 v) { scale(v.x, v.y, v.z); }
    void translate(real x, real y, real z);
    void translateSimple(real x, real y, real z);
    void translate(Vertex3 v) { translate(v.x, v.y, v.z); }

    // calculates: this = rotate(alpha) * this;
    void rotate(Vertex3 &v);
    void rotateX(real alpha);
    void rotateY(real alpha);
    void rotateZ(real alpha);

private:
    real m[4*4];
};
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.