types.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include <SDL3/SDL_rect.h>
 
#include <algorithm>
#include <optional>
 
namespace Flint {
  template <typename T>
  struct Vec2 {
      T x, y;
 
      Vec2 operator+(T scalar) {
        return {x + scalar, y + scalar};
      }
 
      Vec2 operator+(const Vec2 &other) const {
        return {x + other.x, y + other.y};
      }
 
      Vec2 operator-(T scalar) {
        return {x - scalar, y - scalar};
      }
 
      Vec2 operator-(const Vec2 &other) const {
        return {x - other.x, y - other.y};
      }
 
      Vec2 operator*(T scalar) const {
        return {x * scalar, y * scalar};
      }
 
      Vec2 operator*(const Vec2 &other) const {
        return {x * other.x, y * other.y};
      }
 
      Vec2 operator/(T scalar) const {
        return {x / scalar, y / scalar};
      }
 
      Vec2 operator/(const Vec2 &other) const {
        return {x / other.x, y / other.y};
      }
 
      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*=(T scalar) {
        x *= scalar;
        y *= scalar;
        return *this;
      }
 
      Vec2 &operator/=(T scalar) {
        x /= scalar;
        y /= scalar;
        return *this;
      }
 
      bool operator==(const Vec2 &other) const = default;
  };
 
  using Vec2i = Vec2<int>;
  using Vec2f = Vec2<float>;
 
  template <typename T>
  struct Rect {
      union {
          struct {
              Vec2<T> position; 
              Vec2<T> size;     
          };
 
          struct {
              T x, y, w, h;
          };
      };
 
      Rect() = default;
 
      Rect(Vec2<T> position, Vec2<T> size)
        : position(position),
          size(size) {
      }
 
      Rect(T x, T y, T w, T h)
        : x(x),
          y(y),
          w(w),
          h(h) {
      }
 
      std::optional<Rect<T>> findIntersection(const Rect<T> &other) const {
        T x1 = std::max(position.x, other.position.x);
        T y1 = std::max(position.y, other.position.y);
        T x2 = std::min(position.x + size.x, other.position.x + other.size.x);
        T y2 = std::min(position.y + size.y, other.position.y + other.size.y);
 
        if (x2 > x1 && y2 > y1) {
          return Rect<T>{
              {     x1,      y1},
              {x2 - x1, y2 - y1}
          };
        }
        return std::nullopt;
      }
 
      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;
      }
 
      auto toNative() const {
        if constexpr (std::is_same_v<T, int>) {
          return SDL_Rect{static_cast<int>(position.x), static_cast<int>(position.y),
                          static_cast<int>(size.x), static_cast<int>(size.y)};
        } else {
          return SDL_FRect{position.x, position.y, size.x, size.y};
        }
      }
 
      static auto fromNative(const SDL_Rect &rect) {
        if constexpr (std::is_same_v<T, int>) {
          return Rect<T>{
              {rect.x, rect.y},
              {rect.w, rect.h}
          };
        } else {
          return Rect<T>{
              {static_cast<T>(rect.x), static_cast<T>(rect.y)},
              {static_cast<T>(rect.w), static_cast<T>(rect.h)}
          };
        }
      }
 
      std::optional<Rect> getGlobalBounds() const {
        if (size.x <= 0 || size.y <= 0) {
          return std::nullopt;
        }
        return *this;
      }
  };
 
  using IntRect = Rect<int>;
  using FloatRect = Rect<float>;
}