E:/PROGRAMMING/X_PROJECTS/VSTUDIO/src/MODULES/Math/TVector3.h

Go to the documentation of this file.

/****************************************************************************\
*                                                                            *
* 19.02.2006                                                                 *
* TVector3 - Header File                                                     *
*                                                                            *
* (c) Raphael Charwot                                                        *
*                                                                            *
* If you are wondering about all the consts and references, read             *
* "Effective C++" and "More Effective C++" by Scott Meyers                   *
\****************************************************************************/

#ifndef __TVECTOR3_H__
#define __TVECTOR3_H__

/****************************************************************************\
* REQUIRED HEADERS                                                           *
\****************************************************************************/
#include <Definitions.h>
#include <math.h>

/****************************************************************************\
* DEFINITIONS                                                                  *
\****************************************************************************/

/****************************************************************************\
* CLASS                                                                      *
\****************************************************************************/
template<typename T>
struct TVector3
{
  /**************************************************************************\
  * PUBLIC CLASS FUNCTIONS                                                   *
  \**************************************************************************/
  public:
        
          //TVector3() {m_X = 0; m_Y = 0; m_Z = 0;}
    TVector3() {}     //No initialization for speed purposes
        TVector3(const T &v) : m_X(v), m_Y(v), m_Z(v) {}
    TVector3(const T &x, const T &y, const T &z) : m_X(x), m_Y(y), m_Z(z) {}
    TVector3(const TVector3<T> &other) : m_X(other.m_X), m_Y(other.m_Y), m_Z(other.m_Z) {}

    const TVector3<T> &operator=(const TVector3<T> &other) {m_X = other.m_X; m_Y = other.m_Y; m_Z = other.m_Z; return *this;}

    const TVector3<T> operator+(const TVector3<T> &other) const {return TVector3<T>(m_X + other.m_X, m_Y + other.m_Y, m_Z + other.m_Z);}
    const TVector3<T> &operator+=(const TVector3<T> &other) {m_X += other.m_X; m_Y += other.m_Y; m_Z += other.m_Z; return *this;}

    const TVector3<T> operator-(const TVector3<T> &other) const {return TVector3<T>(m_X - other.m_X, m_Y - other.m_Y, m_Z - other.m_Z);}
    const TVector3<T> &operator-=(const TVector3<T> &other) {m_X -= other.m_X; m_Y -= other.m_Y; m_Z -= other.m_Z; return *this;}

    const TVector3<T> operator*(const T &factor) const {return TVector3<T>(m_X * factor, m_Y * factor, m_Z * factor);}
    const TVector3<T> &operator*=(const T &factor) {m_X *= factor; m_Y *= factor; m_Z *= factor; return *this;}

    const TVector3<T> operator/(const T &quot) const {return TVector3<T>(m_X / quot, m_Y / quot, m_Z / quot);}
    const TVector3<T> &operator/=(const T &quot) {m_X /= quot; m_Y /= quot; m_Z /= quot; return *this;}

    //This is the CROSS-Product!!
    const TVector3<T> operator*(const TVector3<T> &other) const {return TVector3<T>(m_Y * other.m_Z - m_Z * other.m_Y, m_Z * other.m_X - m_X * other.m_Z, m_X * other.m_Y - m_Y * other.m_X);}

    const TVector3<T> operator-() const {return TVector3<T>(-m_X, -m_Y, -m_Z);}

    bool operator==(const TVector3<T> &other) {return m_X == other.m_X && m_Y == other.m_Y && m_Z == other.m_Z;}
    bool operator!=(const TVector3<T> &other) {return m_X != other.m_X || m_Y != other.m_Y || m_Z != other.m_Z;}

    T &operator[](const byte &i) {assert(i < 3 && "Error: Invalid index for TVector3::operator[]!");
                                        return *(&m_X + i);}

    const T &operator[](const byte &i) const {assert(i < 3 && "Error: Invalid index for TVector3::operator[]!");
                                              return *(&m_X + i);}

    void Set(const T &x, const T &y, const T &z) {m_X = x; m_Y = y; m_Z = z;}

    const float Length() const {return sqrt(m_X * m_X + m_Y * m_Y + m_Z * m_Z);}
    const float LengthSqr() const {return m_X * m_X + m_Y * m_Y + m_Z * m_Z;}

    void Normalize() {assert(LengthSqr() && "Error: TVector3::Normalize called for a zero vector!");
                      float fL = 1 / Length(); m_X *= fL; m_Y *= fL; m_Z *= fL;}

    const T Dot(const TVector3<T> &other) const {return m_X * other.m_X + m_Y * other.m_Y + m_Z * other.m_Z;}

        void LookAlongRot(TVector3<T> vDir);
        void ShortestRot(const TVector3<T> &vFrom, const TVector3<T> &vTo);

    void Log(word wTargetLog) const {LOG(wTargetLog, "(%.2f, %.2f, %.2f)", m_X, m_Y, m_Z);}

    /**************************************************************************\
    * PUBLIC CLASS MEMBERS                                                     *
    \**************************************************************************/
    public:
        T m_X, m_Y, m_Z;
};

typedef TVector3<float>  CVector3f;
typedef TVector3<sword>  CVector3sw;
typedef TVector3<sdword> CVector3sdw;
typedef TVector3<double> CVector3d;

#include "CMatrix33.h"

template<typename T>
void TVector3<T>::LookAlongRot(TVector3<T> vDir)
{
        float fLen = vDir.Length();
        if(fLen > 0.0001) //Prevent division by zero
        {
                vDir /= fLen;
                TVector3<T> vUp, vRight;
                if(vDir.m_Y > 0.9999f) //Prevent up and in vector being the same
                {
                        vUp.Set(0.0f, 0.0f, 1.0f);
                }
                else
                {
                        vUp.Set(0.0f, 1.0f, 0.0f);
                }
                vRight = vDir * vUp;
                vRight.Normalize();
                vUp = vRight * vDir;
                //Ok, we got the vectors! Lets create the matrix
                CMatrix33 mat;
                mat._11 = vRight.m_X;
                mat._21 = vRight.m_Y;
                mat._31 = vRight.m_Z;
                mat._12 = vUp.m_X;
                mat._22 = vUp.m_Y;
                mat._32 = vUp.m_Z;
                //invert the in vector
                mat._13 = -vDir.m_X;
                mat._23 = -vDir.m_Y;
                mat._33 = -vDir.m_Z;

                //Extract rotation
                *this = mat.GetZXYRotationVector();
        }
}

template<typename T>
void TVector3<T>::ShortestRot(const TVector3<T> &vFrom, const TVector3<T> &vTo)
{
        *this = vTo - vFrom;

        while(m_X > MY_PI)
        {
                m_X -= 2.0f * MY_PI;
        }
        while(m_X < -MY_PI)
        {
                m_X += 2.0f * MY_PI;
        }
        while(m_Y > MY_PI)
        {
                m_Y -= 2.0f * MY_PI;
        }
        while(m_Y < -MY_PI)
        {
                m_Y += 2.0f * MY_PI;
        }
        while(m_Z > MY_PI)
        {
                m_Z -= 2.0f * MY_PI;
        }
        while(m_Z < -MY_PI)
        {
                m_Z += 2.0f * MY_PI;
        }
}

#endif

---