From 8f56b58092c80f2f865c79c0432443104631586c Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Fri, 15 Feb 2019 07:03:01 +0700
Subject: [PATCH] math: additional rect and aabb operators

---
 headers/enduro2d/math/aabb.hpp        | 150 ++++++++++++++++++++++++++
 headers/enduro2d/math/rect.hpp        | 150 ++++++++++++++++++++++++++
 untests/sources/untests_math/aabb.cpp |  57 ++++++++++
 untests/sources/untests_math/rect.cpp |  49 +++++++++
 4 files changed, 406 insertions(+)

diff --git a/headers/enduro2d/math/aabb.hpp b/headers/enduro2d/math/aabb.hpp
index c64450ae..40663b1f 100644
--- a/headers/enduro2d/math/aabb.hpp
+++ b/headers/enduro2d/math/aabb.hpp
@@ -35,6 +35,22 @@ namespace e2d
 
         template < typename To >
         aabb<To> cast_to() const noexcept;
+
+        T* data() noexcept;
+        const T* data() const noexcept;
+
+        T& operator[](std::size_t index) noexcept;
+        T  operator[](std::size_t index) const noexcept;
+
+        aabb& operator+=(T v) noexcept;
+        aabb& operator-=(T v) noexcept;
+        aabb& operator*=(T v) noexcept;
+        aabb& operator/=(T v) noexcept;
+
+        aabb& operator+=(const vec3<T>& v) noexcept;
+        aabb& operator-=(const vec3<T>& v) noexcept;
+        aabb& operator*=(const vec3<T>& v) noexcept;
+        aabb& operator/=(const vec3<T>& v) noexcept;
     };
 }
 
@@ -65,6 +81,76 @@ namespace e2d
             position.template cast_to<To>(),
             size.template cast_to<To>()};
     }
