Vector2.hpp

#ifndef RAYLIB_CPP_INCLUDE_VECTOR2_HPP_
#define RAYLIB_CPP_INCLUDE_VECTOR2_HPP_
 
#ifndef RAYLIB_CPP_NO_MATH
#include <cmath>
#endif
 
#include <string>
 
#include "./raylib.hpp"
#include "./raymath.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./RadiansDegrees.hpp"
 
namespace raylib {
class Vector2 : public ::Vector2 {
 public:
    Vector2(const ::Vector2& vec) : ::Vector2{vec.x, vec.y} {}
 
    Vector2(float x, float y) : ::Vector2{x, y} {}
    Vector2(float x) : ::Vector2{x, 0} {}
    Vector2() : ::Vector2{0, 0} {}
 
    GETTERSETTER(float, X, x)
    GETTERSETTER(float, Y, y)
 
    Vector2& operator=(const ::Vector2& vector2) {
        set(vector2);
        return *this;
    }
 
    bool operator==(const ::Vector2& other) const {
        return x == other.x
            && y == other.y;
    }
 
    bool operator!=(const ::Vector2& other) const {
        return !(*this == other);
    }
 
    std::string ToString() const {
        return TextFormat("Vector2(%f, %f)", x, y);
    }
 
    operator std::string() const {
        return ToString();
    }
 
#ifndef RAYLIB_CPP_NO_MATH
    Vector2 Add(const ::Vector2& vector2) const {
        return Vector2Add(*this, vector2);
    }
 
    Vector2 operator+(const ::Vector2& vector2) const {
        return Vector2Add(*this, vector2);
    }
 
    Vector2& operator+=(const ::Vector2& vector2) {
        set(Vector2Add(*this, vector2));
 
        return *this;
    }
 
    Vector2 Subtract(const ::Vector2& vector2) const {
        return Vector2Subtract(*this, vector2);
    }
 
    Vector2 operator-(const ::Vector2& vector2) const {
        return Vector2Subtract(*this, vector2);
    }
 
    Vector2& operator-=(const ::Vector2& vector2) {
        set(Vector2Subtract(*this, vector2));
 
        return *this;
    }
 
    Vector2 Negate() const {
        return Vector2Negate(*this);
    }
 
    Vector2 operator-() const {
        return Vector2Negate(*this);
    }
 
    Vector2 Multiply(const ::Vector2& vector2) const {
        return Vector2Multiply(*this, vector2);
    }
 
    Vector2 operator*(const ::Vector2& vector2) const {
        return Vector2Multiply(*this, vector2);
    }
 
    Vector2& operator*=(const ::Vector2& vector2) {
        set(Vector2Multiply(*this, vector2));
 
        return *this;
    }
 
    Vector2 Scale(const float scale) const {
        return Vector2Scale(*this, scale);
    }
 
    Vector2 operator*(const float scale) const {
        return Vector2Scale(*this, scale);
    }
 
    Vector2& operator*=(const float scale) {
        set(Vector2Scale(*this, scale));
 
        return *this;
    }
 
    Vector2 Divide(const ::Vector2& vector2) const {
        return Vector2Divide(*this, vector2);
    }
 
    Vector2 operator/(const ::Vector2& vector2) const {
        return Vector2Divide(*this, vector2);
    }
 
    Vector2& operator/=(const ::Vector2& vector2) {
        set(Vector2Divide(*this, vector2));
 
        return *this;
    }
 
    Vector2 Divide(const float div) const {
        return ::Vector2{x / div, y / div};
    }
 
    Vector2 operator/(const float div) const {
        return Divide(div);
    }
 
    Vector2& operator/=(const float div) {
        this->x /= div;
        this->y /= div;
 
        return *this;
    }
 
    Vector2 Normalize() const {
        return Vector2Normalize(*this);
    }
 
    Vector2 Transform(::Matrix mat) const {
        return ::Vector2Transform(*this, mat);
    }
 
    Vector2 Lerp(const ::Vector2& vector2, float amount) const {
        return Vector2Lerp(*this, vector2, amount);
    }
 
    Vector2 Reflect(const ::Vector2& normal) const {
        return Vector2Reflect(*this, normal);
    }
 
