Geo.h

Go to the documentation of this file.

//Luke Lenhart, 2007
//See /docs/License.txt for details on how this code may be used.

//all angles are in radians

#ifndef GEO_H_INCLUDED
#define GEO_H_INCLUDED

#include "../base/Setup.h"

#ifdef MPMA_COMPILE_GEO

#include <cmath>
#include <string>

#include "../base/Types.h"
#include "GeoBases.h"

namespace GEO
{
    // -- global constants

    extern const float PI2; 
    extern const float PI; 
    extern const float FLOAT_TOLERANCE; 


    // -- vector definitions

    struct Vector4: public VectorN<4>
    {
        //ctors
        inline Vector4() {} 
        inline Vector4(float x, float y, float z, float w) {elements[0]=x; elements[1]=y; elements[2]=z; elements[3]=w;} 
        inline Vector4(const float *array): VectorN<4>(array) {} 
        inline Vector4(float c): VectorN<4>(c) {} 
        inline Vector4(int c): VectorN<4>((float)c) {} 
        inline Vector4(const Vector4 &o): VectorN<4>((const float*)&o) {} 
        inline Vector4(const VectorN<4> &o): VectorN<4>((const float*)&o) {} 
        inline Vector4(const struct Vector3 &o, float w=1); 

        //other accessors
        inline float x() const { return elements[0]; } 
        inline float& x() { return elements[0]; } 
        inline float y() const { return elements[1]; } 
        inline float& y() { return elements[1]; } 
        inline float z() const { return elements[2]; } 
        inline float& z() { return elements[2]; } 
        inline float w() const { return elements[3]; } 
        inline float& w() { return elements[3]; } 
    };


    struct Vector3: public VectorN<3>
    {
        //ctors
        inline Vector3() {} 
        inline Vector3(float x, float y, float z) {elements[0]=x; elements[1]=y; elements[2]=z;} 
        inline Vector3(const float *array): VectorN<3>(array) {} 
        inline Vector3(float c): VectorN<3>(c) {} 
        inline Vector3(int c): VectorN<3>((float)c) {} 
        inline Vector3(const Vector3 &o): VectorN<3>((const float*)&o) {} 
        inline Vector3(const VectorN<3> &o): VectorN<3>((const float*)&o) {} 
        explicit inline Vector3(const Vector4 &o); 
        inline Vector3(const struct Vector2 &o, float z=1);

        //other accessors
        inline float x() const { return elements[0]; } 
        inline float& x() { return elements[0]; } 
        inline float y() const { return elements[1]; } 
        inline float& y() { return elements[1]; } 
        inline float z() const { return elements[2]; } 
        inline float& z() { return elements[2]; } 
    };

    struct Vector2: public VectorN<2>
    {
        //ctors
        inline Vector2() {} 
        inline Vector2(float x, float y) {elements[0]=x; elements[1]=y;} 
        inline Vector2(const float *array): VectorN<2>(array) {} 
        inline Vector2(float c): VectorN<2>(c) {} 
        inline Vector2(int c): VectorN<2>((float)c) {} 
        inline Vector2(const Vector2 &o): VectorN<2>((const float*)&o) {} 
        inline Vector2(const VectorN<2> &o): VectorN<2>((const float*)&o) {} 
        explicit inline Vector2(const Vector3 &o); 

        //other accessors
        inline float x() const { return elements[0]; } 
        inline float& x() { return elements[0]; } 
        inline float y() const { return elements[1]; } 
        inline float& y() { return elements[1]; } 
    };

    struct Vector1: public VectorN<1>
    {
        //ctors
        inline Vector1() {} 
        inline Vector1(float x) {elements[0]=x;} 
        inline Vector1(const float *array): VectorN<1>(array) {} 
        inline Vector1(int c): VectorN<1>((float)c) {} 
        inline Vector1(const Vector1 &o): VectorN<1>(o.x()) {} 
        inline Vector1(const VectorN<1> &o): VectorN<1>(o.elements[0]) {} 
        explicit inline Vector1(const Vector3 &o); 

        //other accessors
        inline float x() const { return elements[0]; } 
        inline float& x() { return elements[0]; } 
    };

    // -- square matrix definitions

    struct Matrix4: public MatrixN<4>
    {
        //useful ctors
        inline Matrix4() {} 
        inline Matrix4(const float *array): MatrixN<4>(array) {} 
        inline Matrix4(float e0,float e1,float e2,float e3,float e4,float e5,float e6,float e7,float e8,float e9,float e10,float e11,float e12,float e13,float e14,float e15); 
        inline Matrix4(float c): MatrixN<4>(c) {} 
        inline Matrix4(int c): MatrixN<4>((float)c) {} 
        inline Matrix4(const Matrix4 &o): MatrixN<4>((const float*)&o) {} 
        inline Matrix4(const MatrixN<4> &o): MatrixN<4>((const float*)&o) {} 
        inline Matrix4(const struct Matrix3 &o); 

        inline const float* ToGL() const;
    private:
        static Matrix4 globalGLConversionMatrix;
    };

