src/ugdk/math/vector2D.h

Go to the documentation of this file.

#ifndef UGDK_MATH_VECTOR2D_H_
#define UGDK_MATH_VECTOR2D_H_

#include <ugdk/base/types.h>

#ifdef SWIG
#pragma SWIG nowarn=312
#endif

namespace ugdk {

namespace math {
class Integer2D;
} // 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 ugdk::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(const 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;

    // 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, const 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);
    

    Vector2D operator+(const Vector2D &right) const;


    // TODO revise
    Vector2D operator-() const;


    Vector2D operator-(const Vector2D &right) const;



    Vector2D operator*(const double   &scalar) const;


    Vector2D operator/(const double   &scalar) const;


    double    operator*(const Vector2D &right) const;
};


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

}  // namespace ugdk

#endif  // UGDK_MATH_VECTOR2D_H_