vec2.hpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef VEC2_HPP
#define VEC2_HPP

#include <cmath>

namespace renderstack {

class vec2
{
public:
    vec2(float _x = 0, float _y = 0)
    :   x(_x)
    ,   y(_y)
    {
    }

    vec2 operator+(vec2 const &v) const 
    {
        return vec2(x + v.x, y + v.y);
    }

    vec2 &operator+=(vec2 const &v)
    {
        x += v.x;
        y += v.y;
        return *this;
    }

    vec2 operator-(vec2 const &v) const
    {
        return vec2(x - v.x, y - v.y);
    }

    vec2 &operator-=(vec2 const &v) 
    {
        x -= v.x;
        y -= v.y;
        return *this;
    }

    bool operator==(vec2 const &v) const
    {
        return 
            (x == v.x) && 
            (y == v.y);
    }
    vec2 operator*(float f) const
    {
        return vec2(f * x, f * y);
    }

    vec2 &operator*=(float f) 
    {
        x *= f;
        y *= f;
        return *this;
    }

    vec2 operator/(float f) const
    {
        float inv = 1.0f / f;
        return vec2(x * inv, y * inv);
    }

    vec2 &operator/=(float f)
    {
        float inv = 1.f / f;
        x *= inv; 
        y *= inv; 
        return *this;
    }

    vec2 operator-() const 
    {
        return vec2(-x, -y);
    }

    float operator[](int i) const 
    {
        return (&x)[i];
    }

    float &operator[](int i)
    {
        return (&x)[i];
    }

    float length_squared() const { return x * x + y * y; }
    float length() const { return std::sqrt(length_squared()); }

    float x;
    float y;
};

inline float dot(vec2 const &v1, vec2 const &v2)
{
    return v1.x * v2.x + v1.y * v2.y;
}

inline vec2 normalize(vec2 const &v)
{
    return v / v.length();
}

}

#endif