+
+    template < typename T >
+    T* aabb<T>::data() noexcept {
+        return position.data();
+    }
+
+    template < typename T >
+    const T* aabb<T>::data() const noexcept {
+        return position.data();
+    }
+
+    template < typename T >
+    T& aabb<T>::operator[](std::size_t index) noexcept {
+        E2D_ASSERT(index < 6);
+        return data()[index];
+    }
+
+    template < typename T >
+    T aabb<T>::operator[](std::size_t index) const noexcept {
+        E2D_ASSERT(index < 6);
+        return data()[index];
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator+=(T v) noexcept {
+        position += v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator-=(T v) noexcept {
+        position -= v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator*=(T v) noexcept {
+        size *= v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator/=(T v) noexcept {
+        size /= v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator+=(const vec3<T>& v) noexcept {
+        position += v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator-=(const vec3<T>& v) noexcept {
+        position -= v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator*=(const vec3<T>& v) noexcept {
+        size *= v;
+        return *this;
+    }
+
+    template < typename T >
+    aabb<T>& aabb<T>::operator/=(const vec3<T>& v) noexcept {
+        size /= v;
+        return *this;
+    }
 }
 
 namespace e2d
@@ -148,6 +234,70 @@ namespace e2d
     bool operator>=(const aabb<T>& l, const aabb<T>& r) noexcept {
         return !(l < r);
     }
+
+    //
+    // aabb (+,-,*,/) value
+    //
+
+    template < typename T >
+    aabb<T> operator+(const aabb<T>& l, T v) noexcept {
+        return {
+            l.position + v,
+            l.size};
+    }
+
+    template < typename T >
+    aabb<T> operator-(const aabb<T>& l, T v) noexcept {
+        return {
+            l.position - v,
+            l.size};
+    }
+
+    template < typename T >
+    aabb<T> operator*(const aabb<T>& l, T v) noexcept {
+        return {
+            l.position,
+            l.size * v};
+    }
+
+    template < typename T >
+    aabb<T> operator/(const aabb<T>& l, T v) noexcept {
+        return {
+            l.position,
+            l.size / v};
+    }
+
+    //
+    // aabb (+,-,*,/) vec3
+    //
+
+    template < typename T >
+    aabb<T> operator+(const aabb<T>& l, const vec3<T>& v) noexcept {
+        return {
+            l.position + v,
+            l.size};
+    }
+
+    template < typename T >
+    aabb<T> operator-(const aabb<T>& l, const vec3<T>& v) noexcept {
+        return {
+            l.position - v,
+            l.size};
+    }
+
+    template < typename T >
+    aabb<T> operator*(const aabb<T>& l, const vec3<T>& v) noexcept {
+        return {
+            l.position,
+            l.size * v};
+    }
+
+    template < typename T >
+    aabb<T> operator/(const aabb<T>& l, const vec3<T>& v) noexcept {
+        return {
+            l.position,
+            l.size / v};
+    }
 }
 
 namespace e2d { namespace math
diff --git a/headers/enduro2d/math/rect.hpp b/headers/enduro2d/math/rect.hpp
index 5caf8a74..f45c62df 100644
--- a/headers/enduro2d/math/rect.hpp
+++ b/headers/enduro2d/math/rect.hpp
@@ -38,6 +38,22 @@ namespace e2d
 
         template < typename To >
         rect<To> cast_to() const noexcept;
+
+        T* data() noexcept;
+        const T* data() const noexcept;
+
+        T& operator[](std::size_t index) noexcept;
+        T  operator[](std::size_t index) const noexcept;
+
+        rect& operator+=(T v) noexcept;
+        rect& operator-=(T v) noexcept;
+        rect& operator*=(T v) noexcept;
+        rect& operator/=(T v) noexcept;
+
+        rect& operator+=(const vec2<T>& v) noexcept;
+        rect& operator-=(const vec2<T>& v) noexcept;
+        rect& operator*=(const vec2<T>& v) noexcept;
+        rect& operator/=(const vec2<T>& v) noexcept;
     };
 }
 
@@ -80,6 +96,76 @@ namespace e2d
             position.template cast_to<To>(),
             size.template cast_to<To>()};
     }
+
+    template < typename T >
+    T* rect<T>::data() noexcept {
+        return position.data();
+    }
+
+    template < typename T >
+    const T* rect<T>::data() const noexcept {
+        return position.data();
+    }
+
+    template < typename T >
+    T& rect<T>::operator[](std::size_t index) noexcept {
+        E2D_ASSERT(index < 4);
+        return data()[index];
+    }
+
+    template < typename T >
+    T rect<T>::operator[](std::size_t index) const noexcept {
+        E2D_ASSERT(index < 4);
+        return data()[index];
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator+=(T v) noexcept {
+        position += v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator-=(T v) noexcept {
+        position -= v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator*=(T v) noexcept {
+        size *= v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator/=(T v) noexcept {
+        size /= v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator+=(const vec2<T>& v) noexcept {
+        position += v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator-=(const vec2<T>& v) noexcept {
+        position -= v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator*=(const vec2<T>& v) noexcept {
+        size *= v;
+        return *this;
+    }
+
+    template < typename T >
+    rect<T>& rect<T>::operator/=(const vec2<T>& v) noexcept {
+        size /= v;
+        return *this;
+    }
 }
 
 namespace e2d
@@ -163,6 +249,70 @@ namespace e2d
     bool operator>=(const rect<T>& l, const rect<T>& r) noexcept {
         return !(l < r);
     }
+
+    //
+    // rect (+,-,*,/) value
+    //
+
+    template < typename T >
+    rect<T> operator+(const rect<T>& l, T v) noexcept {
+        return {
+            l.position + v,
+            l.size};
+    }
+
+    template < typename T >
+    rect<T> operator-(const rect<T>& l, T v) noexcept {
+        return {
+            l.position - v,
+            l.size};
+    }
+
+    template < typename T >
+    rect<T> operator*(const rect<T>& l, T v) noexcept {
+        return {
+            l.position,
+            l.size * v};
+    }
+
+    template < typename T >
+    rect<T> operator/(const rect<T>& l, T v) noexcept {
+        return {
+            l.position,
+            l.size / v};
+    }
+
+    //
+    // rect (+,-,*,/) vec2
+    //
+
+    template < typename T >
+    rect<T> operator+(const rect<T>& l, const vec2<T>& v) noexcept {
+        return {
+            l.position + v,
+            l.size};
+    }
+
+    template < typename T >
+    rect<T> operator-(const rect<T>& l, const vec2<T>& v) noexcept {
+        return {
+            l.position - v,
+            l.size};
+    }
+
+    template < typename T >
+    rect<T> operator*(const rect<T>& l, const vec2<T>& v) noexcept {
+        return {
+            l.position,
+            l.size * v};
+    }
+
+    template < typename T >
+    rect<T> operator/(const rect<T>& l, const vec2<T>& v) noexcept {
+        return {
+            l.position,
+            l.size / v};
+    }
 }
 
 namespace e2d { namespace math
diff --git a/untests/sources/untests_math/aabb.cpp b/untests/sources/untests_math/aabb.cpp
index 2f882ff0..0cfceef0 100644
--- a/untests/sources/untests_math/aabb.cpp
+++ b/untests/sources/untests_math/aabb.cpp
@@ -27,6 +27,63 @@ TEST_CASE("aabb") {
     {
         REQUIRE(b3f(1,2,3,4,5,6).cast_to<i32>() == b3i(1,2,3,4,5,6));
     }
+    {
+        auto r0 = b3i(1,2,3,4,5,6);
+        REQUIRE(r0.data()[0] == 1);
+        REQUIRE(r0.data()[1] == 2);
+        REQUIRE(r0.data()[2] == 3);
+        REQUIRE(r0.data()[3] == 4);
+        REQUIRE(r0.data()[4] == 5);
+        REQUIRE(r0.data()[5] == 6);
+        r0.data()[0] = 2;
+        REQUIRE(r0 == b3i(2,2,3,4,5,6));
+        const auto& cr0 = r0;
+        REQUIRE(cr0.data()[0] == 2);
+        REQUIRE(cr0.data()[1] == 2);
+        REQUIRE(cr0.data()[2] == 3);
+        REQUIRE(cr0.data()[3] == 4);
+        REQUIRE(cr0.data()[4] == 5);
+        REQUIRE(cr0.data()[5] == 6);
+    }
+    {
+        auto r0 = b3i(1,2,3,4,5,6);
+        REQUIRE(r0[0] == 1);
+        REQUIRE(r0[1] == 2);
+        REQUIRE(r0[2] == 3);
+        REQUIRE(r0[3] == 4);
+        REQUIRE(r0[4] == 5);
+        REQUIRE(r0[5] == 6);
+        r0[0] = 2;
+        REQUIRE(r0 == b3i(2,2,3,4,5,6));
+        const auto& cr0 = r0;
+        REQUIRE(cr0[0] == 2);
+        REQUIRE(cr0[1] == 2);
+        REQUIRE(cr0[2] == 3);
+        REQUIRE(cr0[3] == 4);
+        REQUIRE(cr0[4] == 5);
+        REQUIRE(cr0[5] == 6);
+    }
+    {
+        auto r0 = b3i(1,2,3,4,5,6);
+        REQUIRE(&r0 == &(r0 += 1));
+        REQUIRE(r0 == b3i(2,3,4,4,5,6));
+        REQUIRE(&r0 == &(r0 -= 4));
+        REQUIRE(r0 == b3i(-2,-1,0,4,5,6));
+        REQUIRE(&r0 == &(r0 *= 2));
+        REQUIRE(r0 == b3i(-2,-1,0,8,10,12));
+        REQUIRE(&r0 == &(r0 /= 3));
+        REQUIRE(r0 == b3i(-2,-1,0,2,3,4));
+
+        REQUIRE(b3i(1,2,3,4,5,6) + 2 == b3i(3,4,5,4,5,6));
+        REQUIRE(b3i(1,2,3,4,5,6) - 2 == b3i(-1,0,1,4,5,6));
+        REQUIRE(b3i(1,2,3,4,5,6) * 2 == b3i(1,2,3,8,10,12));
+        REQUIRE(b3i(1,2,3,4,5,6) / 2 == b3i(1,2,3,2,2,3));
+
+        REQUIRE(b3i(1,2,3,4,5,6) + v3i(1,2,3) == b3i(2,4,6,4,5,6));
+        REQUIRE(b3i(1,2,3,4,5,6) - v3i(3,2,1) == b3i(-2,0,2,4,5,6));
+        REQUIRE(b3i(1,2,3,4,5,6) * v3i(2,3,4) == b3i(1,2,3,8,15,24));
+        REQUIRE(b3i(1,2,3,4,12,20) / v3i(2,3,4) == b3i(1,2,3,2,4,5));
+    }
     {
         REQUIRE(make_aabb(2,1,0) == b3i(0,0,0,2,1,0));
         REQUIRE(make_aabb(4,3,2,1,0,-1) == b3i(4,3,2,1,0,-1));
diff --git a/untests/sources/untests_math/rect.cpp b/untests/sources/untests_math/rect.cpp
index 6f3b9a43..c041c62c 100644
--- a/untests/sources/untests_math/rect.cpp
+++ b/untests/sources/untests_math/rect.cpp
@@ -27,6 +27,55 @@ TEST_CASE("rect") {
     {
         REQUIRE(b2f(1,2,3,4).cast_to<i32>() == b2i(1,2,3,4));
     }
+    {
+        auto r0 = b2i(1,2,3,4);
+        REQUIRE(r0.data()[0] == 1);
+        REQUIRE(r0.data()[1] == 2);
+        REQUIRE(r0.data()[2] == 3);
+        REQUIRE(r0.data()[3] == 4);
+        r0.data()[0] = 2;
+        REQUIRE(r0 == b2i(2,2,3,4));
+        const auto& cr0 = r0;
+        REQUIRE(cr0.data()[0] == 2);
+        REQUIRE(cr0.data()[1] == 2);
+        REQUIRE(cr0.data()[2] == 3);
+        REQUIRE(cr0.data()[3] == 4);
+    }
+    {
+        auto r0 = b2i(1,2,3,4);
+        REQUIRE(r0[0] == 1);
+        REQUIRE(r0[1] == 2);
+        REQUIRE(r0[2] == 3);
+        REQUIRE(r0[3] == 4);
+        r0[0] = 2;
+        REQUIRE(r0 == b2i(2,2,3,4));
+        const auto& cr0 = r0;
+        REQUIRE(cr0[0] == 2);
+        REQUIRE(cr0[1] == 2);
+        REQUIRE(cr0[2] == 3);
+        REQUIRE(cr0[3] == 4);
+    }
+    {
+        auto r0 = b2i(1,2,3,4);
+        REQUIRE(&r0 == &(r0 += 1));
+        REQUIRE(r0 == b2i(2,3,3,4));
+        REQUIRE(&r0 == &(r0 -= 4));
+        REQUIRE(r0 == b2i(-2,-1,3,4));
+        REQUIRE(&r0 == &(r0 *= 2));
+        REQUIRE(r0 == b2i(-2,-1,6,8));
+        REQUIRE(&r0 == &(r0 /= 3));
+        REQUIRE(r0 == b2i(-2,-1,2,2));
+
+        REQUIRE(b2i(1,2,3,4) + 2 == b2i(3,4,3,4));
+        REQUIRE(b2i(1,2,3,4) - 2 == b2i(-1,0,3,4));
+        REQUIRE(b2i(1,2,3,4) * 3 == b2i(1,2,9,12));
+        REQUIRE(b2i(1,2,6,9) / 3 == b2i(1,2,2,3));
+
+        REQUIRE(b2i(1,2,3,4) + v2i(1,2) == b2i(2,4,3,4));
+        REQUIRE(b2i(1,2,3,4) - v2i(1,2) == b2i(0,0,3,4));
+        REQUIRE(b2i(1,2,3,4) * v2i(2,3) == b2i(1,2,6,12));
+        REQUIRE(b2i(1,2,6,8) / v2i(3,2) == b2i(1,2,2,4));
+    }
     {
         REQUIRE(make_rect(2,1) == b2i(0,0,2,1));
         REQUIRE(make_rect(4,3,2,1) == b2i(4,3,2,1));