---

sglVec2.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglVec2.hpp
 *  Created: 8 March 1999
 *  Summary: 2D templated vector class
 *****************************************************************************/

#ifndef __SGL_VEC2_HPP
#define __SGL_VEC2_HPP

#include <sgl.h>

template <class T> class sglMat2;

// ---------------------------------------------------------------------------

template <class T>
class sglVec2
{
public:
   // constructors
   sglVec2() {};

   sglVec2(T x, T y)
      { m_vector[0] = x; m_vector[1] = y; }

   template <class S>
   sglVec2(const sglVec2<S>& vec)
      { m_vector[0] = (T)vec[0]; m_vector[1] = (T)vec[1]; }

   // destructor
   ~sglVec2() {};  // not virtual, do not subclass

   inline T *getPtr() const { return (T *)m_vector; }

   // indexing operators
   inline T& operator[](unsigned int i)             { return m_vector[i]; }
   inline const T& operator[](unsigned int i) const { return m_vector[i]; }

   // set from any other type
   template <class S>
   inline void set(S x, S y) { m_vector[0] = (T)x; m_vector[1] = (T)y; }  

   // assignment operator
   template <class S>
   inline sglVec2 &operator=(const sglVec2<S>& vec)
      {
         m_vector[0] = (T)vec[0];  m_vector[1] = (T)vec[1]; return *this;
      }

   // boolean operators
   template <class S>
   inline bool operator==(const sglVec2<S>& vec) const
      {
         return (m_vector[0] == (T)vec[0] && m_vector[1] == (T)vec[1]);
      }
   template <class S>
   inline bool operator!=(const sglVec2<S>& vec) const
      {
         return (m_vector[0] != (T)vec[0] || m_vector[1] != (T)vec[1]);
      }

   template <class S>
   inline bool operator<(const sglVec2<S>& vec) const
      {
         return (dot(*this) < vec.dot(vec));
      }
   template <class S>
   inline bool operator>(const sglVec2<S>& vec) const
      {
         return (dot(*this) > vec.dot(vec));
      }

   // math operators
   template <class S>
   inline sglVec2& operator+=(const sglVec2<S>& vec)
      {
         m_vector[0] += (T)vec[0]; m_vector[1] += (T)vec[1]; return *this;
      }
   template <class S>
   inline sglVec2& operator-=(const sglVec2<S>& vec)
      {
         m_vector[0] -= (T)vec[0]; m_vector[1] -= (T)vec[1]; return *this;
      }
   inline sglVec2& operator*=(const T s)
      {
         m_vector[0] *= s; m_vector[1] *= s; return *this;
      }

   template <class S>
   inline const sglVec2<T> operator+(const sglVec2<S> &rhs) const
      {
         return sglVec2(m_vector[0]+(T)rhs[0],
                        m_vector[1]+(T)rhs[1]);
      }
   template <class S>
   inline const sglVec2<T> operator-(const sglVec2<S> &rhs) const
      {
         return sglVec2(m_vector[0]-(T)rhs[0],
                        m_vector[1]-(T)rhs[1]);
      }
   inline const sglVec2<T> operator*(T scalar) const
      {
         return sglVec2(m_vector[0]*(T)scalar, m_vector[1]*(T)scalar);
      }

   // explicit math operations (for backward compatibility)
   template <class S1, class S2>
   inline void add(const sglVec2<S1>& vec1, const sglVec2<S2>& vec2)
      {
         m_vector[0] = (T)vec1[0] + (T)vec2[0];
         m_vector[1] = (T)vec2[1] + (T)vec1[1];
      }
   template <class S1, class S2>
   inline void sub(const sglVec2<S1>& vec1, const sglVec2<S2>& vec2)
      {
         m_vector[0] = (T)vec1[0] - (T)vec2[0];
         m_vector[1] = (T)vec1[1] - (T)vec2[1];
      }
   template <class S>
   inline void scale(const sglVec2<S>& vec, T s)
      {
         m_vector[0] = (T)vec[0]*s;
         m_vector[1] = (T)vec[1]*s;
      }

   // other ops
   template <class S>
   inline bool almostEqual(const sglVec2<S>& vec, double eps) const
      {
         return (SGL_ALMOST_EQUAL(m_vector[0], vec[0], eps) &&
                 SGL_ALMOST_EQUAL(m_vector[1], vec[1], eps));
      }

   template <class S>
   inline T dot(const sglVec2<S>& vec) const
      {
         return (m_vector[0]*(T)vec[0] + m_vector[1]*(T)vec[1]);
      }

   template <class S, class R>
   inline static R dot(const sglVec2<R>& vec1, const sglVec2<S>& vec2)
      {
         return vec1[0]*(R)vec2[0] + vec1[1]*(R)vec2[1];
      }

   inline T length() const
      {
         return (T) sqrt(dot(*this));
      }

   template <class S>
   inline T distance(const sglVec2<S>& vec) const
      {
         return (T) sqrt(((T)vec[0] - m_vector[0])*((T)vec[0] - m_vector[0]) +
                         ((T)vec[1] - m_vector[1])*((T)vec[1] - m_vector[1]));
      }

   inline T normalize()
      {
         T len = length();
         if (len) *this *= (1.0/len);
         return len;
      }

   template <class S>
   inline T normalize(const sglVec2<S>& vec)
      {
         T len = vec.length();
         if (len) scale(vec, 1.0/len);
         return len;
      }

   // stream operators
#if defined(TEMPLATE_OSTREAM_HACK)
   template <class S>
   friend ostream& operator<< (ostream& ostrm, const sglVec2<S>& vec);

   template <class S>
   friend istream& operator>> (istream& istrm, sglVec2<S>& vec);
#else
   friend ostream& operator<< (ostream& ostrm, const sglVec2<T>& vec)
        {
            return (ostrm << "(" << vec[0] << ", " << vec[1] << ")");
        }

   friend istream& operator>> (istream& istrm, sglVec2<T>& vec)
        {
            return (istrm >> vec[0] >> vec[1]);
        }
#endif

private:
   T m_vector[2];
};

//----------------------------------------------------------------------------
#if defined(TEMPLATE_OSTREAM_HACK)
template <class T>
inline ostream& operator<<(ostream& ostrm, const sglVec2<T>& vec)
{
    return (ostrm << "(" << vec[0] << ", " << vec[1] << ")");
}

template <class T>
inline istream& operator>>(istream& istrm, sglVec2<T>& vec)
{
    return (istrm >> vec[0] >> vec[1]);
}
#endif
//----------------------------------------------------------------------------

#endif

---