shape_concepts.h

 
#pragma once
 
#include "geometry_common.h"
#include <optional>
 
namespace ghassanpl::geometry
{
    
    template <typename T, typename SHAPE>
    concept shape = requires (SHAPE const& shape, glm::tvec2<T> pt, T t)
    {
        { shape.edge_length() } -> std::convertible_to<T>;

        { shape.edge_point_alpha(t) } -> std::convertible_to<glm::tvec2<T>>;

        { shape.edge_point(t) } -> std::convertible_to<glm::tvec2<T>>;

        { shape.bounding_box() } -> std::convertible_to<trec2<T>>;

        { shape.closest_point_to(pt) } -> std::convertible_to<glm::tvec2<T>>;
 
        // interval<T> projected_on_axis(glm::tvec2<T> axis) const;
    };

    template <typename T, shape<T> S> auto distance(S const& sh, glm::tvec2<T> pt) { return glm::distance(sh.closest_point_to(pt), pt); }
    template <typename T, shape<T> S> auto distance(glm::tvec2<T> pt, S const& sh) { return glm::distance(sh.closest_point_to(pt), pt); }
 
    template <typename T, shape<T> S> auto distance_squared(S const& sh, glm::tvec2<T> pt) { const auto d = sh.closest_point_to(pt) - pt; return glm::dot(d, d); }
    template <typename T, shape<T> S> auto distance_squared(glm::tvec2<T> pt, S const& sh) { const auto d = sh.closest_point_to(pt) - pt; return glm::dot(d, d); }
 
    template <typename T>
    std::optional<T> axis_overlaps(shape<T> auto const& a, shape<T> auto const& b, glm::vec2 const& axis)
    {
        interval<T> first = a.projected_on_axis(axis);
        interval<T> second = b.projected_on_axis(axis);
 
        return first.overlaps(second) ? first.overlap(second) : std::nullopt;
    }

    template <typename T, typename SHAPE>
    concept area_shape = shape<T, SHAPE> && requires (SHAPE const& shape, glm::tvec2<T> pt, T t) {
        { shape.contains(pt) } -> std::convertible_to<bool>;
        { shape.calculate_area() } -> std::convertible_to<T>;
        { shape.centroid() } -> std::convertible_to<glm::tvec2<T>>;
        /*
        { shape.moment_of_inertia() } -> std::convertible_to<T>;
        { shape.moment_of_inertia(shape.centroid()) } -> std::convertible_to<T>;
        { shape.moment_of_inertia(shape.centroid(), shape.centroid()) } -> std::convertible_to<T>;
        */
    };

    template <typename T, typename SHAPE>
    concept polygon_shape = shape<T, SHAPE> && requires (SHAPE const& shape) {
        { shape.for_each_edge([](glm::tvec2<T> const& a, glm::tvec2<T> const& b) {}) };
        { shape.for_each_vertex([](glm::tvec2<T> const& vertex) {}) };
        { shape.vertex_count() } -> std::convertible_to<size_t>;
        { shape.edge_count() } -> std::convertible_to<size_t>;
        { shape.edge(size_t{}) } -> std::convertible_to<std::optional<std::pair<glm::tvec2<T>, glm::tvec2<T>>>>;
        { shape.vertex(size_t{}) } -> std::convertible_to<std::optional<glm::tvec2<T>>>;
    };
    
    template <typename T, typename SHAPE>
    concept polygon_area_shape = area_shape<T, SHAPE> && polygon_shape<T, SHAPE>;

    template <typename POLY>
    concept indexable_polygonlike = requires (POLY const& polygon, size_t i) {
        { polygon[i] } -> is_specialization_of<glm::tvec2>;
    };


}