ge211_geometry.hxx

#pragma once
 
#include "ge211_forward.hxx"
#include "ge211_if_cpp.hxx"
#include "ge211_noexcept.hxx"
#include "ge211_type_traits.hxx"
#include "ge211_util.hxx"
 
#include <SDL_rect.h>
 
#include <ostream>
#include <type_traits>
#include <utility>
 
namespace ge211 {
 
namespace geometry {
 
class origin_type
{
};
 
 
template <typename COORDINATE>
struct Dims
{
    using Coordinate = COORDINATE;
 
    Coordinate width;  
    Coordinate height; 
 
 
    Dims(Coordinate width, Coordinate height)
            : width{width},
              height{height}
    { }
 
    Dims()
            : Dims{Coordinate{}, Coordinate{}}
    { }
 
    template <typename FROM_COORD>
    explicit Dims(const Dims<FROM_COORD> &that)
            : width(that.width),
              height(that.height)
    { }
 
    template <typename TO_COORD>
    ge211::Dims<TO_COORD>
    into() const
    {
        return {TO_COORD(width), TO_COORD(height)};
    }
 
 
 
    bool operator==(Dims that) const
    {
        return width == that.width && height == that.height;
    }
 
    bool operator!=(Dims that) const
    {
        return !(*this == that);
    }
 
    bool operator<=(Dims that) const
    {
        return width <= that.width && height <= that.height;
    }
 
    bool operator>=(Dims that) const
    {
        return that <= *this;
    }
 
    bool operator<(Dims that) const
    {
        return *this <= that && *this != that;
    }
 
    bool operator>(Dims that) const
    {
        return that < *this;
    }
 
    Dims operator+(Dims that) const
    {
        return {Coordinate(width + that.width),
                Coordinate(height + that.height)};
    }
 
    Dims operator-(Dims that) const
    {
        return {Coordinate(width - that.width),
                Coordinate(height - that.height)};
    }
 
    template <
            typename OTHER_COORD,
            typename RESULT_COORD = Multiply_Result<Coordinate, OTHER_COORD>
    >
    Dims<RESULT_COORD>
    operator*(Dims<OTHER_COORD> that) const
    {
        return {RESULT_COORD(width * that.width),
                RESULT_COORD(height * that.height)};
    }
 
    template <
            typename ARITHMETIC_TYPE,
            typename = std::enable_if_t<Is_Arithmetic<ARITHMETIC_TYPE>>
    >
    Dims operator*(ARITHMETIC_TYPE scalar) const
    {
        return {Coordinate(width * scalar), Coordinate(height * scalar)};
    }
 
    template <
            typename ARITHMETIC_TYPE,
            typename = std::enable_if_t<Is_Arithmetic<ARITHMETIC_TYPE>>
    >
    Dims operator/(ARITHMETIC_TYPE scalar) const
    {
        return {Coordinate(width / scalar), Coordinate(height / scalar)};
    }
 
    // Negates a Dims. (Multiplies it by -1.)
    Dims operator-() const
    {
        return {-width, -height};
    }
 
    Dims &operator+=(Dims that)
    {
        return *this = *this + that;
    }
 
    Dims &operator-=(Dims that)
    {
        return *this = *this - that;
    }
 
    template <
            typename OTHER_COORD
    >
    Dims &operator*=(Dims<OTHER_COORD> that)
    {
        return *this = *this * that;
    }
 
    template <
            typename ARITHMETIC_TYPE,
            typename = std::enable_if_t<Is_Arithmetic<ARITHMETIC_TYPE>>
    >
    Dims &operator*=(ARITHMETIC_TYPE scalar)
    {
        return *this = *this * scalar;
    }
 
    template <
            typename ARITHMETIC_TYPE,
            typename = std::enable_if_t<Is_Arithmetic<ARITHMETIC_TYPE>>
    >
    Dims &operator/=(ARITHMETIC_TYPE scalar)
    {
        return *this = *this / scalar;
    }
 
};
 
 
template <
        typename COORDINATE,
        typename SCALAR,
        typename = std::enable_if_t<Is_Arithmetic<SCALAR>>
>
Dims<COORDINATE>
operator*(SCALAR scalar, Dims<COORDINATE> dims)
{
    return dims * scalar;
}
 
template <typename COORDINATE>
struct Posn
{
    using Coordinate = COORDINATE;
 
    using Dims_type = Dims<COORDINATE>;
 
    Coordinate x; 
    Coordinate y; 
 
 
    Posn(Coordinate x, Coordinate y)
    NOEXCEPT_(detail::is_nothrow_convertible<Coordinate>())
            : x{x},
              y{y}
    { }
 
    Posn(origin_type)
    NOEXCEPT_(noexcept(Coordinate{}))
            : Posn(Coordinate{}, Coordinate{})
    { }
 
    explicit Posn(Dims_type dims)
    NOEXCEPT_(detail::is_nothrow_convertible<Coordinate>())
            : Posn{dims.width, dims.height}
    { }
 
