D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spTransformation2D.hpp

Go to the documentation of this file.

/*
 * Transformation 2D header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SCENE_TRANSFORMATION_2D_H__
#define __SP_SCENE_TRANSFORMATION_2D_H__


#include "Base/spStandard.hpp"
#include "Base/spDimensionPoint2D.hpp"
#include "Base/spDimensionSize2D.hpp"
#include "Base/spDimensionMatrix4.hpp"


namespace sp
{
namespace scene
{


template <typename T> class Transformation2D
{
    
    public:
        
        Transformation2D() :
            Rotation_   (T(0)),
            Scale_      (T(1)),
            HasChanged_ (true)
        {
        }
        Transformation2D(const dim::matrix4<T> &Matrix) :
            Position_   (Matrix.getPosition()   ),
            Rotation_   (Matrix.getRotation().Z ),
            Scale_      (Matrix.getScale()      ),
            Matrix_     (Matrix                 ),
            HasChanged_ (false                  )
        {
        }
        Transformation2D(
            const dim::point2d<T> &Position, const T &Rotation, const dim::size2d<T> &Scale) :
            Position_   (Position   ),
            Rotation_   (Rotation   ),
            Scale_      (Scale      ),
            HasChanged_ (true       )
        {
        }
        Transformation2D(const Transformation2D<T> &Other) :
            Position_   (Other.Position_    ),
            Rotation_   (Other.Rotation_    ),
            Scale_      (Other.Scale_       ),
            Matrix_     (Other.Matrix_      ),
            HasChanged_ (Other.HasChanged_  )
        {
        }
        ~Transformation2D()
        {
        }
        
        /* === Operators === */
        
        Transformation2D<T>& operator = (const Transformation2D<T> &Other)
        {
            Position_   = Other.Position_;
            Rotation_   = Other.Rotation_;
            Scale_      = Other.Scale_;
            Matrix_     = Other.Matrix_;
            HasChanged_ = Other.HasChanged_;
            return *this;
        }
        
        Transformation2D<T>& operator *= (const Transformation2D<T> &Other)
        {
            operator = (getMatrix() * Other.getMatrix());
            return *this;
        }
        
        Transformation2D<T> operator * (const Transformation2D<T> &Other) const
        {
            Transformation2D<T> Temp(*this);
            Temp *= Other;
            return Temp;
        }
        
        /* === Functions === */
        
        dim::matrix4<T> getMatrix() const
        {
            if (HasChanged_)
            {
                Matrix_.reset(dim::vector3d<T>(Position_.X, Position_.Y, T(0)));
                Matrix_.rotateZ(Rotation_);
                Matrix_.scale(dim::vector3d<T>(Scale_.Width, Scale_.Height, T(1)));
                HasChanged_ = false;
            }
            return Matrix_;
        }
        
        Transformation2D<T> getInverse() const
        {
            dim::matrix4<T> Mat;
            getMatrix(Mat);
            Mat.setInverse();
            return Transformation2D<T>(Mat);
        }
        
        void interpolate(const Transformation2D<T> &From, const Transformation2D<T> &To, const T &Interpolation)
        {
            math::Lerp(Position_,   From.Position_, To.Position_,   Interpolation);
            math::Lerp(Rotation_,   From.Rotation_, To.Rotation_,   Interpolation);
            math::Lerp(Scale_,      From.Scale_,    To.Scale_,      Interpolation);
            HasChanged_ = true;
        }
        
        void move(const dim::point2d<T> &Direction)
        {
            Position_ += (getRotationMatrix() * Direction);
            HasChanged_ = true;
        }
        void turn(const T &Rotation)
        {
            Rotation_ += Rotation;
            HasChanged_ = true;
        }
        
        /* === Inline functions === */
        
        inline void setPosition(const dim::point2d<T> &Position)
        {
            Position_ = Position;
            HasChanged_ = true;
        }
        inline dim::point2d<T> getPosition() const
        {
            return Position_;
        }
        
        inline void setRotation(const T &Rotation)
        {
            Rotation_ = Rotation;
            HasChanged_ = true;
        }
        inline T getRotation() const
        {
            return Rotation_;
        }
        inline dim::matrix4<T> getRotationMatrix() const
        {
            dim::matrix4<T> Mat;
            Mat.rotateZ(Rotation_);
            return Mat;
        }
        
        inline void setScale(const dim::size2d<T> &Scale)
        {
            Scale_ = Scale;
            HasChanged_ = true;
        }
        inline dim::size2d<T> getScale() const
        {
            return Scale_;
        }
        
        inline void translate(const dim::point2d<T> &Direction)
        {
            Position_ += Direction;
            HasChanged_ = true;
        }
        inline void transform(const dim::size2d<T> &Size)
        {
            Scale_ += Size;
            HasChanged_ = true;
        }
        
        inline void getMatrix(dim::matrix4<T> &Matrix) const
        {
            Matrix *= getMatrix();
        }
        
        inline dim::matrix4<T> getInverseMatrix() const
        {
            return getMatrix().getInverse();
        }
        
        inline void setMatrixDirect(const dim::matrix4<T> &Matrix)
        {
            Matrix_ = Matrix;
        }
        inline dim::matrix4<T>& getMatrixDirect()
        {
            return Matrix_;
        }
        inline dim::matrix4<T> getMatrixDirect() const
        {
            return Matrix_;
        }
        
    private:
        
        /* === Members === */
        
        dim::point2d<T> Position_;
        T Rotation_;
        dim::size2d<T> Scale_;
        
        mutable dim::matrix4<T> Matrix_;
        mutable bool HasChanged_;
        
};


typedef Transformation2D<f32> ScreenSpaceTransformation;


} // /namespace scene

} // /namespace sp


#endif



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