GeoBases.h

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

//This file is only meant to be included by Geo.h.

#pragma once
#include "../base/Vary.h"

namespace
{
    // -- helpers shared between VectorN and MatrixN
    
    template <typename VecType>
    inline void AssignFromArray(VecType &v, const float *arr)
    {
        for (uint i=0; i<v.ElementCount(); ++i)
            v[i]=arr[i];
    }
    
    template <typename VecType>
    inline void AssignFromValue(VecType &v, float val)
    {
        for (uint i=0; i<v.ElementCount(); ++i)
            v[i]=val;
    }

    template <typename VecType>
    inline VecType Scale(const VecType &v, const float &s)
    {
        VecType r;
        for (uint i=0; i<v.ElementCount(); ++i)
            r[i]=v[i]*s;
        return r;
    }

    template <typename VecType>
    inline VecType Scale(const VecType &v1, const VecType &v2)
    {
        VecType r;
        for (uint i=0; i<v1.ElementCount(); ++i)
            r[i]=v1[i]*v2[i];
        return r;
    }

    template <typename VecType>
    inline VecType Add(const VecType &v1, const VecType &v2)
    {
        VecType r;
        for (uint i=0; i<v1.ElementCount(); ++i)
            r[i]=v1[i]+v2[i];
        return r;
    }

    template <typename VecType>
    inline VecType Sub(const VecType &v1, const VecType &v2)
    {
        VecType r;
        for (uint i=0; i<v1.ElementCount(); ++i)
            r[i]=v1[i]-v2[i];
        return r;
    }

    template <typename VecType>
    inline VecType Neg(const VecType &v)
    {
        VecType r;
        for (uint i=0; i<v.ElementCount(); ++i)
            r[i]=-v[i];
        return r;
    }

    template <typename VecType>
    inline VecType Div(const VecType &v1, const VecType &v2)
    {
        VecType r;
        for (uint i=0; i<v1.ElementCount(); ++i)
            r[i]=v1[i]/v2[i];
        return r;
    }

    template <typename VecType>
    inline void ScaleSelf(VecType &v, const float &s)
    {
        for (uint i=0; i<v.ElementCount(); ++i)
            v[i]*=s;
    }

    template <typename VecType>
    inline void ScaleSelf(VecType &v1, const VecType &v2)
    {
        for (uint i=0; i<v1.ElementCount(); ++i)
            v1[i]*=v2[i];
    }

    template <typename VecType>
    inline void AddSelf(VecType &v1, const VecType &v2)
    {
        for (uint i=0; i<v1.ElementCount(); ++i)
            v1[i]+=v2[i];
    }

    template <typename VecType>
    inline void SubSelf(VecType &v1, const VecType &v2)
    {
        for (uint i=0; i<v1.ElementCount(); ++i)
            v1[i]-=v2[i];
    }

    template <typename VecType>
    inline void NegSelf(VecType &v)
    {
        for (uint i=0; i<v.ElementCount(); ++i)
            v[i]=-v[i];
    }

    template <typename VecType>
    inline void DivSelf(VecType &v1, const VecType &v2)
    {
        for (uint i=0; i<v1.ElementCount(); ++i)
            v1[i]/=v2[i];
    }
}

namespace GEO
{
    template <uint elemCount> struct MatrixN; //predef

    
    // -- VectorN
    
    template <uint elemCount>
    struct VectorN
    {
        typedef MatrixN<elemCount> MatrixType; 
        typedef MatrixN<elemCount+1> GreaterMatrixType; 
        
        float elements[elemCount]; 
        inline uint ElementCount() const { return elemCount; } 
        
        //ctors
        inline VectorN() {} 
        inline VectorN(const float *array) { AssignFromArray(*this,array); } 
        inline VectorN(float c) { AssignFromValue(*this,c); } 
        
        //access operators
        inline float& operator[](uint index) { return elements[index]; } 
        inline const float& operator[](uint index) const { return elements[index]; } 
        
        //binary non-altering operators
        inline VectorN operator*(const VectorN &o) const { return Scale(*this,o); } 
        inline VectorN operator*(const float &o) const { return Scale<VectorN>(*this,o); } 
        friend inline VectorN operator*(const float &o, const VectorN &me) { return Scale<VectorN>(me,o); } 
        inline VectorN operator/(const VectorN &o) const { return Div(*this,o); } 
        inline VectorN operator/(const float &o) const { return Scale<VectorN>(*this,1/o); } 
        inline VectorN operator+(const VectorN &o) const { return Add(*this,o); } 
        inline VectorN operator+(const float &o) const { return Add(*this,VectorN(o)); } 
        inline VectorN operator-(const VectorN &o) const { return Sub(*this,o); } 
        inline VectorN operator-(const float &o) const { return Sub(*this,VectorN(o)); } 
        
