src/Transform.h

#ifndef TRANSFORM_H_INCLUDED
#define TRANSFORM_H_INCLUDED

#include "CGLA/Vec3f.h"
#include "CGLA/Vec4f.h"
#include "CGLA/Mat3x3f.h"
#include "CGLA/Mat4x4f.h"
#include "Object.h"

#include <vector>

class GameObject;

using namespace CGLA;

enum SpaceOfReferenceEnum{
        LOCAL,
        PARENT,
        WORLD
};

//Transform class
/*
* Class responsible for the scene graph hierarchy and for the space transformations,
* A transform must attached to a game object, child can be attached,
* The class provides methods for translation, rotation and scalings as well as accessors
* for world and local transform matrices as well as the inverses and the wiew transformations.
*/

class Transform :public Object{
        public :
                static const RTTI TYPE;
                virtual const RTTI& getType() const{ return TYPE; }

        public: 
                typedef std::vector<Transform*>::const_iterator ChildrenIterator;

    protected:
                GameObject* gameObject;

        Transform * parent;
        std::vector<Transform*> children;
        
        Vec3f position;
                Vec3f worldPosition;
                Vec3f scaling;
                Vec3f worldScaling;
                Vec3f eulerAngles;
                Vec3f worldEulerAngles;

                Mat3x3f rotationMatrix;
                Mat3x3f worldRotationMatrix;
                Mat4x4f transformMatrix;
                Mat4x4f worldTransformMatrix;
        
                bool _hasMoved;

    public:
        Transform();
                ~Transform();
        Transform(Vec3f const& pos);
                Transform(const Transform& transform);
        void setGameObject(GameObject* object);
                GameObject* getGameObject()const;

                //***********TREE STRTURE********//
        void addChild(Transform* child);
                void attachChild(Transform* child);
        void removeChild(Transform* child);
                void removeChild(int index);
                ChildrenIterator getChildrenIteratorBegin()const;
                ChildrenIterator getChildrenIteratorEnd()const;
                int getChildCount()const;
                Transform* getChild(int index);
                int getChildIndex(Transform * child)const;
                Transform* getParent();

                void setParent(Transform* par);

                //*****************MOVEMENT************//
                void setPosition(const Vec3f& pos);
                void setWorldPosition(const Vec3f& pos);
                void setScale(const Vec3f& scal);
                void setWorldScale(const Vec3f& scal);
                void setRotation(const Vec3f& rot);
                        
                void translate(float x, float y, float z);
                void translate(const Vec3f& translation);

                void scale(float x, float y, float z);
                void scale(const Vec3f& scaling);
                void rotate(float rx, float ry, float rz, SpaceOfReferenceEnum reference = PARENT);
                void rotate(const Vec3f& euler_angles, SpaceOfReferenceEnum reference = PARENT);
                void rotate(const Vec3f& axis, float angle);

                void lookAt(const Vec3f& targetPoint);

                
                //***********QUERIES*********//
                Vec3f getPosition()const;
                Vec3f getWorldPosition()const;
                Vec3f getScale()const;
                Vec3f getWorldScale()const;
                Vec3f getRotation()const;

                Vec3f getForward()const;
                Vec3f getUp()const;
                Vec3f getRight()const;

                Mat3x3f getRotationMatrix()const;
                Mat3x3f getWorldRotationMatrix()const;
                Mat4x4f getTransformMatrix()const;
                Mat4x4f getInverseTransformMatrix()const;

                Mat4x4f getWorldTransformMatrix()const;
                Mat4x4f getWorldInverseTransformMatrix()const;

                Mat4x4f getWorldViewMatrix() const;
                Mat4x4f getWorldInverseViewMatrix() const;

                //*****************OPENGL STATE**********//
                void applyTransform()const;
                void applyWorldTransform()const;
                void applyViewTransform()const;
                void applyWorldViewTransform()const;

                void _updateWorldPosition();
                void _updateTransformMatrix();
                void _updateWorldTransformMatrix();
                void _updateWorldRotationMatrix();

        protected:


        private:
                //Serialization
                friend class boost::serialization::access;
                template<class Archive>
                void serialize(Archive& ar, const unsigned int version){
                        // serialize base class information
                        ar & boost::serialization::base_object<Object>(*this);
                        ar & position;
                        ar & scaling;
                        ar & eulerAngles;
                }

};


#endif // TRANSFORM_H_INCLUDED