    Vector2 Rotate(Radian angle) const {
        return Vector2Rotate(*this, angle);
    }
 
    Vector2 MoveTowards(const ::Vector2& target, float maxDistance) const {
        return Vector2MoveTowards(*this, target, maxDistance);
    }
 
    Vector2 Invert() const {
        return ::Vector2Invert(*this);
    }
 
    Vector2 Clamp(::Vector2 min, ::Vector2 max) const {
        return ::Vector2Clamp(*this, min, max);
    }
 
    Vector2 Clamp(float min, float max) const {
        return ::Vector2ClampValue(*this, min, max);
    }
 
    int Equals(::Vector2 q) const {
        return ::Vector2Equals(*this, q);
    }
 
    float Length() const {
        return Vector2Length(*this);
    }
 
    float LengthSqr() const {
        return Vector2LengthSqr(*this);
    }
 
    float DotProduct(const ::Vector2& vector2) const {
        return Vector2DotProduct(*this, vector2);
    }
 
    float Distance(const ::Vector2& vector2) const {
        return Vector2Distance(*this, vector2);
    }
 
    float DistanceSqr(::Vector2 v2) const {
        return ::Vector2DistanceSqr(*this, v2);
    }
 
    Radian Angle(const ::Vector2& vector2) const {
        return Vector2Angle(*this, vector2);
    }
 
    static Vector2 Zero() {
        return Vector2Zero();
    }
 
    static Vector2 One() {
        return Vector2One();
    }
#endif
 
    void DrawPixel(::Color color = {0, 0, 0, 255}) const {
        ::DrawPixelV(*this, color);
    }
 
    void DrawLine(::Vector2 endPos, ::Color color = {0, 0, 0, 255}) const {
        ::DrawLineV(*this, endPos, color);
    }
 
    void DrawLine(::Vector2 endPos, float thick, ::Color color = {0, 0, 0, 255}) const {
        ::DrawLineEx(*this, endPos, thick, color);
    }
 
    void DrawLineBezier(::Vector2 endPos, float thick, ::Color color = {0, 0, 0, 255}) const {
        ::DrawLineBezier(*this, endPos, thick, color);
    }
 
    void DrawCircle(float radius, ::Color color = {0, 0, 0, 255}) const {
        ::DrawCircleV(*this, radius, color);
    }
 
    void DrawRectangle(::Vector2 size, ::Color color = {0, 0, 0, 255}) const {
        ::DrawRectangleV(*this, size, color);
    }
 
    void DrawPoly(int sides, float radius, Degree rotation, ::Color color = {0, 0, 0, 255}) const {
        ::DrawPoly(*this, sides, radius, rotation, color);
    }
 
    bool CheckCollisionCircle(float radius1, ::Vector2 center2, float radius2) const {
        return ::CheckCollisionCircles(*this, radius1, center2, radius2);
    }
 
    bool CheckCollisionCircle(float radius, ::Rectangle rec) const {
        return ::CheckCollisionCircleRec(*this, radius, rec);
    }
 
    bool CheckCollision(::Rectangle rec) const {
        return ::CheckCollisionPointRec(*this, rec);
    }
 
    bool CheckCollision(::Vector2 center, float radius) const {
        return ::CheckCollisionPointCircle(*this, center, radius);
    }
 
    bool CheckCollision(::Vector2 p1, ::Vector2 p2, ::Vector2 p3) const {
        return ::CheckCollisionPointTriangle(*this, p1, p2, p3);
    }
 
    bool CheckCollisionLines(
            ::Vector2 endPos1,
            ::Vector2 startPos2, ::Vector2 endPos2,
            ::Vector2 *collisionPoint) const {
        return ::CheckCollisionLines(*this, endPos1, startPos2, endPos2, collisionPoint);
    }
 
    bool CheckCollisionPointLine(::Vector2 p1, ::Vector2 p2, int threshold = 1) const {
        return ::CheckCollisionPointLine(*this, p1, p2, threshold);
    }
 
 protected:
    void set(const ::Vector2& vec) {
        x = vec.x;
        y = vec.y;
    }
};
 
}  // namespace raylib
 
using RVector2 = raylib::Vector2;
 
#endif  // RAYLIB_CPP_INCLUDE_VECTOR2_HPP_