KeosVector2.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_VECTOR2_H
#define KEOS_VECTOR2_H

#include "KeosPrerequisites.h"

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

    CVector2(T X = 0, T Y = 0);

    void Set(T X, T Y);

    T Length() const;

    T LengthSq() const;

    void Normalize();

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

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

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

    CVector2<T> operator *(T t) const;
    CVector2<T> operator /(T t) const;

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

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

    operator T*();

    // Vector components
    T x, y;
  };

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

  // Usual types of vectors
  typedef CVector2<int>   TVector2I;
  typedef CVector2<float> TVector2F;


  //=======================================================================
  // CVector2 inline functions
  //=======================================================================

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

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

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

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

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

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

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

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

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

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

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

    return *this;
  }

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

    return *this;
  }

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

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

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

    return *this;
  }

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

    return *this;
  }

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

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

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

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

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

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

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

  //-----------------------------------------------------------------------
  template <class T>
  inline CVector2<T> VectorCross(const CVector2<T>& v1, const CVector2<T>& v2)
  {
    return CVector2<T>(/* ??? */);
  }

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

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


} // namespace Keos


#endif // KEOS_VECTOR2_H

---