Transformations.hpp

#ifndef TRANSFORMATIONS_HPP
#define TRANSFORMATIONS_HPP

#include <vector>

#include <steeriously/Matrix.hpp>
#include <steeriously/Vector2.hpp>
#include <steeriously/VectorMath.hpp>

namespace steer //steeriously namepsace
{

    inline std::vector<steer::Vector2> WorldTransform(std::vector<steer::Vector2> &points,
                                                const steer::Vector2   &pos,
                                                const steer::Vector2   &forward,
                                                const steer::Vector2   &side,
                                                const steer::Vector2   &scale)
    {
        //copy the original vertices into the buffer about to be transformed
        std::vector<steer::Vector2> TranVector2Ds = points;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        //scale
        if ( (scale.x != 1.0) || (scale.y != 1.0) )
        {
            matTransform.Scale(scale.x, scale.y);
        }

        //rotate
        matTransform.Rotate(forward, side);

        //and translate
        matTransform.Translate(pos.x, pos.y);

        //now transform the object's vertices
        matTransform.TransformVector2Ds(TranVector2Ds);

        return TranVector2Ds;
    }

    inline std::vector<steer::Vector2> WorldTransform(std::vector<steer::Vector2> &points,
                                     const steer::Vector2   &pos,
                                     const steer::Vector2   &forward,
                                     const steer::Vector2   &side)
    {
        //copy the original vertices into the buffer about to be transformed
        std::vector<steer::Vector2> TranVector2Ds = points;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        //rotate
        matTransform.Rotate(forward, side);

        //and translate
        matTransform.Translate(pos.x, pos.y);

        //now transform the object's vertices
        matTransform.TransformVector2Ds(TranVector2Ds);

        return TranVector2Ds;
    }

    inline steer::Vector2 PointToWorldSpace(const steer::Vector2 &point,
                                        const steer::Vector2 &AgentHeading,
                                        const steer::Vector2 &AgentSide,
                                        const steer::Vector2 &AgentPosition)
    {
        //make a copy of the point
        steer::Vector2 TransPoint = point;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        //rotate
        matTransform.Rotate(AgentHeading, AgentSide);

        //and translate
        matTransform.Translate(AgentPosition.x, AgentPosition.y);

        //now transform the vertices
        matTransform.TransformVector2Ds(TransPoint);

        return TransPoint;
    }

    inline steer::Vector2 VectorToWorldSpace(const steer::Vector2 &vec,
                                         const steer::Vector2 &AgentHeading,
                                         const steer::Vector2 &AgentSide)
    {
        //make a copy of the point
        steer::Vector2 TransVec = vec;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        //rotate
        matTransform.Rotate(AgentHeading, AgentSide);

        //now transform the vertices
        matTransform.TransformVector2Ds(TransVec);

        return TransVec;
    }

    inline steer::Vector2 PointToLocalSpace(const steer::Vector2 &point,
                                 const steer::Vector2 &AgentHeading,
                                 const steer::Vector2 &AgentSide,
                                 const steer::Vector2 &AgentPosition)
    {

        //make a copy of the point
        steer::Vector2 TransPoint = point;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        float Tx = steer::VectorMath::dotProduct(AgentPosition.GetReverse(), AgentHeading);
        float Ty = steer::VectorMath::dotProduct(AgentPosition.GetReverse(), AgentSide);

        //create the transformation matrix
        matTransform._11(AgentHeading.x); matTransform._12(AgentSide.x);
        matTransform._21(AgentHeading.y); matTransform._22(AgentSide.y);
        matTransform._31(Tx);           matTransform._32(Ty);

        //now transform the vertices
        matTransform.TransformVector2Ds(TransPoint);

        return TransPoint;
    }

    inline steer::Vector2 VectorToLocalSpace(const steer::Vector2 &vec,
                                 const steer::Vector2 &AgentHeading,
                                 const steer::Vector2 &AgentSide)
    {

        //make a copy of the point
        steer::Vector2 TransPoint = vec;

        //create a transformation matrix
        steer::Matrix2D matTransform;

        //create the transformation matrix
        matTransform._11(AgentHeading.x); matTransform._12(AgentSide.x);
        matTransform._21(AgentHeading.y); matTransform._22(AgentSide.y);

        //now transform the vertices
        matTransform.TransformVector2Ds(TransPoint);

        return TransPoint;
    }

    inline void Vec2DRotateAroundOrigin(steer::Vector2& v, float ang)
    {
        //create a transformation matrix
        steer::Matrix2D mat;

        //rotate
        mat.Rotate(ang);

        //now transform the object's vertices
        mat.TransformVector2Ds(v);
    }

    inline std::vector<steer::Vector2> CreateWhiskers(unsigned int  NumWhiskers,
                                                float               WhiskerLength,
                                                float               fov,
                                                steer::Vector2      facing,
                                                steer::Vector2      origin)
    {
        //this is the magnitude of the angle separating each whisker
        float SectorSize = fov/(float)(NumWhiskers-1);

        std::vector<steer::Vector2> whiskers;
        steer::Vector2 temp;
        float angle = -fov*0.5;

        for (unsigned int w=0; w<NumWhiskers; ++w)
        {
            //create the whisker extending outwards at this angle
            temp = facing;
            Vec2DRotateAroundOrigin(temp, angle);
            whiskers.push_back(origin + WhiskerLength * temp);

            angle+=SectorSize;
        }

        return whiskers;
    }

} //namespace steeriously

#endif //TRANSFORMATIONS_HPP