squares.h

 
#pragma once
 
#include "direction.h"
 
namespace ghassanpl::geometry::squares
{
    
 
    template <std::integral T>
    constexpr bool is_surrounding(glm::tvec2<T> a, glm::tvec2<T> b) { const auto d = glm::abs_distance(a, b); return d.x < 2 && d.y < 2 && d.x + d.y > 0; }
    template <std::integral T>
    constexpr bool is_neighbor(glm::tvec2<T> a, glm::tvec2<T> b) { const auto d = glm::abs_distance(a, b); return d.x < 2 && d.y < 2 && d.x != d.y; }
    template <std::integral T>
    constexpr bool is_diagonal_neighbor(glm::tvec2<T> a, glm::tvec2<T> b) { const auto d = glm::abs_distance(a, b); return d.x < 2 && d.y < 2 && d.x == d.y; }

    template <typename METRIC, typename T>
    concept metric = std::integral<T> && requires (T t, glm::tvec2<T> vec) {
        { METRIC::is_adjacent(vec, vec) } -> std::convertible_to<bool>;
        { METRIC::is_adjacent(direction{}) } -> std::convertible_to<bool>;
        { METRIC::distance(vec, vec) } -> std::convertible_to<T>;
    };

    struct manhattan_metric
    {
        template <std::integral T>
        static constexpr auto is_adjacent(glm::tvec2<T> a, glm::tvec2<T> b)
        {
            return is_neighbor(a, b);
        }
 
        static constexpr auto is_adjacent(direction dir)
        {
            return is_cardinal(dir);
        }
 
        template <std::integral T>
        static constexpr auto distance(glm::tvec2<T> a, glm::tvec2<T> b)
        {
            const auto d = glm::abs_distance(a, b);
            return d.x + d.y;
        }
    };
    using neighbor_metric = manhattan_metric;

    struct chebyshev_metric
    {
        template <std::integral T>
        static constexpr bool is_adjacent(glm::tvec2<T> a, glm::tvec2<T> b)
        {
            return is_surrounding(a, b);
        }
 
        static constexpr bool is_adjacent(direction dir)
        {
            return is_valid(dir);
        }
 
        template <std::integral T>
        static constexpr auto distance(glm::tvec2<T> a, glm::tvec2<T> b)
        {
            const auto d = glm::abs_distance(a, b);
            return glm::max(d.x, d.y);
        }
    };
    using surrounding_metric = chebyshev_metric;

    template <std::integral T>
    constexpr auto manhattan_distance(glm::tvec2<T> a, glm::tvec2<T> b)
    {
        return manhattan_metric::distance(a, b);
    }
    template <std::integral T>
    constexpr auto neighbor_distance(glm::tvec2<T> a, glm::tvec2<T> b)
    {
        return neighbor_metric::distance(a, b);
    }
 
    template <std::integral T>
    constexpr auto chebyshev_distance(glm::tvec2<T> a, glm::tvec2<T> b)
    {
        return chebyshev_metric::distance(a, b);
    }
    template <std::integral T>
    constexpr auto surrounding_distance(glm::tvec2<T> a, glm::tvec2<T> b)
    {
        return surrounding_metric::distance(a, b);
    }
 
    template <std::integral I, std::floating_point F>
    constexpr glm::tvec2<F> tile_pos_to_world_pos(glm::tvec2<I> tile_pos, glm::tvec2<F> tile_size) { return glm::tvec2<F>(tile_pos) * tile_size; }
 
    template <std::integral I, std::floating_point F>
    constexpr glm::tvec2<F> tile_pos_to_world_pos(glm::tvec2<I> tile_pos, F tile_size) { return glm::tvec2<F>(tile_pos) * tile_size; }
    
    template <std::integral I, std::floating_point F>
    constexpr trec2<F> world_rect_for_tile(glm::tvec2<I> pos, glm::tvec2<F> tile_size) { return trec2<F>::from_size(tile_pos_to_world_pos(pos, tile_size), tile_size); }
    
    template <std::integral I, std::floating_point F>
    constexpr trec2<F> world_rect_for_tile(glm::tvec2<I> pos, F tile_size) { return trec2<F>::from_size(tile_pos_to_world_pos(pos, tile_size), { tile_size, tile_size }); }
 
