MatrixTypes.h

Go to the documentation of this file.

#pragma once

#include <math.h> // sqrt

#include "Matrix.h"

#ifndef mfloat
#define mfloat double
#endif

typedef SymmetricMatrix<4,mfloat> SymmetricMatrix4x4;
typedef Matrix<4,4,mfloat>        Matrix4x4;
typedef Matrix<3,3,mfloat>        Matrix3x3;

typedef Matrix<4,4,double>        Matrix4x4d;
typedef Matrix<3,3,double>        Matrix3x3d;

typedef ColVector<2,mfloat>       ColVector2;
typedef ColVector<3,mfloat>       ColVector3;
typedef ColVector<4,mfloat>       ColVector4;

typedef ColVector<2,double>       ColVector2d;
typedef ColVector<3,double>       ColVector3d;
typedef ColVector<4,double>       ColVector4d;

// -------------------------------------------------------------------
// RgbColor: embodies a color.
  
template < typename T >
class RgbColor : public ColVector<3, T>
{

    public:
        typedef ColVector< 3, T > parentType;

        RgbColor(parentType &p) { parentType::operator=(p); }
        void operator=(const parentType &p) { parentType::operator=(p); }

        RgbColor() {}
        RgbColor (T r_in, T g_in, T b_in)
        {
            array[0] = r_in;
            array[1] = g_in;
            array[2] = b_in;
        }
        T & r() { return array[0]; }
        T & g() { return array[1]; }
        T & b() { return array[2]; }

        T r() const { return array[0]; }
        T g() const { return array[1]; }
        T b() const { return array[2]; }

};

typedef RgbColor< float > RgbFloat;
typedef RgbColor< double > RgbDouble;
typedef RgbColor< unsigned char > RgbByte;

// -------------------------------------------------------------------
// RgbaColor: embodies a color.
  
template < typename T >
class RgbaColor : public ColVector<4, T>
{

    public:
        typedef ColVector< 4, T > parentType;

        RgbaColor(parentType &p) { parentType::operator=(p); }
        void operator=(const parentType &p) { parentType::operator=(p); }

        RgbaColor() {}
        RgbaColor (T r_in, T g_in, T b_in, T a_in)
        {
            array[0] = r_in;
            array[1] = g_in;
            array[2] = b_in;
            array[3] = a_in;
        }
        T & r() { return array[0]; }
        T & g() { return array[1]; }
        T & b() { return array[2]; }
        T & a() { return array[3]; }

        T r() const { return array[0]; }
        T g() const { return array[1]; }
        T b() const { return array[2]; }
        T a() const { return array[3]; }
};

typedef RgbaColor< float > RgbaFloat;
typedef RgbaColor< double > RgbaDouble;
typedef RgbaColor< unsigned char > RgbaByte;

// -------------------------------------------------------------------
// Vertex: Vertices have a position, but no length. Among other
// things, this class helps with normal calculations.

class Vertex : public Matrix<1,3,double> 
{
    public:
        typedef Matrix<1,3,mfloat> parentType;

        // constructors
        Vertex() {}
        Vertex (mfloat x, mfloat y, mfloat z);
        Vertex(parentType &p) { parentType::operator=(p); }

        // accessors
        bool operator==(const Vertex & v) const;
        ColVector3 getNonUnitLengthNormalWith(const Vertex &v2, const Vertex &v3) const;
        ColVector3 getUnitLengthNormalWith   (const Vertex &v2, const Vertex &v3) const;

        // mutators
        void operator=(const parentType &p) { parentType::operator=(p); }
};

typedef Vertex Vertex3d;



// -------------------------------------------------------------------
//                      inlined methods (Vertex)
// -------------------------------------------------------------------

inline Vertex::Vertex (mfloat x, mfloat y, mfloat z) { array[0] = x; array[1] = y; array[2] = z; }

inline ColVector3 Vertex::getNonUnitLengthNormalWith(const Vertex &v2, const Vertex &v3) const
{
        ColVector3 v21 = v2 - *this;
        ColVector3 v31 = v3 - *this;

        return (v21.crossProduct(v31));
}

inline ColVector3 Vertex::getUnitLengthNormalWith (const Vertex &v2, const Vertex &v3) const
{
    ColVector3 rtn = getNonUnitLengthNormalWith (v2,v3);
    mfloat length = rtn.getLength();
    if (length == 0)
        throw LogicError("Vertex::getUnitLengthNormalWidth(): unable to get a normal vector, since the vector length is zero!");
    return (rtn / rtn.getLength());
}

inline bool Vertex::operator==(const Vertex & v) const
{
    return ((parentType)*this == (parentType)v);
}

---