D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_vector4.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_vector_tmpl_4.h
 * \brief Basic template vector class of any type and size 4.
 * \author Yannick Allusse
*/


#ifndef CL_VECTORS_TMPL_4_h
#define CL_VECTORS_TMPL_4_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_Vector4D_Base;
template <typename TType> class CL_Color4;

typedef CL_Color4<float>      CL_Color4f;
typedef CL_Color4<int>                  CL_Color4i;
typedef   CL_Color4<double>   CL_Color4d;

typedef CL_Vector4D_Base<float>                   CL_Vector4Df;
typedef CL_Vector4D_Base<int>           CL_Vector4Di;
typedef CL_Vector4D_Base<double>        CL_Vector4Dd;

//=========================================================
//=========================================================
//        CL_Vector4D_Base
//=========================================================
//=========================================================

template <typename TType> class CL_Vector4D_Base : public CLT_Vector<TType>
{
public :

//Contructors / Destructors   =================================
          _SG_TLS_INLINE CL_Vector4D_Base();
          _SG_TLS_INLINE CL_Vector4D_Base(const CLT_Vector<TType> &_Vec);
          /*_SG_TLS_INLINE CL_Vector4D_Base(const CL_Vector4D_Base &  _Vec);
          _SG_TLS_INLINE CL_Vector4D_Base(const TType *               _Val);
          _SG_TLS_INLINE CL_Vector4D_Base(const TType                 _Val);
          _SG_TLS_INLINE CL_Vector4D_Base(const TType                 _a, const TType _b, const TType _c , const TType _d);
          */
          _SG_TLS_INLINE ~CL_Vector4D_Base();
          

          _SG_TLS_INLINE void           Set(const TType _a, const TType _b, const TType _c , const TType _d);

          _SG_TLS_INLINE CL_Vector4D_Base<TType> & operator= (const CL_Vector4D_Base<TType> & _Vec2);
          _SG_TLS_INLINE CL_Vector4D_Base<TType> & operator= (const TType       * _Val);
          _SG_TLS_INLINE CL_Vector4D_Base<TType> & operator= (const TType       _Val);
//===========================================================

#if _SG_TLS_XML
          _SG_TLS_INLINE 
                    TiXmlElement*
                    XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        const CL_Vector4D_Base<TType> &_defVal);

          _SG_TLS_INLINE 
                    TiXmlElement*
                    XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        TType _defVal = 0);

          _SG_TLS_INLINE 
                    TiXmlElement* 
                    XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        std::string  _type, 
                                        const CL_Vector4D_Base<TType> &_defVal);

          _SG_TLS_INLINE 
                    TiXmlElement* 
                    XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        std::string  _type, 
                                        TType _defVal = 0);

/*

          _SG_TLS_INLINE bool XMLSave(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        char * _type, 
                                        const CL_Vector4D_Base<TType> &_defVal = CL_Vector4D_Base<TType>());
          _SG_TLS_INLINE bool XMLSave(TiXmlElement* XML_Elem, 
                                        const std::string _Name, 
                                        const CL_Vector4D_Base<TType> &_defVal = CL_Vector4D_Base<TType>());
*/
          #endif
};




          
//============================================================================
//CL_Vector4D_Base START===========================================================
//============================================================================
template <typename TType> 
CL_Vector4D_Base<TType>::CL_Vector4D_Base() 
          : CLT_Vector<TType>(4, 0.)
{}

template <typename TType> 
CL_Vector4D_Base<TType>::CL_Vector4D_Base(const CLT_Vector<TType> &_Vec)
          : CLT_Vector<TType>(_Vec)
          {}

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

template <typename TType> void CL_Vector4D_Base<TType>::Set(const TType _a, const TType _b, const TType _c , const TType _d)
{
          vec[0] = _a;
          vec[1] = _b;
          vec[2] = _c;
          vec[3] = _d;        
}

template <typename TType> CL_Vector4D_Base<TType> & CL_Vector4D_Base<TType>::operator= (const CL_Vector4D_Base<TType> & _Vec2)
{
          VECTOR_OP_EQUAL(this, _Vec2.vec[i], , GetDim());
          return(*this);
}
template <typename TType> CL_Vector4D_Base<TType> & CL_Vector4D_Base<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_Vector4D_Base<TType> & CL_Vector4D_Base<TType>::operator= (const TType _Val)
{
          VECTOR_OP_EQUAL(this, _Val, , GetDim());
          return(*this);
}