        //binary self modifying operators
        inline void operator*=(const VectorN &o) { ScaleSelf(*this,o); } 
        inline void operator*=(const float &o) { ScaleSelf<VectorN>(*this,o); } 
        inline void operator/=(const VectorN &o) { DivSelf(*this,o); } 
        inline void operator/=(const float &o) { ScaleSelf<VectorN>(*this,1/o); } 
        inline void operator+=(const VectorN &o) { AddSelf(*this,o); } 
        inline void operator+=(const float &o) { AddSelf(*this,VectorN(o)); } 
        inline void operator-=(const VectorN &o) { SubSelf(*this,o); } 
        inline void operator-=(const float &o) { SubSelf(*this,VectorN(o)); } 
        
        //unary operators
        inline VectorN operator-() const { return Neg(*this); } 
        
        //comparison
        inline friend bool operator==(const VectorN &v1, const VectorN &v2) { return NearEqual(v1,v2); } 
        inline friend bool operator==(const VectorN &v, const float &c) { return NearEqual(v,c); } 
        
        inline friend bool operator!=(const VectorN &v1, const VectorN &v2) { return !NearEqual(v1,v2); } 
        inline friend bool operator!=(const VectorN &v, const float &c) { return !NearEqual(v,c); } 
        
        //other functions
        inline float LengthSquared() const { return VecDot(*this,*this); } 
        inline float Length() const { return std::sqrt(LengthSquared()); } 
        inline VectorN Normal() const { return VecNormal(*this); } 
        inline void Normalize() { VecNormalize(*this); } 
        inline float Dot(const VectorN &o) const { return VecDot(*this,o); } 
        inline float AngleBetween(const VectorN &o) const { return VecAngleBetween(*this,o); } 
        inline void Transform(const MatrixType &m) const { *this=TransformVector(m,*this); } 
        
        //human readable conversion
        operator const std::string() const; 
    };
    
    template <uint elemCount>
    VectorN<elemCount>::operator const std::string() const
    {
        std::string s="(";

        for (uint i=0; i<ElementCount(); ++i)
        {
            s+=MPMA::Vary(elements[i]);
            if (i!=ElementCount()-1) s+=", ";
        }

        s+=")";
        return s;
    }
    

    // -- MatrixN
    
    template <uint rowCount>
    struct MatrixN
    {
        typedef VectorN<rowCount> VectorType; 
        typedef VectorN<rowCount-1> LesserVectorType; 
        
        union
        {
            float elements[rowCount*rowCount]; 
            float rowcol[rowCount][rowCount]; 
        };
        inline uint RowColCount() const { return rowCount; } 
        inline uint ElementCount() const { return rowCount*rowCount; } 
        
        //ctors
        inline MatrixN() {} 
        inline MatrixN(const float *array) { AssignFromArray(*this,array); } 
        inline MatrixN(float c) { AssignFromValue(*this,c); } 
        
        //proxy access class, to allow for both 1d and 2d array notation to work
        template <typename T, typename TRet>
        class Proxy
        {
        public:
            inline Proxy(T &mat, int ind): mat(mat), ind(ind) {}
            inline operator TRet&() { return mat.elements[ind]; }
            inline TRet& operator[](uint offset) { return mat.rowcol[ind][offset]; }
            void operator=(const float val) {mat.elements[ind]=val;}
        
        private:
            T &mat;
            int ind;
        };
        
        //access operators
        inline Proxy<MatrixN, float> operator[](uint ind) { return Proxy<MatrixN, float>(*this,ind); } 
        inline Proxy<const MatrixN, const float> operator[](uint ind) const { return Proxy<const MatrixN, const float>(*this,ind); } 
        
        inline float m(int row, int col) const { return rowcol[row][col]; } 
        inline float& m(int row, int col) { return rowcol[row][col]; } 
        
        //equality operators
        inline friend bool operator==(const MatrixN &m1, const MatrixN &m2) { return NearEqual(m1,m2); } 
        inline friend bool operator!=(const MatrixN &m1, const MatrixN &m2) { return !NearEqual(m1,m2); } 
        
        //access a row(direct) or column(copied out) in the matrix as a vector
        inline VectorType& Row(uint r) { return *(VectorType*)rowcol[r]; } 
        inline const VectorType& Row(uint r) const { return *(const VectorType*)rowcol[r]; } 
        inline const VectorType GetColumn(uint col) const; 
        inline void SetColumn(uint col, const VectorType &vec); 
        inline void SetColumn(uint col, const LesserVectorType &vec); 
        
