KeosVector3.h

Go to the documentation of this file.

/*
 * This source file is part of KEOS (Free 3D Engine)
 * For the latest info, see http://www.keosengine.org/
 * E-mails : thierry.vouriot@keosengine.org, yeri@keosengine.org
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
 * http://www.gnu.org/copyleft/lesser.txt.
 *
 */

#ifndef KEOS_VECTOR3_H
#define KEOS_VECTOR3_H

#include "KeosPrerequisites.h"

namespace Keos
{
  //-----------------------------------------------------------------------
  template <class T>
  class CVector3
  {
  public :

    CVector3(T X = 0, T Y = 0, T Z = 0);

    void Set(T X, T Y, T Z);

    T Length() const;

    T LengthSq() const;

    void Normalize();

    // arithmetic operations
    CVector3<T> operator +() const;
    CVector3<T> operator -() const;

    CVector3<T> operator +(const CVector3<T>& v) const;
    CVector3<T> operator -(const CVector3<T>& v) const;

    const CVector3<T>& operator +=(const CVector3<T>& v);
    const CVector3<T>& operator -=(const CVector3<T>& v);

    const CVector3<T>& operator *=(T t);
    const CVector3<T>& operator /=(T t);

    bool operator ==(const CVector3<T>& v) const;
    bool operator !=(const CVector3<T>& v) const;

    operator T*();

    // Vector components
    T x, y, z;
  };

  // Globals functions
  template <class T> CVector3<T>   operator * (const CVector3<T>& v, T t);
  template <class T> CVector3<T>   operator / (const CVector3<T>& v, T t);
  template <class T> CVector3<T>   operator * (T t, const CVector3<T>& v);
  template <class T> T             VectorDot  (const CVector3<T>& v1, const CVector3<T>& v2);
  template <class T> CVector3<T>   VectorCross(const CVector3<T>& v1, const CVector3<T>& v2);
  template <class T> CVector3<T>  VectorBetweenTwoPoints(const CVector3<T>& p1, const CVector3<T>& p2);
  template <class T> std::istream& operator >>(std::istream& Stream, CVector3<T>& Vector);
  template <class T> std::ostream& operator <<(std::ostream& Stream, const CVector3<T>& Vector);

  // Usual types of vectors
  typedef CVector3<int>   TVector3I;
  typedef CVector3<float> TVector3F;


  //=======================================================================
  // CVector3 inline functions
  //=======================================================================

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T>::CVector3(T X, T Y, T Z) :
      x(X),
      y(Y),
      z(Z)
  {}

  //-----------------------------------------------------------------------
  template <class T>
  inline void CVector3<T>::Set(T X, T Y, T Z)
  {
    x = X;
    y = Y;
    z = Z;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline T CVector3<T>::Length() const
  {
    return std::sqrt(LengthSq());
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline T CVector3<T>::LengthSq() const
  {
    return x * x + y * y + z * z;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline void CVector3<T>::Normalize()
  {
    T Norm = Length();

    if (std::abs(Norm) > std::numeric_limits<T>::epsilon())
    {
      x /= Norm;
      y /= Norm;
      z /= Norm;
    }
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> CVector3<T>::operator +() const
  {
    return this;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> CVector3<T>::operator -() const
  {
    return CVector3<T>(-x, -y, -z);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> CVector3<T>::operator +(const CVector3<T>& v) const
  {
    return CVector3<T>(x + v.x, y + v.y, z + v.z);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> CVector3<T>::operator -(const CVector3<T>& v) const
  {
    return CVector3<T>(x - v.x, y - v.y, z - v.z);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline const CVector3<T>& CVector3<T>::operator +=(const CVector3<T>& v)
  {
    x += v.x;
    y += v.y;
    z += v.z;

    return *this;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline const CVector3<T>& CVector3<T>::operator -=(const CVector3<T>& v)
  {
    x -= v.x;
    y -= v.y;
    z -= v.z;

    return *this;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline const CVector3<T>& CVector3<T>::operator *=(T t)
  {
    x *= t;
    y *= t;
    z *= t;

    return *this;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline const CVector3<T>& CVector3<T>::operator /=(T t)
  {
    x /= t;
    y /= t;
    z /= t;

    return *this;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline bool CVector3<T>::operator ==(const CVector3<T>& v) const
  {
    return ((std::abs(x - v.x) <= std::numeric_limits<T>::epsilon()) &&
            (std::abs(y - v.y) <= std::numeric_limits<T>::epsilon()) &&
            (std::abs(z - v.z) <= std::numeric_limits<T>::epsilon()));
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline bool CVector3<T>::operator !=(const CVector3<T>& v) const
  {
    return !(*this == v);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T>::operator T*()
  {
    return &x;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> operator *(const CVector3<T>& v, T t)
  {
    return CVector3<T>(v.x * t, v.y * t, v.z * t);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> operator /(const CVector3<T>& v, T t)
  {
    return CVector3<T>(v.x / t, v.y / t, v.z / t);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> operator *(T t, const CVector3<T>& v)
  {
    return v * t;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline T VectorDot(const CVector3<T>& v1, const CVector3<T>& v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> VectorCross(const CVector3<T>& v1, const CVector3<T>& v2)
  {
    return CVector3<T>(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector3<T> VectorBetweenTwoPoints(const CVector3<T>& p1, const CVector3<T>& p2)
  {
    return CVector3<T>(p1.x - p2.x, p1.y - p2.y, p1.z - p2.z);
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline std::istream& operator >>(std::istream& Stream, CVector3<T>& Vector)
  {
    return Stream >> Vector.x >> Vector.y >> Vector.z;
  }

  //-----------------------------------------------------------------------
  template <class T>
  inline std::ostream& operator <<(std::ostream& Stream, const CVector3<T>& Vector)
  {
    return Stream << Vector.x << " " << Vector.y << " " << Vector.z;
  }


} // namespace Keos


#endif // KEOS_VECTOR3_H

---