    template <std::integral I = int, std::floating_point F>
    inline glm::tvec2<I> world_pos_to_tile_pos(glm::tvec2<F> world_pos, glm::tvec2<F> tile_size) { return glm::tvec2<I>(glm::floor(world_pos / tile_size)); }
 
    template <std::integral I = int, std::floating_point F>
    inline glm::tvec2<I> world_pos_to_tile_pos(glm::tvec2<F> world_pos, F tile_size) { return glm::tvec2<I>(glm::floor(world_pos / tile_size)); }
    
    template <std::integral I = int, std::floating_point F>
    inline trec2<I> world_rect_to_tile_rect(trec2<F> const& world_rect, glm::tvec2<F> tile_size) { return trec2<I>{ glm::floor(world_rect.p1 / tile_size), glm::ceil(world_rect.p2 / tile_size) }; }
 
    template <std::integral I = int, std::floating_point F>
    inline trec2<I> world_rect_to_tile_rect(trec2<F> const& world_rect, F tile_size) { return trec2<I>{ glm::floor(world_rect.p1 / tile_size), glm::ceil(world_rect.p2 / tile_size) }; }
 
    template <std::floating_point F>
    inline glm::tvec2<F> snap_world_pos_to_tile_grid(glm::tvec2<F> world_pos, glm::tvec2<F> tile_size) {
        return glm::floor((world_pos + (tile_size * 0.5f)) / tile_size) * tile_size;
    }

    template <std::integral I, std::floating_point F, metric<I> METRIC = chebyshev_metric>
    struct ttile_space
    {
        using metric = METRIC;
        using vec2 = glm::tvec2<F>;
        using ivec2 = glm::tvec2<I>;
        using rec2 = trec2<F>;
        using irec2 = trec2<I>;
 
        using tile_pos = named<vec2, "tile_pos", traits::location>;
        using world_pos = named<ivec2, "world_pos", traits::location>;
 
        using tile_rec = named<rec2, "tile_rec">;
        using world_rec = named<irec2, "world_rec">;
 
        vec2 tile_size{ F(1), F(1) };
 
        constexpr vec2 to_world_pos(ivec2 tile_pos) const noexcept { return tile_pos_to_world_pos(tile_pos, tile_size); }
        constexpr rec2 world_rect_for_tile(ivec2 tile_pos) const noexcept { return ghassanpl::geometry::squares::world_rect_for_tile(tile_pos, tile_size); }
        constexpr ivec2 to_tile_pos(vec2 world_pos) const noexcept { return world_pos_to_tile_pos(world_pos, tile_size); }
        constexpr irec2 to_tile_rect(rec2 const& world_rect) const noexcept { return world_rect_to_tile_rect(world_rect, tile_size); }
        
        inline vec2 snap_to_grid(vec2 world_pos) const { return snap_world_pos_to_tile_grid(world_pos, tile_size); }
 
        constexpr world_pos to_world_pos(tile_pos tile_pos) const noexcept { return to_world_pos(*tile_pos); }
        constexpr world_rec world_rect_for_tile(tile_pos tile_pos) const noexcept { return world_rect_for_tile(*tile_pos); }
        constexpr tile_pos to_tile_pos(world_pos world_pos) const noexcept { return to_tile_pos(*world_pos); }
        constexpr tile_rec to_tile_rect(world_rec const& world_rect) const noexcept { return to_tile_rect(*world_rect); }
 
        inline world_pos snap_to_grid(world_pos world_pos) const { return snap_to_grid(*world_pos); }
 
        static constexpr auto is_adjacent(ivec2 a, ivec2 b) { return metric::is_adjacent(a, b); }
        static constexpr auto is_adjacent(tile_pos a, tile_pos b) { return is_adjacent(*a, *b); }
        static constexpr auto is_adjacent(direction dir) { return metric::is_adjacent(dir); }
        static constexpr auto tile_distance(ivec2 a, ivec2 b) { return metric::distance(a, b); }
        static constexpr auto tile_distance(tile_pos a, tile_pos b) { return distance(*a, *b); }
    };
 
    using chebyshev_tile_space = ttile_space<int, float, chebyshev_metric>;
    using manhattan_tile_space = ttile_space<int, float, manhattan_metric>;

    using tile_pos = named<glm::ivec2, "tile_pos", traits::location>;
    using world_pos = named<glm::vec2, "world_pos", traits::location>;

    using tile_rec = named<irec2, "tile_rec">;
    using world_rec = named<rec2, "world_rec">;

}