point3.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 "point2.hpp"
#include "vector3.hpp"
#include "extent3.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 : point3);
 
hi_export namespace hi::inline v1 {
 
class point3 {
public:
    using array_type = simd<float, 4>;
    using value_type = array_type::value_type;
 
    constexpr point3(point3 const&) noexcept = default;
    constexpr point3(point3&&) noexcept = default;
    constexpr point3& operator=(point3 const&) noexcept = default;
    constexpr point3& operator=(point3&&) noexcept = default;
 
    [[nodiscard]] constexpr point3(point2 const& other) noexcept : _v(static_cast<array_type>(other)) {}
 
    [[nodiscard]] constexpr explicit operator point2() const noexcept
    {
        auto tmp = _v;
        tmp.z() = 0.0f;
        return point2{tmp};
    }
 
    [[nodiscard]] constexpr point3(point2 const& other, float z) noexcept : _v(static_cast<array_type>(other))
    {
        _v.z() = z;
    }
 
    [[nodiscard]] constexpr explicit operator array_type() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr explicit point3(array_type const& other) noexcept : _v(other)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] constexpr point3() noexcept : _v(0.0f, 0.0f, 0.0f, 1.0f) {}
 
    [[nodiscard]] constexpr point3(float x, float y, float z = 0.0f) noexcept : _v(x, y, z, 1.0f) {}
 
    [[nodiscard]] constexpr float& x() noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float& y() noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float& z() noexcept
    {
        return _v.z();
    }
 
    [[nodiscard]] constexpr float x() const noexcept
    {
        return _v.x();
    }
 
    [[nodiscard]] constexpr float y() const noexcept
    {
        return _v.y();
    }
 
    [[nodiscard]] constexpr float z() const noexcept
    {
        return _v.z();
    }
 
    constexpr point3& operator+=(vector3 const& rhs) noexcept
    {
        return *this = *this + rhs;
    }
 
    constexpr point3& operator-=(vector3 const& rhs) noexcept
    {
        return *this = *this - rhs;
    }
 
    [[nodiscard]] constexpr friend point3 operator+(point3 const& lhs, vector3 const& rhs) noexcept
    {
        return point3{lhs._v + array_type{rhs}};
    }
 
    [[nodiscard]] constexpr friend point3 operator+(vector3 const& lhs, point3 const& rhs) noexcept
    {
        return point3{array_type{lhs} + rhs._v};
    }
 
    [[nodiscard]] constexpr friend point3 operator-(point3 const& lhs, vector3 const& rhs) noexcept
    {
        return point3{lhs._v - array_type{rhs}};
    }
 
    [[nodiscard]] constexpr friend vector3 operator-(point3 const& lhs, point3 const& rhs) noexcept
    {
        return vector3{lhs._v - rhs._v};
    }
 
    [[nodiscard]] constexpr friend bool operator==(point3 const& lhs, point3 const& rhs) noexcept
    {
        return equal(lhs._v, rhs._v);
    }
 
    [[nodiscard]] friend constexpr point3 midpoint(point3 const& lhs, point3 const& rhs) noexcept
    {
        return point3{(lhs._v + rhs._v) * array_type::broadcast(0.5f)};
    }
 
    [[nodiscard]] friend constexpr point3 reflect(point3 const& lhs, point3 const& rhs) noexcept
    {
        return point3{rhs._v - (lhs._v - rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 min(point3 const& lhs, point3 const& rhs) noexcept
    {
        return point3{min(lhs._v, rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 max(point3 const& lhs, point3 const& rhs) noexcept
    {
        return point3{max(lhs._v, rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 round(point3 const& rhs) noexcept
    {
        return point3{round(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 ceil(point3 const& rhs) noexcept
    {
        return point3{ceil(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 floor(point3 const& rhs) noexcept
    {
        return point3{floor(rhs._v)};
    }
 
    [[nodiscard]] friend constexpr point3 ceil(point3 const& lhs, extent3 rhs) noexcept
    {
        auto const rhs_ = array_type{rhs}.xyz1();
        return point3{ceil(lhs._v / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend constexpr point3 floor(point3 const& lhs, extent3 rhs) noexcept
    {
        auto const rhs_ = array_type{rhs}.xyz1();
        return point3{floor(lhs._v / rhs_) * rhs_};
    }
 
    [[nodiscard]] friend float distance(point3 const& lhs, point3 const& rhs) noexcept
    {
        return hypot(rhs - lhs);
    }
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return _v.w() != 0.0f;
    }
 
    [[nodiscard]] friend std::string to_string(point3 const& rhs) noexcept
    {
        return std::format("<{}, {}, {}>", rhs._v.x(), rhs._v.y(), rhs._v.z());
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, point3 const& rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
 
private:
    array_type _v;
};
 
[[nodiscard]] constexpr point3 operator+(point2 const& lhs, vector3 const& rhs) noexcept
{
    return point3{f32x4{lhs} + f32x4{rhs}};
}
 
[[nodiscard]] constexpr point3 operator+(vector3 const& lhs, point2 const& rhs) noexcept
{
    return point3{f32x4{lhs} + f32x4{rhs}};
}
 
[[nodiscard]] constexpr point3 operator-(point2 const& lhs, vector3 const& rhs) noexcept
{
    return point3{f32x4{lhs} - f32x4{rhs}};
}
 
 
 
 
} // namespace hi::inline v1
 
// XXX #617 MSVC bug does not handle partial specialization in modules.
hi_export template<>
struct std::formatter<hi::point3, char> : std::formatter<std::string, char> {
    auto format(hi::point3 const& t, auto& fc) const
    {
        return std::formatter<std::string, char>::format(std::format("<{}, {}, {}>", t.x(), t.y(), t.z()), fc);
    }
};