rectangle.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 "aarectangle.hpp"
#include "alignment.hpp"
#include "../SIMD/module.hpp"
#include <array>
 
namespace hi { inline namespace v1 {
 
class rectangle {
public:
    point3 origin;
    vector3 right;
    vector3 up;
 
    constexpr rectangle() noexcept : origin(), right(), up() {}
    constexpr rectangle(rectangle const& rhs) noexcept = default;
    constexpr rectangle& operator=(rectangle const& rhs) noexcept = default;
    constexpr rectangle(rectangle&& rhs) noexcept = default;
    constexpr rectangle& operator=(rectangle&& rhs) noexcept = default;
 
    constexpr rectangle(point3 origin, vector3 right, vector3 up) noexcept : origin(origin), right(right), up(up) {}
 
    constexpr rectangle(point3 origin, point3 right_bottom, point3 left_top, point3 right_top) noexcept :
        rectangle(origin, right_bottom - origin, left_top - origin)
    {
    }
 
    constexpr rectangle(aarectangle rhs) noexcept
    {
        hilet p0 = get<0>(rhs);
        hilet p3 = get<3>(rhs);
        hilet diagonal = static_cast<f32x4>(p3 - p0);
 
        origin = p0;
        right = vector3{diagonal.x000()};
        up = vector3{diagonal._0y00()};
    }
 
    constexpr explicit rectangle(extent2 size) noexcept :
        rectangle(point3{}, vector3{size.width(), 0.0f, 0.0f}, vector3{0.0f, size.height(), 0.0f})
    {
    }
 
    constexpr rectangle& operator=(aarectangle rhs) noexcept
    {
        hilet p0 = get<0>(rhs);
        hilet p3 = get<3>(rhs);
        hilet diagonal = static_cast<f32x4>(p3 - p0);
 
        origin = p0;
        right = vector3{diagonal.x000()};
        up = vector3{diagonal._0y00()};
        return *this;
    }
 
    constexpr rectangle(point3 origin, extent2 extent) noexcept : rectangle(origin, extent.right(), extent.up()) {}
 
    [[nodiscard]] constexpr explicit operator aarectangle() const noexcept
    {
        auto left_bottom = f32x4::broadcast(std::numeric_limits<float>::max());
        auto right_top = f32x4::broadcast(-std::numeric_limits<float>::max());
 
        hilet p0 = origin;
        left_bottom = min(left_bottom, static_cast<f32x4>(p0));
        right_top = max(right_top, static_cast<f32x4>(p0));
 
        hilet p1 = p0 + right;
        left_bottom = min(left_bottom, static_cast<f32x4>(p1));
        right_top = max(right_top, static_cast<f32x4>(p1));
 
        hilet p2 = p0 + up;
        left_bottom = min(left_bottom, static_cast<f32x4>(p2));
        right_top = max(right_top, static_cast<f32x4>(p2));
 
        hilet p3 = p2 + right;
        left_bottom = min(left_bottom, static_cast<f32x4>(p3));
        right_top = max(right_top, static_cast<f32x4>(p3));
 
        return aarectangle{left_bottom.xy00() | right_top._00xy()};
    }
 
    [[nodiscard]] explicit operator bool() const noexcept
    {
        // min() is smallest normal float.
        return area() > std::numeric_limits<float>::min();
    }
 
    [[nodiscard]] constexpr bool is_rectangle() const noexcept
    {
        hilet dp = dot(right, up);
        return -std::numeric_limits<float>::min() <= dp and dp <= std::numeric_limits<float>::min();
    }
 
    [[nodiscard]] constexpr bool is_axis_aligned() const noexcept
    {
        hilet should_be_zeroes = static_cast<f32x4>(right).yz00() | static_cast<f32x4>(up)._00xz();
        return equal(should_be_zeroes, f32x4{});
    }
 
    [[nodiscard]] float width() const noexcept
    {
        return hypot(right);
    }
 
    [[nodiscard]] float height() const noexcept
    {
        return hypot(up);
    }
 
    [[nodiscard]] constexpr extent2 size() const noexcept
    {
        return {width(), height()};
    }
 
    [[nodiscard]] float area() const noexcept
    {
        return hypot(cross(right, up));
    }
 
    [[nodiscard]] constexpr point3 operator[](std::size_t i) const noexcept
    {
        switch (i) {
        case 0:
            return get<0>(*this);
        case 1:
            return get<1>(*this);
        case 2:
            return get<2>(*this);
        case 3:
            return get<3>(*this);
        default:
            hi_no_default();
        }
    }
 
    template<std::size_t I>
    [[nodiscard]] friend constexpr point3 get(rectangle const& rhs) noexcept
    {
        static_assert(I < 4);
        if constexpr (I == 0) {
            return rhs.origin;
        } else if constexpr (I == 1) {
            return rhs.origin + rhs.right;
        } else if constexpr (I == 2) {
            return rhs.origin + rhs.up;
        } else {
            return rhs.origin + rhs.right + rhs.up;
        }
    }
 
    [[nodiscard]] friend constexpr rectangle operator+(rectangle const& lhs, extent2 rhs) noexcept
    {
        hilet extra_right = normalize(lhs.right) * rhs.width();
        hilet extra_up = normalize(lhs.up) * rhs.height();
        hilet extra_diagonal = extra_right + extra_up;
 
        return rectangle{lhs.origin - extra_diagonal, lhs.right + 2.0f * extra_right, lhs.up + 2.0f * extra_up};
    }
 
    [[nodiscard]] friend constexpr rectangle operator-(rectangle const& lhs, extent2 rhs) noexcept
    {
        hilet extra_right = normalize(lhs.right) * rhs.width();
        hilet extra_up = normalize(lhs.up) * rhs.height();
        hilet extra_diagonal = extra_right + extra_up;
 
        return rectangle{lhs.origin + extra_diagonal, lhs.right - 2.0f * extra_right, lhs.up - 2.0f * extra_up};
    }
 
    [[nodiscard]] friend constexpr rectangle operator+(rectangle const& lhs, float rhs) noexcept
    {
        return lhs + extent2{rhs, rhs};
    };
 
    [[nodiscard]] friend constexpr rectangle operator-(rectangle const& lhs, float rhs) noexcept
    {
        return lhs - extent2{rhs, rhs};
    }
};
 
}} // namespace hi::v1