    template <typename FROM_COORD>
    explicit Posn(const Posn<FROM_COORD> &that)
            : x(that.x),
              y(that.y)
    { }
 
    template <typename TO_COORD>
    ge211::Posn<TO_COORD>
    into() const
    {
        return {TO_COORD(x), TO_COORD(y)};
    }
 
 
 
    bool operator==(Posn that) const
    NOEXCEPT_(detail::is_nothrow_comparable<Coordinate>())
    {
        return x == that.x && y == that.y;
    }
 
    bool operator!=(Posn p2) const
    NOEXCEPT_(detail::is_nothrow_comparable<Coordinate>())
    {
        return !(*this == p2);
    }
 
    Posn operator+(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return down_right_by(dims);
    }
 
    Posn operator-(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return up_left_by(dims);
    }
 
    Dims_type operator-(Posn that) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x - that.x, y - that.y};
    }
 
    Posn &operator+=(Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return *this = *this + dims;
    }
 
    Posn &operator-=(Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return *this = *this - dims;
    }
 
 
 
    Posn up_by(Coordinate dy) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x, y - dy};
    }
 
    Posn down_by(Coordinate dy) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x, y + dy};
    }
 
    Posn left_by(Coordinate dx) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x - dx, y};
    }
 
    Posn right_by(Coordinate dx) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x + dx, y};
    }
 
    Posn up_left_by(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x - dims.width, y - dims.height};
    }
 
    Posn up_right_by(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x + dims.width, y - dims.height};
    }
 
    Posn down_left_by(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x - dims.width, y + dims.height};
    }
 
    Posn down_right_by(Dims_type dims) const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x + dims.width, y + dims.height};
    }
 
};
 
 
template <typename COORDINATE>
struct Rect
{
    using Coordinate = COORDINATE;
 
    using Dims_type = Dims<Coordinate>;
 
    using Posn_type = Posn<Coordinate>;
 
    Coordinate x;         
    Coordinate y;         
    Coordinate width;     
    Coordinate height;    
 
 
    Rect(Coordinate x, Coordinate y, Coordinate width, Coordinate height)
            : x{x},
              y{y},
              width{width},
              height{height}
    { }
 
    Rect()
            : Rect{Coordinate{}, Coordinate{}, Coordinate{}, Coordinate{}}
    { }
 
    template <typename FROM_COORD>
    explicit Rect(const Rect<FROM_COORD> &that)
            : x(that.x),
              y(that.y),
              width(that.width),
              height(that.height)
    { }
 
    template <typename TO_COORD>
    ge211::Rect<TO_COORD>
    into() const
    {
        return {TO_COORD(x), TO_COORD(y), TO_COORD(width), TO_COORD(height)};
    }
 
 
 
    bool operator==(const Rect &that) const
    NOEXCEPT_(detail::is_nothrow_comparable<Coordinate>())
    {
        return x == that.x &&
               y == that.y &&
               width == that.width &&
               height == that.height;
    }
 
    bool operator!=(const Rect &that) const
    NOEXCEPT_(detail::is_nothrow_comparable<Coordinate>())
    {
        return !(*this == that);
    }
 
 
 
    Dims_type dimensions() const
    NOEXCEPT_(detail::is_nothrow_convertible<Coordinate>())
    {
        return {width, height};
    }
 
    Posn_type top_left() const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {x, y};
    }
 
    Posn_type top_right() const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return top_left().right_by(width);
    }
 
    Posn_type bottom_left() const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return top_left().down_by(height);
    }
 
    Posn_type bottom_right() const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return top_left().down_right_by(dimensions());
    }
 
    Posn_type center() const
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>() &&
              detail::has_nothrow_division<Coordinate>())
    {
        return top_left().down_right_by(dimensions() / Coordinate(2));
    }
 
 
 
    static Rect from_top_left(Posn_type tl, Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return {tl.x, tl.y, dims.width, dims.height};
    }
 
    static Rect from_top_right(Posn_type tr, Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return from_top_left(tr.left_by(dims.width), dims);
    }
 
    static Rect from_bottom_left(Posn_type bl, Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return from_top_left(bl.up_by(dims.height), dims);
    }
 
    static Rect from_bottom_right(Posn_type br, Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return from_top_left(br.up_left_by(dims), dims);
    }
 
    static Rect from_center(Posn_type center, Dims_type dims)
    NOEXCEPT_(detail::has_nothrow_arithmetic<Coordinate>())
    {
        return from_top_left(center.up_left_by(dims / Coordinate(2)), dims);
    }
 
 
    class iterator;
 
    iterator begin() const
    {
        return {top_left(), y, y + height};
    }
 
    iterator end() const
    {
        return {top_left().right_by(width), y, y + height};
    }
 
private:
    friend Circle_sprite;
    friend ::ge211::internal::Render_sprite;
    friend class detail::Renderer;
 
    operator SDL_Rect() const
    NOEXCEPT_(detail::is_nothrow_convertible<COORDINATE, int>())
    {
        SDL_Rect result;
        result.x = static_cast<int>(x);
        result.y = static_cast<int>(y);
        result.w = static_cast<int>(width);
        result.h = static_cast<int>(height);
        return result;
    }
};
 
