| #pragma once |
| #include <cmath> |
| #include <cstdint> |
| #include <algorithm> |
|
|
| namespace unify { |
|
|
| struct Vec2 { |
| float x = 0, y = 0; |
| constexpr Vec2() = default; |
| constexpr Vec2(float x_, float y_) : x(x_), y(y_) {} |
| Vec2 operator+(Vec2 o) const { return {x + o.x, y + o.y}; } |
| Vec2 operator-(Vec2 o) const { return {x - o.x, y - o.y}; } |
| Vec2 operator-() const { return {-x, -y}; } |
| Vec2 operator*(float s) const { return {x * s, y * s}; } |
| Vec2 operator/(float s) const { return {x / s, y / s}; } |
| Vec2& operator+=(Vec2 o) { x += o.x; y += o.y; return *this; } |
| Vec2& operator-=(Vec2 o) { x -= o.x; y -= o.y; return *this; } |
| Vec2& operator*=(float s) { x *= s; y *= s; return *this; } |
| bool operator==(Vec2 o) const { return x == o.x && y == o.y; } |
| bool operator!=(Vec2 o) const { return !(*this == o); } |
| }; |
| inline Vec2 operator*(float s, Vec2 v) { return {v.x * s, v.y * s}; } |
| inline float dot(Vec2 a, Vec2 b) { return a.x * b.x + a.y * b.y; } |
| inline float cross(Vec2 a, Vec2 b) { return a.x * b.y - a.y * b.x; } |
| inline Vec2 cross(Vec2 a, float s) { return {s * a.y, -s * a.x}; } |
| inline Vec2 cross(float s, Vec2 a) { return {-s * a.y, s * a.x}; } |
| inline float length_sq(Vec2 v) { return dot(v, v); } |
| inline float length(Vec2 v) { return std::sqrt(dot(v, v)); } |
| inline Vec2 perp(Vec2 v) { return {-v.y, v.x}; } |
| inline Vec2 normalize(Vec2 v) { |
| float l = length(v); |
| return l > 1e-12f ? v / l : Vec2{0, 0}; |
| } |
| inline Vec2 vmin(Vec2 a, Vec2 b) { return {std::min(a.x, b.x), std::min(a.y, b.y)}; } |
| inline Vec2 vmax(Vec2 a, Vec2 b) { return {std::max(a.x, b.x), std::max(a.y, b.y)}; } |
| inline bool finite(Vec2 v) { return std::isfinite(v.x) && std::isfinite(v.y); } |
| inline float lerp(float a, float b, float t) { return a + (b - a) * t; } |
| inline Vec2 lerp(Vec2 a, Vec2 b, float t) { return a + (b - a) * t; } |
| inline float clampf(float v, float lo, float hi) { return v < lo ? lo : (v > hi ? hi : v); } |
|
|
| |
| struct Rot { |
| float c = 1, s = 0; |
| Rot() = default; |
| explicit Rot(float angle) : c(std::cos(angle)), s(std::sin(angle)) {} |
| float angle() const { return std::atan2(s, c); } |
| Vec2 apply(Vec2 v) const { return {c * v.x - s * v.y, s * v.x + c * v.y}; } |
| Vec2 apply_inv(Vec2 v) const { return {c * v.x + s * v.y, -s * v.x + c * v.y}; } |
| }; |
|
|
| struct Transform { |
| Vec2 position; |
| float rotation = 0; |
| Vec2 scale{1, 1}; |
| Vec2 apply(Vec2 local) const { |
| Rot r(rotation); |
| return position + r.apply({local.x * scale.x, local.y * scale.y}); |
| } |
| }; |
|
|
| struct AABB { |
| Vec2 min, max; |
| bool overlaps(const AABB& o) const { |
| return !(max.x < o.min.x || o.max.x < min.x || max.y < o.min.y || o.max.y < min.y); |
| } |
| AABB merged(const AABB& o) const { return {vmin(min, o.min), vmax(max, o.max)}; } |
| AABB expanded(float r) const { return {{min.x - r, min.y - r}, {max.x + r, max.y + r}}; } |
| Vec2 center() const { return (min + max) * 0.5f; } |
| Vec2 extent() const { return (max - min) * 0.5f; } |
| }; |
|
|
| struct Color { |
| uint8_t r = 255, g = 255, b = 255, a = 255; |
| static constexpr Color rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) { return Color{r, g, b, a}; } |
| bool operator==(const Color& o) const { return r == o.r && g == o.g && b == o.b && a == o.a; } |
| }; |
|
|
| } |
|
|
