---

---

AI_TVector2.h

Go to the documentation of this file.

#ifndef AI__VECTOR2_H
#define AI__VECTOR2_H
//------------------------------------------------------------------------------
#include "AI_Math.h"
#include <float.h>

class AI_TVector2 {
public:
    AI_TVector2();
    AI_TVector2(const float _x, const float _y);
    AI_TVector2(const AI_TVector2& vec);
    AI_TVector2(const float* p);
    void set(const float _x, const float _y);
    void set(const AI_TVector2& vec);
    void set(const float* p);
    float len() const;
    void norm();
    void operator+=(const AI_TVector2& v0);
    void operator-=(const AI_TVector2& v0);
    void operator*=(const float s);
    void operator/=(const float s);
    bool isequal(const AI_TVector2& v, const float tol) const;
    int compare(const AI_TVector2& v, float tol) const;
    void rotate(float angle);
    void lerp(const AI_TVector2& v0, float lerpVal);
    void lerp(const AI_TVector2& v0, const AI_TVector2& v1, float lerpVal);
    float dot(const AI_TVector2& v0) const;

    float x, y;
};

//------------------------------------------------------------------------------
inline
AI_TVector2::AI_TVector2() :
    x(0.0f),
    y(0.0f)
{
    // empty
}

//------------------------------------------------------------------------------
inline
AI_TVector2::AI_TVector2(const float _x, const float _y) :
    x(_x),
    y(_y)
{
    // empty
}

//------------------------------------------------------------------------------
inline
AI_TVector2::AI_TVector2(const AI_TVector2& vec) :
    x(vec.x),
    y(vec.y)
{
    // empty
}

//------------------------------------------------------------------------------
inline
AI_TVector2::AI_TVector2(const float* p) :
    x(p[0]),
    y(p[1])
{
    // empty
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::set(const float _x, const float _y)
{
    x = _x;
    y = _y;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::set(const AI_TVector2& v)
{
    x = v.x;
    y = v.y;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::set(const float* p)
{
    x = p[0];
    y = p[1];
}

//------------------------------------------------------------------------------
inline
float
AI_TVector2::len() const
{
    return (float) sqrt(x * x + y * y);
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::norm()
{
    float l = len();
    if (l > AI_TINY)
    {
        x /= l;
        y /= l;
    }
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::operator +=(const AI_TVector2& v0)
{
    x += v0.x;
    y += v0.y;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::operator -=(const AI_TVector2& v0)
{
    x -= v0.x;
    y -= v0.y;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::operator *=(const float s)
{
    x *= s;
    y *= s;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::operator /=(const float s)
{
    x /= s;
    y /= s;
}

//------------------------------------------------------------------------------
inline
bool
AI_TVector2::isequal(const AI_TVector2& v, const float tol) const
{
    if (fabs(v.x - x) > tol)      return false;
    else if (fabs(v.y - y) > tol) return false;
    return true;
}

//------------------------------------------------------------------------------
inline
int
AI_TVector2::compare(const AI_TVector2& v, float tol) const
{
    if (fabs(v.x - x) > tol)      return (v.x > x) ? +1 : -1;
    else if (fabs(v.y - y) > tol) return (v.y > y) ? +1 : -1;
    else                          return 0;
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::rotate(float angle)
{
    // rotates this one around P(0,0).
    float sa, ca;

    sa = (float) sin(angle);
    ca = (float) cos(angle);

    // "handmade" multiplication
    AI_TVector2 help(ca * this->x - sa * this->y,
                  sa * this->x + ca * this->y);

    *this = help;
}

//------------------------------------------------------------------------------
static
inline
AI_TVector2 operator +(const AI_TVector2& v0, const AI_TVector2& v1)
{
    return AI_TVector2(v0.x + v1.x, v0.y + v1.y);
}

//------------------------------------------------------------------------------
static
inline
AI_TVector2 operator -(const AI_TVector2& v0, const AI_TVector2& v1)
{
    return AI_TVector2(v0.x - v1.x, v0.y - v1.y);
}

//------------------------------------------------------------------------------
static
inline
float operator %(const AI_TVector2& v0, const AI_TVector2& v1)
{
    return v0.x * v1.x + v0.y * v1.y;
}


//------------------------------------------------------------------------------
static
inline
AI_TVector2 operator *(const AI_TVector2& v0, const float s)
{
    return AI_TVector2(v0.x * s, v0.y * s);
}

//------------------------------------------------------------------------------
static
inline
AI_TVector2 operator -(const AI_TVector2& v)
{
    return AI_TVector2(-v.x, -v.y);
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::lerp(const AI_TVector2& v0, float lerpVal)
{
    x = v0.x + ((x - v0.x) * lerpVal);
    y = v0.y + ((y - v0.y) * lerpVal);
}

//------------------------------------------------------------------------------
inline
void
AI_TVector2::lerp(const AI_TVector2& v0, const AI_TVector2& v1, float lerpVal)
{
    x = v0.x + ((v1.x - v0.x) * lerpVal);
    y = v0.y + ((v1.y - v0.y) * lerpVal);
}

//------------------------------------------------------------------------------
inline
float
AI_TVector2::dot(const AI_TVector2& v0) const
{
    return ( x * v0.x + y * v0.y );
}

//------------------------------------------------------------------------------
#endif

---

InExIn pages are hosted by
InExIn documentation generated by doxygen at Tue Dec 18 12:55:28 2007