template <typename COORDINATE>
class Rect<COORDINATE>::iterator
        : public std::iterator<std::input_iterator_tag, const Posn_type>
{
public:
    Posn_type operator*() const
    {
        return current_;
    }
 
    Posn_type const *operator->() const
    {
        return &current_;
    }
 
    iterator &operator++()
    {
        if (++current_.y >= y_end_) {
            ++current_.x;
            current_.y = y_begin_;
        }
 
        return *this;
    }
 
    iterator &operator--()
    {
        if (current_.y == y_begin_) {
            current_.y = y_end_;
            --current_.x;
        }
 
        --current_.y;
 
        return *this;
    }
 
    iterator operator++(int)
    {
        iterator result(*this);
        ++*this;
        return result;
    }
 
    iterator operator--(int)
    {
        iterator result(*this);
        --*this;
        return result;
    }
 
    bool operator==(iterator const &that) const
    {
        return **this == *that;
    }
 
    bool operator!=(iterator const &that) const
    {
        return !(*this == that);
    }
 
private:
    friend Rect;
 
    iterator(Posn_type current, Coordinate y_begin, Coordinate y_end)
            : current_(current),
              y_begin_(y_begin),
              y_end_(y_end)
    { }
 
    Posn_type current_;
    Coordinate y_begin_;
    Coordinate y_end_;
};
 
 
class Transform
{
public:
 
    Transform() NOEXCEPT;
 
    static Transform rotation(double) NOEXCEPT;
 
    static Transform flip_h() NOEXCEPT;
 
    static Transform flip_v() NOEXCEPT;
 
    static Transform scale(double) NOEXCEPT;
 
    static Transform scale_x(double) NOEXCEPT;
 
    static Transform scale_y(double) NOEXCEPT;
 
 
 
    Transform &set_rotation(double) NOEXCEPT;
 
    Transform &set_flip_h(bool) NOEXCEPT;
 
    Transform &set_flip_v(bool) NOEXCEPT;
 
    Transform &set_scale(double) NOEXCEPT;
 
    Transform &set_scale_x(double) NOEXCEPT;
 
    Transform &set_scale_y(double) NOEXCEPT;
 
 
 
    double get_rotation() const NOEXCEPT;
 
    bool get_flip_h() const NOEXCEPT;
 
    bool get_flip_v() const NOEXCEPT;
 
    double get_scale_x() const NOEXCEPT;
 
    double get_scale_y() const NOEXCEPT;
 
 
 
    bool is_identity() const NOEXCEPT;
 
    Transform operator*(const Transform& other) const NOEXCEPT;
 
    Transform inverse() const NOEXCEPT;
 
 
 
    bool operator==(const Transform& other) const NOEXCEPT;
 
    bool operator!=(const Transform& other) const NOEXCEPT;
 
 
private:
    double rotation_;
    double scale_x_;
    double scale_y_;
    bool flip_h_;
    bool flip_v_;
};
 
 
//;
constexpr origin_type the_origin;
 
 
 
template <typename COORDINATE>
Dims<COORDINATE>
make_dims(COORDINATE x, COORDINATE y)
{
    return {x, y};
}
 
template <typename COORDINATE>
Posn<COORDINATE>
make_posn(COORDINATE x, COORDINATE y)
{
    return {x, y};
}
 
 
template <typename COORDINATE>
Rect<COORDINATE>
make_rect(COORDINATE x, COORDINATE y, COORDINATE width, COORDINATE height)
{
    return {x, y, width, height};
}
 
 
 
template <typename COORDINATE>
std::ostream& operator<<(std::ostream& out, Dims<COORDINATE> dims)
{
    return out
            << "Dims<" << detail::name_of_type<COORDINATE>() << ">("
            << dims.width << ", " << dims.height << ")";
}
 
template <typename COORDINATE>
std::ostream& operator<<(std::ostream& out, Posn<COORDINATE> p)
{
    return out
            << "Posn<" << detail::name_of_type<COORDINATE>() << ">("
            << p.x << ", " << p.y << ")";
}
 
template <typename COORDINATE>
std::ostream& operator<<(std::ostream& out, Rect<COORDINATE> rect)
{
    return out
            << "Rect<" << detail::name_of_type<COORDINATE>() << ">("
            << rect.x     << ", " << rect.y      << ", "
            << rect.width << ", " << rect.height << ")";
}
 
 
} // end namespace geometry.
 
} // end namespace ge211
 
// specializations in std:
namespace std {
 
template <typename COORDINATE>
struct hash<ge211::Posn<COORDINATE>>
{
    std::size_t operator()(ge211::Posn<COORDINATE> pos) const
    NOEXCEPT
    {
        return hash_t_(pos.x) * 31 ^ hash_t_(pos.y);
    }
 
private:
    std::hash<COORDINATE> hash_t_;
};
 
} // end namespace std