iaarect.hpp

// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/ivec.hpp"
 
namespace tt {
 
class iaarect {
    ivec v;
 
public:
    tt_force_inline iaarect() noexcept : v() {}
    tt_force_inline iaarect(iaarect const &rhs) noexcept = default;
    tt_force_inline iaarect &operator=(iaarect const &rhs) noexcept = default;
    tt_force_inline iaarect(iaarect &&rhs) noexcept = default;
    tt_force_inline iaarect &operator=(iaarect &&rhs) noexcept = default;
 
    iaarect(__m128i rhs) noexcept :
        v(rhs) {}
 
    iaarect &operator=(__m128i rhs) noexcept {
        v = rhs;
        return *this;
    }
 
    operator __m128i () const noexcept {
        return v;
    }
 
    template<typename T, std::enable_if_t<std::is_integral_v<T>,int> = 0>
    tt_force_inline iaarect(T x, T y, T width, T height) noexcept :
        iaarect(ivec(x, y, x + width, y + height)) {}
 
    tt_force_inline iaarect(ivec const &offset, ivec const &extent) noexcept :
        iaarect(offset.xyxy() + extent.zwxy()) {}
 
    [[nodiscard]] tt_force_inline static iaarect p0p3(ivec const &p1, ivec const &p2) noexcept {
        return _mm_blend_epi16(p1, p2.xyxy(), 0b11'11'00'00);
    }
 
    iaarect &operator|=(iaarect const &rhs) noexcept {
        return *this = *this | rhs;
    }
 
    iaarect &operator+=(ivec const &rhs) noexcept {
        return *this = *this + rhs;
    }
 
    iaarect &operator-=(ivec const &rhs) noexcept {
        return *this = *this - rhs;
    }
 
    template<size_t I>
    [[nodiscard]] tt_force_inline ivec corner() const noexcept {
        static_assert(I <= 3);
        if constexpr (I == 0) {
            return v.xy01();
        } else if constexpr (I == 1) {
            return v.zy01();
        } else if constexpr (I == 2) {
            return v.xw01();
        } else {
            return v.zw01();
        }
    }
 
    [[nodiscard]] tt_force_inline ivec offset() const noexcept { return corner<0>(); }
 
    
    [[nodiscard]] ivec extent() const noexcept {
        return corner<3>() - corner<0>();
    }
 
    [[nodiscard]] tt_force_inline int x1() const noexcept { return v.x(); } 
    [[nodiscard]] tt_force_inline int y1() const noexcept { return v.y(); } 
    [[nodiscard]] tt_force_inline int x2() const noexcept { return v.z(); } 
    [[nodiscard]] tt_force_inline int y2() const noexcept { return v.w(); } 
    [[nodiscard]] tt_force_inline int width() const noexcept { return extent().x(); }
    [[nodiscard]] tt_force_inline int height() const noexcept { return extent().y(); }
 
    [[nodiscard]] bool contains(ivec const &rhs) const noexcept {
        return
            (((rhs >= v) & 0x00ff) == 0x00ff) &&
            (((rhs <= v) & 0xff00) == 0xff00);
    }
 
    [[nodiscard]] friend bool operator==(iaarect const &lhs, iaarect const &rhs) noexcept {
        return lhs.v == rhs.v;
    }
 
    [[nodiscard]] friend bool operator!=(iaarect const &lhs, iaarect const &rhs) noexcept {
        return !(lhs == rhs);
    }
 
    [[nodiscard]] friend iaarect operator|(iaarect const &lhs, iaarect const &rhs) noexcept {
        return _mm_blend_epi16(min(lhs.v, rhs.v), max(lhs.v, rhs.v), 0b11'11'00'00);
    }
 
    [[nodiscard]] friend iaarect operator+(iaarect const &lhs, ivec const &rhs) noexcept {
        return static_cast<__m128i>(lhs.v + rhs.xyxy());
    }
 
    [[nodiscard]] friend iaarect operator-(iaarect const &lhs, ivec const &rhs) noexcept {
        return static_cast<__m128i>(lhs.v - rhs.xyxy());
    }
 
    template<typename T, std::enable_if_t<std::is_integral_v<T>,int> = 0>
    [[nodiscard]] friend iaarect expand(iaarect const &lhs, T rhs) noexcept {
        ttlet _0000 = _mm_setzero_si128();
        ttlet _000r = _mm_insert_epi32(_0000, rhs, 0);
        ttlet _00rr = ivec{_mm_shuffle_epi32(_000r, _MM_SHUFFLE(1,1,0,0))};
        ttlet _rr00 = ivec{_mm_shuffle_epi32(_000r, _MM_SHUFFLE(0,0,1,1))};
        return static_cast<__m128i>((lhs.v - _00rr) + _rr00);
    }
};
 
}