Math: Non-const overloads for Frustum::(left|right|top|bottom|near|far|[])

Signed-off-by: Squareys <squareys@googlemail.com>

src/Magnum/Math/Frustum.h

@@ -146,10 +146,17 @@ template<class T> class Frustum {
 
         /**
          * @brief Plane at given index
+         * @m_since_latest
          *
          * Expects that @p i is less than @cpp 6 @ce.
          */
+        Vector4<T>& operator[](std::size_t i) {
+            CORRADE_ASSERT(i < 6, "Math::Frustum::operator[](): index" << i << "out of range",
+                _data[i]);
+            return _data[i];
+        }
         /* returns const& so [][] operations are also constexpr */
+        /** @overload */
         constexpr const Vector4<T>& operator[](std::size_t i) const {
             return CORRADE_CONSTEXPR_ASSERT(i < 6, "Math::Frustum::operator[](): index" << i << "out of range"), _data[i];
         }
@@ -196,23 +203,47 @@ template<class T> class Frustum {
          */
         constexpr const Vector4<T>* cend() const { return _data + 6; }
 
-        /** @brief Left plane */
+        /**
-        constexpr Vector4<T> left() const { return _data[0]; }
+         * @brief Left plane
+         * @m_since_latest
+         */
+        Vector4<T>& left() { return _data[0]; }
+        constexpr Vector4<T> left() const { return _data[0]; } /**< @overload */
 
-        /** @brief Right plane */
+        /**
-        constexpr Vector4<T> right() const { return _data[1]; }
+         * @brief Right plane
+         * @m_since_latest
+         */
+        Vector4<T>& right() { return _data[1]; }
+        constexpr Vector4<T> right() const { return _data[1]; } /**< @overload */
 
-        /** @brief Bottom plane */
+        /**
-        constexpr Vector4<T> bottom() const { return _data[2]; }
+         * @brief Bottom plane
+         * @m_since_latest
+         */
+        Vector4<T>& bottom() { return _data[2]; }
+        constexpr Vector4<T> bottom() const { return _data[2]; } /**< @overload */
 
-        /** @brief Top plane */
+        /**
-        constexpr Vector4<T> top() const { return _data[3]; }
+         * @brief Top plane
+         * @m_since_latest
+         */
+        Vector4<T>& top() { return _data[3]; }
+        constexpr Vector4<T> top() const { return _data[3]; } /**< @overload */
 
-        /** @brief Near plane */
+        /**
-        constexpr Vector4<T> near() const { return _data[4]; }
+         * @brief Near plane
+         * @m_since_latest
+         */
+        Vector4<T>& near() { return _data[4]; }
+        constexpr Vector4<T> near() const { return _data[4]; } /**< @overload */
 
-        /** @brief Far plane */
+        /**
-        constexpr Vector4<T> far() const { return _data[5]; }
+         * @brief Far plane
+         * @m_since_latest
+         */
+        Vector4<T>& far() { return _data[5]; }
+        constexpr Vector4<T> far() const { return _data[5]; } /**< @overload */
 
     private:
         Vector4<T> _data[6];

src/Magnum/Math/Test/FrustumTest.cpp

@@ -124,14 +124,52 @@ void FrustumTest::construct() {
         planes[2], planes[3],
         planes[4], planes[5]};
 
-    CORRADE_COMPARE(frustum[0], planes[0]);
+    constexpr Vector4 c0 = frustum[0];
-    CORRADE_COMPARE(frustum[1], planes[1]);
+    constexpr Vector4 c1 = frustum[1];
-    CORRADE_COMPARE(frustum[2], planes[2]);
+    constexpr Vector4 c2 = frustum[2];
-    CORRADE_COMPARE(frustum[3], planes[3]);
+    constexpr Vector4 c3 = frustum[3];
-    CORRADE_COMPARE(frustum[4], planes[4]);
+    constexpr Vector4 c4 = frustum[4];
-    CORRADE_COMPARE(frustum[5], planes[5]);
+    constexpr Vector4 c5 = frustum[5];
+    CORRADE_COMPARE(c0, planes[0]);
+    CORRADE_COMPARE(c1, planes[1]);
+    CORRADE_COMPARE(c2, planes[2]);
+    CORRADE_COMPARE(c3, planes[3]);
+    CORRADE_COMPARE(c4, planes[4]);
+    CORRADE_COMPARE(c5, planes[5]);
+
+    constexpr Vector4 cleft = frustum.left();
+    constexpr Vector4 cright = frustum.right();
+    constexpr Vector4 cbottom = frustum.bottom();
+    constexpr Vector4 ctop = frustum.top();
+    constexpr Vector4 cnear = frustum.near();
+    constexpr Vector4 cfar = frustum.far();
+    CORRADE_COMPARE(cleft, planes[0]);
+    CORRADE_COMPARE(cright, planes[1]);
+    CORRADE_COMPARE(cbottom, planes[2]);
+    CORRADE_COMPARE(ctop, planes[3]);
+    CORRADE_COMPARE(cnear, planes[4]);
+    CORRADE_COMPARE(cfar, planes[5]);
 
     CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Vector4, Vector4, Vector4, Vector4, Vector4, Vector4>::value));
+
+    Frustum a{
+        planes[0], planes[1],
+        planes[2], planes[3],
+        planes[4], planes[5]};
+
+    CORRADE_COMPARE(a[0], planes[0]);
+    CORRADE_COMPARE(a[1], planes[1]);
+    CORRADE_COMPARE(a[2], planes[2]);
+    CORRADE_COMPARE(a[3], planes[3]);
+    CORRADE_COMPARE(a[4], planes[4]);
+    CORRADE_COMPARE(a[5], planes[5]);
+
+    CORRADE_COMPARE(a.left(), planes[0]);
+    CORRADE_COMPARE(a.right(), planes[1]);
+    CORRADE_COMPARE(a.bottom(), planes[2]);
+    CORRADE_COMPARE(a.top(), planes[3]);
+    CORRADE_COMPARE(a.near(), planes[4]);
+    CORRADE_COMPARE(a.far(), planes[5]);
 }
 
 void FrustumTest::constructIdentity() {