---

RainVector.h

Go to the documentation of this file.

#ifndef __GXVECTOR_H
#define __GXVECTOR_H


#include "math.h"



//vector
template<unsigned int count>
class CRainVector
{
public:
        float m_fPoints[count];

        inline void Normalize()
        {
                float fLen=GetLength();

                if(0==fLen)
                {
                        return;
                }

                operator/= (fLen);
        }


        //todo, add an [] (returns float&) operator here instead of using m_fpoints, and update in the other ones dummy (like the CGXVector)
        inline float GetLength()
        {
                float fLen=0;

                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        fLen+=(m_fPoints[uCtr]*m_fPoints[uCtr]);
                }

                return (float)sqrt(fLen);
        }

        inline float operator[] (UINT uIndex)
        {
                return m_fPoints[uIndex];
        }


        inline void operator*= (float fMul)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]*=fMul;
                }
        }

        inline void operator+= (float fAdd)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]+=fAdd;
                }
        }


        inline CRainVector<count> operator* (float fAmt)
        {
                CRainVector<count> vRet;
                memcpy(&vRet,this,sizeof(CRainVector<count>));
                vRet*=fAmt;
                return vRet;
        }

        inline CRainVector<count> operator+ (CRainVector<count>& vIn)
        {
                CRainVector<count> vRet;
                
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        vRet.m_fPoints[uCtr]=m_fPoints[uCtr]+vIn.m_fPoints[uCtr];
                }

                return vRet;
        }

        inline CRainVector<count> operator* (CRainVector<count>& vIn)
        {
                CRainVector<count> vRet;
                
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        vRet.m_fPoints[uCtr]=m_fPoints[uCtr]*vIn.m_fPoints[uCtr];
                }

                return vRet;
        }


        inline CRainVector<count> operator/ (CRainVector<count>& vIn)
        {
                CRainVector<count> vRet;
                
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        vRet.m_fPoints[uCtr]=m_fPoints[uCtr]/vIn.m_fPoints[uCtr];
                }

                return vRet;
        }


        inline void operator/= (float fDiv)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]/=fDiv;
                }
        }

        inline void operator-= (CRainVector<count>& vSub)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]-=vSub.m_fPoints[uCtr];
                }
        }

        inline void operator+= (CRainVector<count>& vAdd)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]+=vAdd.m_fPoints[uCtr];
                }
        }

        inline void operator*= (CRainVector<count>& vMul)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]*=vMul.m_fPoints[uCtr];
                }
        }

        inline void operator/= (CRainVector<count>& vDiv)
        {
                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        m_fPoints[uCtr]/=vDiv.m_fPoints[uCtr];
                }
        }




        inline CRainVector operator- (CRainVector<count>& vSub)
        {
                CRainVector vOut=*this;
                vOut-=vSub;
                return vOut;
        }
        

        inline float Dot(CRainVector<count>& vRightSide)
        {
                float fResult=0;

                for(UINT uCtr=0;uCtr<count;uCtr++)
                {
                        fResult+=m_fPoints[uCtr]*(vRightSide.m_fPoints[uCtr]);
                }

                return fResult;
        }

        /*      CBlakeUtil3DVector returnVal;
        returnVal.m_x=(m_y*vArg.m_z)-(m_z*vArg.m_y);
        returnVal.m_y=(m_z*vArg.m_x)-(m_x*vArg.m_z);
        returnVal.m_z=(m_x*vArg.m_y)-(m_y*vArg.m_x);*/


        inline bool Cross(CRainVector<count>& vOut, CRainVector<count>& vRightSide)
        {
                if(3==count)
                {
                        vOut.m_fPoints[0]=(m_fPoints[1]*vRightSide.m_fPoints[2])-(m_fPoints[2]*vRightSide.m_fPoints[1]);
                        vOut.m_fPoints[1]=(m_fPoints[2]*vRightSide.m_fPoints[0])-(m_fPoints[0]*vRightSide.m_fPoints[2]);
                        vOut.m_fPoints[2]=(m_fPoints[0]*vRightSide.m_fPoints[1])-(m_fPoints[1]*vRightSide.m_fPoints[0]);
                        return true;
                }

                return false;
        }

};





#endif

---