D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_vector3.h

/* LICENSE_BEGIN
SutoiTools library supply support for debugging, testing and 
setting good bases for you application. It is part of the 
SugoiEngine project.
Copyright (C) 2006 Allusse Yannick (yannick dot allusse at laposte dot net)


This program is free software; you can redistribute it and/or
modify it under the terms of the GNU 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
LICENSE_END
*/

/* \file SG_TLS_cl_vector3.h
 * \brief Basic template vector class of any type and size 3.
 * \author Yannick Allusse
*/


#ifndef CL_VECTORS_TMPL_3_h
#define CL_VECTORS_TMPL_3_h

#include "SugoiTools\cl_vectors_template.h"

#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new.h"
#endif 


namespace SGE{

          
template <typename TType> class CL_Vector3D;
typedef CL_Vector3D<float>              CL_Vector3Df;
typedef CL_Vector3D<int>                CL_Vector3Di;
typedef CL_Vector3D<double>             CL_Vector3Dd;


//=========================================================
//=========================================================
//        CL_Vector3D
//=========================================================
//=========================================================
template <typename TType> class CL_Vector3D : public CLT_Vector<TType>
{
public :
          TType &x; 
          TType &y; 
          TType &z; 

//Contructors / Destructors   =================================
          _SG_TLS_INLINE CL_Vector3D();
          _SG_TLS_INLINE CL_Vector3D(const CLT_Vector<TType> &_Vec);
          _SG_TLS_INLINE CL_Vector3D(const CL_Vector3D<TType> &       _Vec);
          _SG_TLS_INLINE CL_Vector3D(const TType *          _Val);
          _SG_TLS_INLINE CL_Vector3D(const TType            _Val);
          _SG_TLS_INLINE CL_Vector3D(const TType _x, const TType _y, const TType _z);
                                                  ~CL_Vector3D();
//==========================================================
          _SG_TLS_INLINE void           Set(const TType _x, const TType _y, const TType _z);
          _SG_TLS_INLINE CL_Vector3D<TType> & operator= (const CL_Vector3D<TType> & _Vec2);
          _SG_TLS_INLINE CL_Vector3D<TType> & operator= (const TType  * _Val);
          _SG_TLS_INLINE CL_Vector3D<TType> & operator= (const TType  _Val);
//===========================================================

          _SG_TLS_INLINE const TType                                  operator %	(const CL_Vector3D<TType> &) const;          
          _SG_TLS_INLINE const CL_Vector3D<TType> operator ^	(const CL_Vector3D<TType> &) const;           
          _SG_TLS_INLINE const CL_Vector3D<TType>&          operator ^= (const CL_Vector3D<TType> &);

          _SG_TLS_INLINE const TType                                  operator !	() const;// Distance from [0, 0, 0]
          _SG_TLS_INLINE const CL_Vector3D<TType> operator |          (const TType &) const;       // Sets distance from [0, 0, 0]
          _SG_TLS_INLINE                CL_Vector3D<TType>& operator |= (const TType &);
//===========================================================

          _SG_TLS_INLINE const TType                                  Angle               (const CL_Vector3D<TType> &) const;                 // Calculates angle between this and another point
          _SG_TLS_INLINE const CL_Vector3D<TType> Reflection          (const CL_Vector3D<TType> &) const;             // Mirrors the direction of this point to [0, 0, 0] using the line from [0, 0, 0] to the other point
          _SG_TLS_INLINE const CL_Vector3D<TType> Rotate              (const TType &, const CL_Vector3D<TType> &) const; // Rotates and stuff

#ifdef NX_FOUNDATION_NXVEC3
          _SG_TLS_INLINE  CL_Vector3D<TType> &operator=     (const NxVec3 &_NxVec);
#endif
};



//============================================================================
//CL_Vector3D START===========================================================
//============================================================================
template <typename TType> CL_Vector3D<TType>::CL_Vector3D() : CLT_Vector<TType>(3,0.), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{}

template <typename TType> CL_Vector3D<TType>::CL_Vector3D(const CLT_Vector<TType> &_Vec) : CLT_Vector<TType>(_Vec), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{}


template <typename TType> CL_Vector3D<TType>::CL_Vector3D(const CL_Vector3D<TType> &_Vec) : CLT_Vector<TType>(_Vec), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{}

template <typename TType> CL_Vector3D<TType>::CL_Vector3D(const TType * _Val)  :CLT_Vector<TType>(3,_Val), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{}

template <typename TType> CL_Vector3D<TType>::CL_Vector3D(const TType _Val):CLT_Vector<TType>(3,_Val), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{}

template <typename TType> CL_Vector3D<TType>::CL_Vector3D(const TType _x, const TType _y, const TType _z):CLT_Vector<TType>(3,0.), x( CLT_Vector<TType>::vec[0]), y( CLT_Vector<TType>::vec[1]),z( CLT_Vector<TType>::vec[2])
{
          Set(_x, _y, _z);
}

template <typename TType> CL_Vector3D<TType>::~CL_Vector3D(){}

template <typename TType> void CL_Vector3D<TType>::Set(const TType _x, const TType _y, const TType _z)
{
          x = _x;
          y = _y;
          z = _z;
}

template <typename TType> CL_Vector3D<TType> & CL_Vector3D<TType>::operator= (const CL_Vector3D<TType> & _Vec2)
{
          VECTOR_OP_EQUAL(this, _Vec2.vec[i], , GetDim());
          return (*this);
}
template <typename TType> CL_Vector3D<TType> & CL_Vector3D<TType>::operator= (const TType * _Val)
{
          SG_Assert(_Val, "Given Value is NULL");
          VECTOR_OP_EQUAL(this, _Val[i], , GetDim());
          return(*this);
}
template <typename TType> CL_Vector3D<TType> & CL_Vector3D<TType>::operator= (const TType _Val)
{
          VECTOR_OP_EQUAL(this, _Val, , GetDim());
          return(*this);
}


#ifdef NX_FOUNDATION_NXVEC3

template <typename TType> CL_Vector3D<TType> & CL_Vector3D<TType>::operator=	(const NxVec3 &_NxVec)
{
          Set (_NxVec.x ,_NxVec.y, _NxVec.z);
          return *this;
}
#endif
//==================================================================
//Arithmetic operators START =====================================
//==================================================================


template <typename TType> const TType CL_Vector3D<TType>::operator % (const CL_Vector3D<TType> &v) const
 {
  return x*v.x + y*v.y + z*v.z;
 }

template <typename TType> const CL_Vector3D<TType> CL_Vector3D<TType>::operator ^ (const CL_Vector3D<TType> &v) const
 {
  return CL_Vector3D(y*v.z-v.y*z, z*v.x-v.z*x, x*v.y-v.x*y);
 }

template <typename TType> const CL_Vector3D<TType> & CL_Vector3D<TType>::operator ^= (const CL_Vector3D<TType> &v)
 {   return (*this = *this ^ v);  }

template <typename TType> const TType CL_Vector3D<TType>::operator !() const
 {
  return sqrt(x*x + y*y + z*z);
 }


template <typename TType> const CL_Vector3D<TType> CL_Vector3D<TType>::operator | (const TType &_v) const
{
  return ((*this) * (_v / !(*this)));
  //return (*this * (l / !*this));
}

template <typename TType> CL_Vector3D<TType> & CL_Vector3D<TType>::operator |= (const TType &_v)
{
  return (*this = *this | _v);
}

//Arithmetique operators END =====================================
template <typename TType> const TType CL_Vector3D<TType>::Angle(const CL_Vector3D<TType> &_v) const
 {
  return acos(*this % _v) * 57.2957795130823208767981548141052;
 }

template <typename TType> const CL_Vector3D<TType> CL_Vector3D<TType>::Reflection(const CL_Vector3D<TType> &_v) const
 {
  const CL_Vector3D n(*this | 1.0);
//  return (n - v * 2.0 * (n % v)) * !this;
  return (n - _v * 2.0 * (n % _v)) * !*this;
 }



template <typename TType> const CL_Vector3D<TType> CL_Vector3D<TType>::Rotate(const TType &a, const CL_Vector3D<TType> &v) const
 {
  const double s = sin(0.0174532925199432957692369076848861*a);
  const double c = cos(0.0174532925199432957692369076848861*a);
  //return CL_Vector3D(this * c + ((v * this) * (1.0 - c)) * v + (this ^ v) * s);
  return CL_Vector3D(*this * c + ((v * *this) * (1.0 - c)) * v + (*this ^ v) * s);
 }
//============================================================================
//CL_Vector3D END================================================================
//============================================================================


};//namespace SGE

#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new_off.h"//Must be the last....
#endif 



#endif//CL_VECTORS_TMPL_3_h

---