geometry.h

Go to the documentation of this file.

 
 
#ifndef ASW_GEOMETRY_H
#define ASW_GEOMETRY_H
 
#include <cmath>
 
namespace asw {
 
template <typename T> class Vec2 {
public:
    Vec2() = default;
 
    Vec2(T x, T y)
        : x(x)
        , y(y)
    {
    }
 
    T angle(const Vec2& other) const
    {
        return std::atan2(y - other.y, x - other.x);
    }
 
    T angle() const
    {
        if (x == 0 && y == 0) {
            return 0;
        }
        return std::atan2(y, x);
    }
 
    T distance(const Vec2& other) const
    {
        return std::hypot(x - other.x, y - other.y);
    }
 
    T dot(const Vec2& other) const
    {
        return (x * other.x) + (y * other.y);
    }
 
    T cross(const Vec2& other) const
    {
        return (x * other.y) - (y * other.x);
    }
 
    T magnitude() const
    {
        return std::sqrt((x * x) + (y * y));
    }
 
    Vec2 operator+(const Vec2& other) const
    {
        return Vec2(x + other.x, y + other.y);
    }
 
    Vec2 operator-(const Vec2& other) const
    {
        return Vec2(x - other.x, y - other.y);
    }
 
    Vec2 operator*(const T scalar) const
    {
        return Vec2(x * scalar, y * scalar);
    }
 
    Vec2 operator/(const T scalar) const
    {
        return Vec2(x / scalar, y / scalar);
    }
 
    Vec2 operator%(const T scalar) const
    {
        return Vec2(x % scalar, y % scalar);
    }
 
    Vec2& operator+=(const Vec2& other)
    {
        x += other.x;
        y += other.y;
        return *this;
    }
 
    Vec2& operator-=(const Vec2& other)
    {
        x -= other.x;
        y -= other.y;
        return *this;
    }
 
    Vec2& operator*=(const T scalar)
    {
        x *= scalar;
        y *= scalar;
        return *this;
    }
 
    Vec2& operator/=(const T scalar)
    {
        x /= scalar;
        y /= scalar;
        return *this;
    }
 
    Vec2& operator%=(const T scalar)
    {
        x %= scalar;
        y %= scalar;
        return *this;
    }
 
    bool operator==(const Vec2& other) const = default;
 
    T x { 0 };
 
    T y { 0 };
};
 
template <typename T> class Vec3 {
public:
    Vec3() = default;
 
    Vec3(T x, T y, T z)
        : x(x)
        , y(y)
        , z(z)
    {
    }
 
    T angle(const Vec3& other) const
    {
        T dot_product = dot(other);
        T magnitudes = magnitude() * other.magnitude();
        return std::acos(dot_product / magnitudes);
    }
 
    T distance(const Vec3& other) const
    {
        return std::sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y)
            + (z - other.z) * (z - other.z));
    }
 
    T dot(const Vec3& other) const
    {
        return (x * other.x) + (y * other.y) + (z * other.z);
    }
 
    Vec3 cross(const Vec3& other) const
    {
        return Vec3((y * other.z) - (z * other.y), (z * other.x) - (x * other.z),
            (x * other.y) - (y * other.x));
    }
 
    T magnitude() const
    {
        return std::sqrt((x * x) + (y * y) + (z * z));
    }
 
    Vec3 operator+(const Vec3& other) const
    {
        return Vec3(x + other.x, y + other.y, z + other.z);
    }
 
    Vec3 operator-(const Vec3& other) const
    {
        return Vec3(x - other.x, y - other.y, z - other.z);
    }
 
    Vec3 operator*(const T scalar) const
    {
        return Vec3(x * scalar, y * scalar, z * scalar);
    }
 
    Vec3 operator/(const T scalar) const
    {
        return Vec3(x / scalar, y / scalar, z / scalar);
    }
 
    Vec3 operator%(const T scalar) const
    {
        return Vec3(x % scalar, y % scalar, z % scalar);
    }
 
    Vec3& operator+=(const Vec3& other)
    {
        x += other.x;
        y += other.y;
        z += other.z;
        return *this;
    }
 
    Vec3& operator-=(const Vec3& other)
    {
        x -= other.x;
        y -= other.y;
        z -= other.z;
        return *this;
    }
 
    Vec3& operator*=(const T scalar)
    {
        x *= scalar;
        y *= scalar;
        z *= scalar;
        return *this;
    }
 
    Vec3& operator/=(const T scalar)
    {
        x /= scalar;
        y /= scalar;
        z /= scalar;
        return *this;
    }
 
    Vec3& operator%=(const T scalar)
    {
        x %= scalar;
        y %= scalar;
        z %= scalar;
        return *this;
    }
 
    bool operator==(const Vec3& other) const = default;
 
    T x { 0 };
 
    T y { 0 };
 
    T z { 0 };
};
 
template <typename T> class Quad {
public:
    Quad()
        : position(0, 0)
        , size(0, 0)
    {
    }
 
    Quad(const Vec2<T>& position, const Vec2<T>& size)
        : position(position)
        , size(size)
    {
    }
 
    Quad(T x, T y, T width, T height)
        : position(x, y)
        , size(width, height)
    {
    }
 
    void set_position(T x, T y)
    {
        position = Vec2<T>(x, y);
    }
 
    void set_size(T width, T height)
    {
        size = Vec2<T>(width, height);
    }
 
    Vec2<T> get_center() const
    {
        return Vec2<T>(position.x + (size.x / 2.0F), position.y + (size.y / 2.0F));
    }
 
    bool contains(const Vec2<T>& point) const
    {
        return point.x >= position.x && point.x <= position.x + size.x && point.y >= position.y
            && point.y <= position.y + size.y;
    }
 
    bool contains(T x, T y) const
    {
        return x >= position.x && x <= position.x + size.x && y >= position.y
            && y <= position.y + size.y;
    }
 
    bool collides(const Quad& other) const
    {
        bool is_outside = position.x + size.x <= other.position.x || // a is left of b
            other.position.x + other.size.x <= position.x || // b is left of a
            position.y + size.y <= other.position.y || // a is above b
            other.position.y + other.size.y <= position.y; // b is above a
 
        return !is_outside;
    }
 
    // Collision
    bool collides_bottom(const Quad& other) const
    {
        return position.y < other.position.y + other.size.y
            && position.y + size.y > other.position.y + other.size.y;
    }
 
    bool collides_top(const Quad& other) const
    {
        return position.y + size.y > other.position.y && position.y < other.position.y;
    }
 
    bool collides_left(const Quad& other) const
    {
        return position.x + size.x > other.position.x && position.x < other.position.x;
    }
 
    bool collides_right(const Quad& other) const
    {
        return position.x < other.position.x + other.size.x
            && position.x + size.x > other.position.x + other.size.x;
    }
 
    Quad operator+(const Quad<T>& quad) const
    {
        return Quad(position + quad.position, size + quad.size);
    }
 
    Quad operator-(const Quad<T>& quad) const
    {
        return Quad(position - quad.position, size - quad.size);
    }
 
    Quad operator*(const T scalar) const
    {
        return Quad(position * scalar, size * scalar);
    }
 
    Quad operator/(const T scalar) const
    {
        return Quad(position / scalar, size / scalar);
    }
 
    Vec2<T> position;
 
    Vec2<T> size;
};
 
using Vec2f = Vec2<float>;
using Vec2i = Vec2<int>;
using Vec3f = Vec3<float>;
using Vec3i = Vec3<int>;
using Quadf = Quad<float>;
using Quadi = Quad<int>;
 
} // namespace asw
 
#endif // ASW_GEOMETRY_H