point2.hpp

// Copyright Take Vos 2021-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "vector2.hpp"
#include "extent2.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include <hikocpu/hikocpu.hpp>
#include <format>
#include <concepts>
#include <exception>
#include <compare>
 
hi_export_module(hikogui.geometry : point2);
 
hi_export namespace hi::inline v1 {
 
class point2 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr point2(point2 const&) noexcept = default;
    constexpr point2(point2&&) noexcept = default;
    constexpr point2& operator=(point2 const&) noexcept = default;
    constexpr point2& operator=(point2&&) noexcept = default;
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit point2(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr point2() noexcept : _v(0.0f, 0.0f, 0.0f, 1.0f) {}
 
    [[nodiscard]] constexpr point2(float x, float y) noexcept : _v(x, y, 0.0f, 1.0f) {}
 
    [[nodiscard]] constexpr float& x() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float& y() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float y() const noexcept
    {
        return _v.y();
    }
 
    constexpr point2& operator+=(vector2 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    constexpr point2& operator-=(vector2 const& rhs) noexcept
    {
        return *this = *this - rhs;
    }
 
    [[nodiscard]] constexpr friend point2 operator+(point2 const& lhs, vector2 const& rhs) noexcept
    {
        return point2{lhs._v + array_type{rhs}};
    }
 
    [[nodiscard]] constexpr friend point2 operator+(vector2 const& lhs, point2 const& rhs) noexcept
    {
        return point2{array_type{lhs} + rhs._v};
    }
 
    [[nodiscard]] constexpr friend point2 operator-(point2 const& lhs, vector2 const& rhs) noexcept
    {
        return point2{lhs._v - array_type{rhs}};
    }
 
    [[nodiscard]] constexpr friend vector2 operator-(point2 const& lhs, point2 const& rhs) noexcept
    {
        return vector2{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(point2 const& lhs, point2 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] friend constexpr point2 midpoint(point2 const& lhs, point2 const& rhs) noexcept
    {
        return point2{(lhs._v + rhs._v) * array_type::broadcast(0.5f)};
    }
 
    [[nodiscard]] friend constexpr point2 reflect(point2 const& lhs, point2 const& rhs) noexcept
    {
        return point2{rhs._v - (lhs._v - rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 min(point2 const& lhs, point2 const& rhs) noexcept
    {
        return point2{min(lhs._v, rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 max(point2 const& lhs, point2 const& rhs) noexcept
    {
        return point2{max(lhs._v, rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 round(point2 const& rhs) noexcept
    {
        return point2{round(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 ceil(point2 const& rhs) noexcept
    {
        return point2{ceil(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 floor(point2 const& rhs) noexcept
    {
        return point2{floor(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point2 ceil(point2 const& lhs, extent2 rhs) noexcept
    {
        auto const rhs_ = array_type{rhs}.xy11();
        return point2{ceil(lhs._v / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend constexpr point2 floor(point2 const& lhs, extent2 rhs) noexcept
    {
        auto const rhs_ = array_type{rhs}.xy11();
        return point2{floor(lhs._v / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend float distance(point2 const& lhs, point2 const& rhs) noexcept
    {
        return hypot(rhs - lhs);
    }
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.z() == 0.0f and _v.w() != 0.0f;
    }
 
    [[nodiscard]] friend std::string to_string(point2 const& rhs) noexcept
    {
        return std::format("<{}, {}>", rhs._v.x(), rhs._v.y());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, point2 const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
} // namespace hi::inline v1
 
// XXX #617 MSVC bug does not handle partial specialization in modules.
hi_export template<>
struct std::formatter<hi::point2, char> : std::formatter<std::string, char> {
    auto format(hi::point2 const& t, auto& fc) const
    {
        return std::formatter<std::string, char>::format(std::format("<{}, {}>", t.x(), t.y()), fc);
    }
};