        //binary non-altering operators
        inline MatrixN operator*(const float &o) const { return Scale<MatrixN>(*this,o); } 
        inline MatrixN operator*(const int &o) const { return Scale<MatrixN>(*this,(float)o); } 
        friend inline MatrixN operator*(const float &o, const MatrixN &me) { return Scale(me,o); } 
        inline MatrixN operator/(const float &o) const { return Scale<MatrixN>(*this,1/o); } 
        inline MatrixN operator/(const int &o) const { return Scale<MatrixN>(*this,1.0f/o); } 
        inline MatrixN operator+(const MatrixN &o) const { return Add(*this,o); } 
        inline MatrixN operator+(const float &o) const { return Add(*this,MatrixN(o)); } 
        inline MatrixN operator-(const MatrixN &o) const { return Sub(*this,o); } 
        inline MatrixN operator-(const float &o) const { return Sub(*this,MatrixN(o)); } 
        
        inline MatrixN operator-() const { return Neg(*this); } 
        
        //binary self-modifying operators
        inline void operator*=(const float &o) { ScaleSelf<MatrixN>(*this,o); } 
        inline void operator/=(const float &o) { ScaleSelf<MatrixN>(*this,1/o); } 
        inline void operator+=(const MatrixN &o) { AddSelf(*this,o); } 
        inline void operator+=(const float &o) { AddSelf(*this,MatrixN(o)); } 
        inline void operator-=(const MatrixN &o) { SubSelf(*this,o); } 
        inline void operator-=(const float &o) { SubSelf(*this,MatrixN(o)); } 
        
        //other operators
        inline MatrixN operator*(const MatrixN &o) const { return MatMul(*this,o); } 
        inline void operator*=(const MatrixN &o) { *this=MatMul(*this,o); } 
        inline VectorType operator*(const VectorType &v) const { return TransformVector(*this,v); } 
        
        //other operations
        inline MatrixN Transpose() const; 
        inline void SetTranspose(); 
        inline void MakeIdentity(); 
        inline LesserVectorType GetTranslation() const { return LesserVectorType(GetColumn(RowColCount()-1)); } 
        inline void SetTranslation(const LesserVectorType &v) { SetColumn(RowColCount()-1,v); } 

        //human readable conversion
        operator const std::string() const; 
    };
    
    template <uint rowCount>
    inline const typename MatrixN<rowCount>::VectorType MatrixN<rowCount>::GetColumn(uint col) const
    {
        VectorType vec;
        for (uint i=0; i<RowColCount(); ++i)
            vec[i]=rowcol[i][col];
        return vec;
    }
    
    template <uint rowCount>
    inline void MatrixN<rowCount>::SetColumn(uint col, const VectorType &vec)
    {
        for (uint i=0; i<RowColCount(); ++i)
            rowcol[i][col]=vec[i];
    }
    
    template <uint rowCount>
    inline void MatrixN<rowCount>::SetColumn(uint col, const LesserVectorType &vec)
    {
        for (uint i=0; i<vec.ElementCount(); ++i)
            rowcol[i][col]=vec[i];
    }
    
    template <uint rowCount>
    MatrixN<rowCount> MatrixN<rowCount>::Transpose() const
    {
        return MatTranspose(*this);
    }
    
    template <uint rowCount>
    void MatrixN<rowCount>::SetTranspose()
    {
        //swap the rows and cols, leaving the diagonal alone
        for (uint r=1; r<RowColCount(); ++r)
        {
            for (uint c=0; c<r; ++c)
            {
                float tmp=rowcol[r][c];
                rowcol[r][c]=rowcol[c][r];
                rowcol[c][r]=tmp;
            }
        }
    }
    
    template <uint rowCount>
    inline void MatrixN<rowCount>::MakeIdentity()
    {
        for (uint x=0; x<RowColCount(); ++x)
            for (uint y=0; y<RowColCount(); ++y)
                rowcol[x][y]=0;

        for (uint i=0; i<RowColCount(); ++i)
            rowcol[i][i]=1;
    }
    
    template <uint rowCount>
    MatrixN<rowCount>::operator const std::string() const
    {
        std::string s="[";
        for (uint i=0; i<RowColCount(); ++i)
        {
            s+=Row(i);
            if (i!=RowColCount()-1) s+=", ";
        }

        s+="]";
        return s;
    }
    
} //namespace GEO