_math.h

#pragma once
#include "_types.h"
#include <cmath>
 
namespace njin {

inline constexpr f32 pi = 3.14159265358979f;

struct rect {
  vec2 pos{};  
  vec2 size{}; 
};

struct circle {
  vec2 center{};     
  f32 radius = 0.0f; 
};
 
// Phép toán vec2: + - * / theo từng thành phần, * / với một số, đổi dấu,
// += -= *= /=, == và !=. Mô tả trong trang Toán học của wiki.
constexpr vec2 operator+(vec2 a, vec2 b) { return {a.x + b.x, a.y + b.y}; }
constexpr vec2 operator-(vec2 a, vec2 b) { return {a.x - b.x, a.y - b.y}; }
constexpr vec2 operator*(vec2 a, vec2 b) { return {a.x * b.x, a.y * b.y}; }
constexpr vec2 operator/(vec2 a, vec2 b) { return {a.x / b.x, a.y / b.y}; }
constexpr vec2 operator*(vec2 a, f32 s) { return {a.x * s, a.y * s}; }
constexpr vec2 operator*(f32 s, vec2 a) { return {a.x * s, a.y * s}; }
constexpr vec2 operator/(vec2 a, f32 s) { return {a.x / s, a.y / s}; }
constexpr vec2 operator-(vec2 a) { return {-a.x, -a.y}; }
constexpr vec2 &operator+=(vec2 &a, vec2 b) { return a = a + b; }
constexpr vec2 &operator-=(vec2 &a, vec2 b) { return a = a - b; }
constexpr vec2 &operator*=(vec2 &a, f32 s) { return a = a * s; }
constexpr vec2 &operator/=(vec2 &a, f32 s) { return a = a / s; }
constexpr bool operator==(vec2 a, vec2 b) { return a.x == b.x && a.y == b.y; }
constexpr bool operator!=(vec2 a, vec2 b) { return !(a == b); }

constexpr f32 dot(vec2 a, vec2 b) { return a.x * b.x + a.y * b.y; }

constexpr f32 cross(vec2 a, vec2 b) { return a.x * b.y - a.y * b.x; }

constexpr f32 length_sq(vec2 v) { return dot(v, v); }

inline f32 length(vec2 v) { return std::sqrt(length_sq(v)); }

inline f32 distance(vec2 a, vec2 b) { return length(b - a); }

inline vec2 normalize(vec2 v) {
  const f32 len = length(v);
  return len > 0.0f ? v / len : vec2{0.0f, 0.0f};
}

inline vec2 rotate(vec2 v, f32 degrees) {
  const f32 r = degrees * (pi / 180.0f);
  const f32 c = std::cos(r);
  const f32 s = std::sin(r);
  return {v.x * c - v.y * s, v.x * s + v.y * c};
}

inline vec2 from_angle(f32 degrees) { return rotate({1.0f, 0.0f}, degrees); }

inline f32 angle_of(vec2 v) { return std::atan2(v.y, v.x) * (180.0f / pi); }

constexpr vec3 operator+(vec3 a, vec3 b) { return {a.x + b.x, a.y + b.y, a.z + b.z}; }
constexpr vec3 operator-(vec3 a, vec3 b) { return {a.x - b.x, a.y - b.y, a.z - b.z}; }
constexpr vec3 operator*(vec3 a, f32 s) { return {a.x * s, a.y * s, a.z * s}; }
constexpr vec3 operator*(f32 s, vec3 a) { return {a.x * s, a.y * s, a.z * s}; }
constexpr vec3 operator/(vec3 a, f32 s) { return {a.x / s, a.y / s, a.z / s}; }
constexpr vec3 operator-(vec3 a) { return {-a.x, -a.y, -a.z}; }
constexpr vec3 &operator+=(vec3 &a, vec3 b) { return a = a + b; }
constexpr vec3 &operator-=(vec3 &a, vec3 b) { return a = a - b; }
constexpr vec3 &operator*=(vec3 &a, f32 s) { return a = a * s; }
constexpr bool operator==(vec3 a, vec3 b) { return a.x == b.x && a.y == b.y && a.z == b.z; }
constexpr bool operator!=(vec3 a, vec3 b) { return !(a == b); }

constexpr f32 dot(vec3 a, vec3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }

constexpr vec3 cross(vec3 a, vec3 b) {
  return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}

constexpr f32 length_sq(vec3 v) { return dot(v, v); }

inline f32 length(vec3 v) { return std::sqrt(length_sq(v)); }

inline f32 distance(vec3 a, vec3 b) { return length(b - a); }

inline vec3 normalize(vec3 v) {
  const f32 len = length(v);
  return len > 0.0f ? v / len : vec3{0.0f, 0.0f, 0.0f};
}

constexpr vec3 lerp(vec3 a, vec3 b, f32 t) { return a + (b - a) * t; }

constexpr f32 clamp(f32 v, f32 lo, f32 hi) { return v < lo ? lo : (v > hi ? hi : v); }

constexpr vec2 clamp(vec2 v, vec2 lo, vec2 hi) {
  return {clamp(v.x, lo.x, hi.x), clamp(v.y, lo.y, hi.y)};
}

constexpr f32 lerp(f32 a, f32 b, f32 t) { return a + (b - a) * t; }
constexpr vec2 lerp(vec2 a, vec2 b, f32 t) { return a + (b - a) * t; }
constexpr rgba lerp(rgba a, rgba b, f32 t) {
  return {lerp(a.r, b.r, t), lerp(a.g, b.g, t), lerp(a.b, b.b, t),
          lerp(a.a, b.a, t)};
}

constexpr f32 move_toward(f32 from, f32 to, f32 max_step) {
  return to > from ? (from + max_step > to ? to : from + max_step)
                   : (from - max_step < to ? to : from - max_step);
}

inline vec2 move_toward(vec2 from, vec2 to, f32 max_step) {
  const vec2 d = to - from;
  const f32 len = length(d);
  return len <= max_step || len == 0.0f ? to : from + d / len * max_step;
}

constexpr vec2 rect_center(rect r) { return r.pos + r.size * 0.5f; }

constexpr rect rect_from_center(vec2 center, vec2 size) {
  return {center - size * 0.5f, size};
}

namespace colors {
inline constexpr rgba white{1.0f, 1.0f, 1.0f, 1.0f};  
inline constexpr rgba black{0.0f, 0.0f, 0.0f, 1.0f};  
inline constexpr rgba red{0.9f, 0.16f, 0.22f, 1.0f};  
inline constexpr rgba green{0.0f, 0.89f, 0.19f, 1.0f}; 
inline constexpr rgba blue{0.0f, 0.47f, 0.95f, 1.0f}; 
inline constexpr rgba yellow{0.99f, 0.98f, 0.0f, 1.0f}; 
inline constexpr rgba gray{0.51f, 0.51f, 0.51f, 1.0f}; 
inline constexpr rgba transparent{0.0f, 0.0f, 0.0f, 0.0f}; 
} // namespace colors

} // namespace njin