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() : x(0), y(0) {}
 
    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::hypotf(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 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;
    }
 
    bool operator==(const Vec2& other) const {
      return x == other.x && y == other.y;
    }
 
    bool operator!=(const Vec2& other) const {
      return x != other.x || y != other.y;
    }
 
    T x{0};
 
    T y{0};
  };
 
  template <typename T>
  class Vec3 {
   public:
    Vec3() : x(0), y(0), z(0) {}
 
    Vec3(T x, T y, T z) : x(x), y(y), z(z) {}
 
    T angle(const Vec3& other) const {
      T dotProduct = dot(other);
      T magnitudes = magnitude() * other.magnitude();
      return std::acos(dotProduct / 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 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;
    }
 
    bool operator==(const Vec3& other) const {
      return x == other.x && y == other.y && z == other.z;
    }
 
    bool operator!=(const Vec3& other) const {
      return x != other.x || y != other.y || z != other.z;
    }
 
    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 setPosition(T x, T y) { position = Vec2<T>(x, y); }
 
    void setSize(T width, T height) { size = Vec2<T>(width, height); }
 
    Vec2<T> getCenter() 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 collidesBottom(const Quad& other) const {
      return position.y < other.position.y + other.size.y &&
             position.y + size.y > other.position.y + other.size.y;
    }
 
    bool collidesTop(const Quad& other) const {
      return position.y + size.y > other.position.y &&
             position.y < other.position.y;
    }
 
    bool collidesLeft(const Quad& other) const {
      return position.x + size.x > other.position.x &&
             position.x < other.position.x;
    }
 
    bool collidesRight(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;
  };
 
}  // namespace asw
 
#endif  // ASW_GEOMETRY_H