    struct Matrix3: public MatrixN<3>
    {
        //useful ctors
        inline Matrix3() {} 
        inline Matrix3(const float *array): MatrixN<3>(array) {} 
        inline Matrix3(float e0,float e1,float e2,float e3,float e4,float e5,float e6,float e7,float e8); 
        inline Matrix3(float c): MatrixN<3>(c) {} 
        inline Matrix3(int c): MatrixN<3>((float)c) {} 
        inline Matrix3(const Matrix3 &o): MatrixN<3>((const float*)&o) {} 
        inline Matrix3(const MatrixN<3> &o): MatrixN<3>((const float*)&o) {} 
        explicit inline Matrix3(const struct Matrix4 &o); 
        inline Matrix3(const struct Matrix2 &o); 
    };

    struct Matrix2: public MatrixN<2>
    {
        //useful ctors
        inline Matrix2() {} 
        inline Matrix2(const float *array): MatrixN<2>(array) {} 
        inline Matrix2(float e0,float e1,float e2,float e3); 
        inline Matrix2(float c): MatrixN<2>(c) {} 
        inline Matrix2(int c): MatrixN<2>((float)c) {} 
        inline Matrix2(const Matrix2 &o): MatrixN<2>((const float*)&o) {} 
        inline Matrix2(const MatrixN<2> &o): MatrixN<2>((const float*)&o) {} 
        explicit inline Matrix2(const Matrix3 &o); 
    };


    // -- quaternion definition

    //TODO


    // -- generic utilities

    inline bool NearEqual(float c0, float c1, float tolerance=FLOAT_TOLERANCE); 
    template <typename VecType>
    inline bool NearEqual(const VecType& v1, const VecType& v2, float tolerance=FLOAT_TOLERANCE); 
    template <typename VecType>
    inline bool NearEqual(const VecType& v, float c, float tolerance=FLOAT_TOLERANCE); 

    inline bool IsFinite(float c); 
    template <typename VecType>
    inline bool IsFinite(VecType &v); 

    template <typename VecType>
    inline VecType Clamp(const VecType &val, const VecType &min, const VecType &max); 
    template <>
    inline float Clamp(const float &val, const float &min, const float &max); 

    // -- Vector functions

    template <typename VecType1, typename VecType2>
    inline float VecDot(const VecType1 &v1, const VecType2 &v2); 

    inline struct Vector3 VecCross(const struct Vector3 &v1, const struct Vector3 &v2); 

    template <typename VecType>
    inline VecType VecNormal(const VecType &v); 
    template <typename VecType>
    inline void VecNormalize(VecType &v); 

    template <typename VecType1, typename VecType2>
    inline float VecAngleBetween(const VecType1 &l1, const VecType2 &l2); 

    template <typename VecType1, typename VecType2>
    inline float VecDistance(const VecType1 &l1, const VecType2 &l2); 

    template <typename VecType>
    inline float VecLength(const VecType &v); //<!length of a vector
    template <typename VecType>
    inline float VecLengthSquared(const VecType &v); //<!squared length of a vector

    template <typename VecType1, typename VecType2>
    inline VecType1 VecReflect(const VecType1 &vec, const VecType2 &norm); 


    // -- Matrix functions

    template <typename MatType>
    MatType MatMul(const MatType &m1, const MatType &m2); 

    float MatDeterminant(const Matrix4 &mat); 
    float MatDeterminant(const Matrix3 &mat); 
    inline float MatDeterminant(const Matrix2 &mat); 

    template <typename MatType>
    MatType MatTranspose(const MatType &mat); 

    template <typename MatType>
    MatType MatInverse(const MatType &mat); 

    inline Matrix3 MatRotateX(float angle); 
    inline Matrix3 MatRotateY(float angle); 
    inline Matrix3 MatRotateZ(float angle); 
    inline Matrix3 MatRotateAxis(const Vector3 &axis, float angle); 

    template <typename VecType>
    inline typename VecType::GreaterMatrixType MatTranslate(const VecType &offset); 

    template <typename VecType>
    inline typename VecType::GreaterMatrixType MatScale(const VecType &scale); 

    Matrix4 MatProjectionFoV(float fov=PI/2, float aspectYdivX=1.0f, float nearZ=1.0f, float farZ=1000.0f); 

    Matrix4 MatProjectionOrtho(float left, float right, float bottom, float top, float nearZ=1.0f, float farZ=1000.0f); 
    inline Matrix4 MatProjectionOrtho(float nearZ=1.0f, float farZ=1000.0f); 

    Matrix4 MatViewLookAt(const Vector3 &pos, const Vector3 &tar, const Vector3 &vagueUp=Vector3(0,0,1), bool flipVert=false, bool flipHorz=false); 


    // -- Mixed functions

    template <typename VecType>
    inline VecType TransformVector(const typename VecType::MatrixType &m, const VecType &v); 

}; //namespace GEO

//include template and inline implementations
#ifndef GEO_INCLUDE_INLINE
    #define GEO_INCLUDE_INLINE
    #include "Geo.cpp"
#endif

#endif //#ifdef MPMA_COMPILE_GEO

#endif // GEO_H_INCLUDED