D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_pos.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_SG_TLS_cl_pos.h
 * \brief Class to manage position/rotation/scale of template vectors.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_CL_POS_H
#define SG_TLS_CL_POS_H


#include "SugoiTools\xml.h"
#include "SugoiTools\cl_vector2.h"
#include "SugoiTools\cl_vector3.h"
#include "SugoiTools\cl_vector4.h"


#include <gl\glut.h>          
#include <gl\gl.h>                      // Header File For The OpenGL32 Library
#pragma comment(lib ,"glut32.lib")
#pragma comment(lib ,"opengl32.lib")

namespace SGE{
//OpenGL functions
_SG_TLS_EXPORT _SG_TLS_INLINE void glTranslate (const CL_Vector2Df &_Vec);
_SG_TLS_EXPORT _SG_TLS_INLINE void glRotate       (const CL_Vector2Df &_Vec);
_SG_TLS_EXPORT _SG_TLS_INLINE void glScale        (const CL_Vector2Df &_Vec);

_SG_TLS_EXPORT _SG_TLS_INLINE void glTranslate(const CL_Vector3Df &_Vec);
_SG_TLS_EXPORT _SG_TLS_INLINE void glRotate       (const CL_Vector3Df &_Vec);
_SG_TLS_EXPORT _SG_TLS_INLINE void glScale        (const CL_Vector3Df &_Vec);
_SG_TLS_EXPORT _SG_TLS_INLINE void glVertex       (const CL_Vector3Df &_Vec);

//_SG_TLS_INLINE 
_SG_TLS_EXPORT _SG_TLS_INLINE void glScissor(const CL_Vector2Di &_Pos, const CL_Vector2Di &_Size);
//
_SG_TLS_EXPORT _SG_TLS_INLINE void glViewport(const CL_Vector2Di &_Pos, const CL_Vector2Di &_Size);

//===============================



template <class VectorType> class  CLT_POS
          :public CL_XML_OBJ
{
public:
          VectorType Pos;               
          VectorType Rot;               
          VectorType Scale;   

          _SG_TLS_INLINE 
                    CLT_POS()
                              :CL_XML_OBJ("pos")
                    {
                              Clear();
                    }

          _SG_TLS_INLINE CLT_POS(CLT_POS & _Pos)
                    :CL_XML_OBJ("pos")
                    {
                              this->Pos = _Pos.Pos;
                              this->Rot = _Pos.Rot;
                              this->Scale = _Pos.Scale;
                    };

          _SG_TLS_INLINE 
                    ~CLT_POS()
                    {}
          
          
          _SG_TLS_INLINE 
                    void Clear()
                    {
                              Scale = 1;
                              Pos.Clear();
                              Rot.Clear();
                    }

          //transformations ======================

          _SG_TLS_INLINE 
                    void DoTranslate()
                    {glTranslate(Pos);}

          _SG_TLS_INLINE void DoRotate()
                    {glRotate(Rot);}

          _SG_TLS_INLINE void DoScale()
                    {glScale(Scale);}

          _SG_TLS_INLINE void SetScale(VectorType _v)
                    {Scale = _v;}
          _SG_TLS_INLINE void SetRot(VectorType _v)
                    {Rot = _v;}
          _SG_TLS_INLINE void SetPos(VectorType _v)
                    {Pos = _v;}
          //=============================

#if _SG_TLS_XML

          _SG_TLS_INLINE 
                    TiXmlElement* 
                    XMLLoad(TiXmlElement* XML_ROOT)
                    {
                              TiXmlElement* XML_Elm = CL_XML_OBJ::XMLLoad(XML_ROOT);
                              Clear();//Init all positions values to default
                              Pos.XMLLoad                   (XML_Elm, "pos");
                              Rot.XMLLoad                   (XML_Elm, "rot");
                              Scale.XMLLoad       (XML_Elm, "scale", 1);
                              return XML_Elm;
                    }

          _SG_TLS_INLINE 
                    TiXmlElement*
                    XMLSave(TiXmlElement* XML_ROOT)
                    {
                              TiXmlElement* XML_Elm = CL_XML_OBJ::XMLSave(XML_ROOT);
                              SG_Assert(XML_ROOT, "CLT_POS::XMLSave() => XML root element empty");
                              Pos.XMLSave                   (XML_Elm, "pos");
                              Rot.XMLSave                   (XML_Elm, "rot");
                              Scale.XMLSave       (XML_Elm, "scale", 1);
                              return XML_Elm;
                    }
#endif

          _SG_TLS_INLINE CLT_POS &operator=	(const CLT_POS &_Pos)
                    {
                              this->Pos = _Pos.Pos;
                              this->Rot = _Pos.Rot;
                              this->Scale = _Pos.Scale;
                              return (*this);
                    }

          _SG_TLS_INLINE bool operator==	(const CLT_POS &_Pos)
                    {
                              if (!(this->Pos == _Pos.Pos))
                                        return false;
                              if (!(this->Rot == _Pos.Rot))
                                        return false;
                              if (!(this->Scale == _Pos.Scale))
                                        return false;
                              return true;
                    }
private:
};



class _SG_TLS_EXPORT CL_VERTEX
{
public:
          CL_Color4f          Color;
          CL_Vector2Df TexCoord;
          CL_Vector3Df Pos;

          CL_VERTEX();
          ~CL_VERTEX();
          void Draw(bool _textured, bool _colored = true);  
#if _SG_TLS_XML
          _SG_TLS_INLINE TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT);
          _SG_TLS_INLINE TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT);
#endif
};


#define CL_POS3Df CLT_POS<CL_Vector3Df> 
#define CL_POS2Df CLT_POS<CL_Vector2Df> 


};//namespace SGE
#endif //SG_TLS_CL_POS_H

---