#if _SG_TLS_XML
template <typename TType>
          TiXmlElement*
                    CL_Vector4D_Base<TType>::XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        const CL_Vector4D_Base<TType> &_defVal = CL_Vector4D_Base<TType>())
          {
                    TiXmlElement* XMLTag = CLT_Vector<TType>::XMLLoad(XML_Elem, _name);
                    if (!XMLTag)
                              (*this) = _defVal;

                    return XMLTag;      
          }

template <typename TType>
          TiXmlElement*
                    CL_Vector4D_Base<TType>::XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        TType _defVal = 0)
          {
                    return CLT_Vector<TType>::XMLLoad(XML_Elem, _name, _defVal);
          }



template <typename TType>
          TiXmlElement* 
                    CL_Vector4D_Base<TType>::XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        std::string  _type, 
                                        const CL_Vector4D_Base<TType> &_defVal = CL_Vector4D_Base<TType>())
          {
                    TiXmlElement* XMLTag = CLT_Vector<TType>::XMLLoad(XML_Elem, _name, _type);
                    if (!XMLTag)
                              (*this) = _defVal;

                    return XMLTag;      
          }

          
template <typename TType>
          TiXmlElement* 
                    CL_Vector4D_Base<TType>::XMLLoad(TiXmlElement* XML_Elem, 
                                        const std::string _name, 
                                        std::string  _type, 
                                        TType _defVal = 0)
          {
                    return CLT_Vector<TType>::XMLLoad(XML_Elem, _name, _type, _defVal);
          }
#endif
//============================================================================
//CL_Vector4D_Base END================================================================
//============================================================================




template <typename TType> class CL_Color4 : public CL_Vector4D_Base<TType>
{
public :  
          TType &r; 
          TType &g; 
          TType &b; 
          TType &a; 

          
          _SG_TLS_INLINE
                    CL_Color4()
                              :CL_Vector4D_Base<TType>(), 
                              r(CL_Vector4D_Base<TType>::vec[0]), 
                              g(CL_Vector4D_Base<TType>::vec[1]),
                              b(CL_Vector4D_Base<TType>::vec[2]),
                              a(CL_Vector4D_Base<TType>::vec[3])
                              {
                              }

          _SG_TLS_INLINE 
                    CL_Color4(CL_Color4 &_Col)
                              :CL_Vector4D_Base<TType>(_Col),
                              r(CL_Vector4D_Base<TType>::vec[0]), 
                              g(CL_Vector4D_Base<TType>::vec[1]),
                              b(CL_Vector4D_Base<TType>::vec[2]),
                              a(CL_Vector4D_Base<TType>::vec[3])
                              {
                              }

          
          _SG_TLS_INLINE 
                    CL_Color4(const TType _r, const TType _g,const TType  _b, const TType _a)
                              :CL_Vector4D_Base<TType>(), 
                              r(CL_Vector4D_Base<TType>::vec[0]), 
                              g(CL_Vector4D_Base<TType>::vec[1]),
                              b(CL_Vector4D_Base<TType>::vec[2]),
                              a(CL_Vector4D_Base<TType>::vec[3])
                              {
                              Set(_r, _g, _b, _a);
                              }

          _SG_TLS_INLINE 
                    ~CL_Color4()
                    {}

          _SG_TLS_INLINE 
                    void Draw()
                    {
                              glColor4f(r, g, b, a);
                    }

          _SG_TLS_INLINE 
                    CL_Color4<TType> & 
                              operator= (const CL_Vector4D_Base<TType> & _Vec2)
                    {
                              VECTOR_OP_EQUAL(this, _Vec2.vec[i], , GetDim());
                              return (*this);
                    }

          _SG_TLS_INLINE 
                    CL_Color4<TType> & 
                              operator= (const TType * _Val)
                    {
                              return (*this) = CLT_Vector<TType>(4, _Val);
                    }

          _SG_TLS_INLINE 
                    CL_Color4<TType> & 
                              operator= (const TType _Val)
                    {
                              return(*this) = CLT_Vector<TType>(4,_Val);
                    }
};

};//namespace SGE

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

---