vector2D.h

Go to the documentation of this file.

#ifndef UGDK_MATH_VECTOR2D_H_
#define UGDK_MATH_VECTOR2D_H_

#include <ugdk/structure/types.h>
#include <ugdk/math.h>
#include <array>
#include <tuple>

#ifdef SWIG
#pragma SWIG nowarn=312
#endif

namespace ugdk {
namespace math {

// 2 dimension vectors, using doubles.
class Vector2D {
  public:

    Vector2D() : x(0.0), y(0.0) {}


    explicit Vector2D(double value) : x(value), y(value) {}


    Vector2D(double _x, double _y) : x(_x), y(_y) {}

    Vector2D(const math::Integer2D& int2d);

    ~Vector2D() { }

    // Fields are accessible as x/y or val[0] and val[1].
    union {
        struct { double x, y;   };
        struct { double val[2]; };
    };

    double get_x() const { return x; }
    double get_y() const { return y; }
    void set_x(double x_) { x = x_; }
    void set_y(double y_) { y = y_; }



    double NormOne() const;


    double Length() const;
    

    double LengthSquared() const { return (x*x) + (y*y); }


    double Angle() const;


    Vector2D Normalize() const;


    Vector2D Rotate(double angle) const;
    

    void Mirror(const ugdk::enums::mirroraxis::MirrorAxis axis);
    

    Vector2D Mirrored(const ugdk::enums::mirroraxis::MirrorAxis axis) const;


    Vector2D Scale(const Vector2D& scale) const;


    void Divide(const Vector2D& divider);


    Vector2D Divided(const Vector2D& divider) const;

    // Static methods


    static Vector2D Add(const Vector2D& a, const Vector2D& b) {
        return Vector2D(a.x + b.x, a.y + b.y);
    }
    

    static Vector2D Subtract(const Vector2D& a, const Vector2D& b) {
        return Vector2D(a.x - b.x, a.y - b.y);
    }
    

    static Vector2D Multiply(const Vector2D& a, double scalar) {
        return Vector2D(a.x * scalar, a.y * scalar);
    }
    

    static double InnerProduct(const Vector2D& a, const Vector2D& b) {
        return (a.x * b.x) + (a.y * b.y);
    }


    double length() const { return Length(); }
    

    double angle() const { return Angle(); }


    static Vector2D Normalized(Vector2D& a) { return a.Normalize(); }


    static Vector2D Rotate(Vector2D& a, double angle) {
        return a.Rotate(angle);
    }



    bool operator==(const Vector2D& rhs) {
        return x==rhs.x && y==rhs.y;
    }

    // TODO document and revise
    Vector2D& operator+=(const Vector2D &other);
    
    // TODO document and revise
    Vector2D& operator-=(const Vector2D &other);
    
    // TODO document
    Vector2D& operator*=(double other);
    

    Vector2D operator+(const Vector2D& right) const;


    // TODO revise
    Vector2D operator-() const;


    Vector2D operator-(const Vector2D& right) const;



    Vector2D operator*(double scalar) const;


    Vector2D operator/(double scalar) const;


    double    operator*(const Vector2D &right) const;

    operator std::array<double, 2> () const {
        std::array<double, 2> result {{ x,y }};
        return result;
    }

    operator std::pair<double, double> () const {
        return std::make_pair(x, y);
    }
};


Vector2D operator*(double scalar, const Vector2D &right);

}  // namespace math
}  // namespace ugdk

#endif  // UGDK_MATH_VECTOR2D_H_