From 4bc84f68153ecff0307a6a314fa62fd91b14dc6f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Tue, 20 Aug 2019 10:12:33 +0200
Subject: [PATCH] Math: expand UnderlyingTypeOf to support vectors and
 matrices.

This allows getting underlying type of those without needing to include
them. Yay.
---
 src/Magnum/Math/Test/TypeTraitsTest.cpp |  7 ++++++
 src/Magnum/Math/TypeTraits.h            | 32 ++++++++++++++++++-------
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/Magnum/Math/Test/TypeTraitsTest.cpp b/src/Magnum/Math/Test/TypeTraitsTest.cpp
index 5580d1ddc..b9b64ba94 100644
--- a/src/Magnum/Math/Test/TypeTraitsTest.cpp
+++ b/src/Magnum/Math/Test/TypeTraitsTest.cpp
@@ -247,8 +247,15 @@ void TypeTraitsTest::isUnitless() {
 
 void TypeTraitsTest::underlyingTypeOf() {
     CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Int>, Int>::value));
+
     CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Deg<Float>>, Float>::value));
     CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Unit<Rad, Double>>, Double>::value));
+
+    CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Vector2<UnsignedByte>>, UnsignedByte>::value));
+    CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Color3<Float>>, Float>::value));
+
+    CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Matrix2x3<Double>>, Double>::value));
+    CORRADE_VERIFY((std::is_same<UnderlyingTypeOf<Matrix4<Float>>, Float>::value));
 }
 
 template<class T> void TypeTraitsTest::equalsIntegral() {
diff --git a/src/Magnum/Math/TypeTraits.h b/src/Magnum/Math/TypeTraits.h
index 7217559d9..ab5e30c19 100644
--- a/src/Magnum/Math/TypeTraits.h
+++ b/src/Magnum/Math/TypeTraits.h
@@ -250,20 +250,36 @@ namespace Implementation {
     };
     template<class T> struct UnderlyingType<Deg<T>> { typedef T Type; };
     template<class T> struct UnderlyingType<Rad<T>> { typedef T Type; };
+    template<std::size_t size, class T> struct UnderlyingType<Vector<size, T>> {
+        typedef T Type;
+    };
+    template<class T> struct UnderlyingType<Vector2<T>> { typedef T Type; };
+    template<class T> struct UnderlyingType<Vector3<T>> { typedef T Type; };
+    template<class T> struct UnderlyingType<Vector4<T>> { typedef T Type; };
+    template<class T> struct UnderlyingType<Color3<T>> { typedef T Type; };
+    template<class T> struct UnderlyingType<Color4<T>> { typedef T Type; };
+    template<std::size_t cols, std::size_t rows, class T> struct UnderlyingType<RectangularMatrix<cols, rows, T>> {
+        typedef T Type;
+    };
+    template<std::size_t size, class T> struct UnderlyingType<Matrix<size, T>> {
+        typedef T Type;
+    };
+    template<class T> struct UnderlyingType<Matrix3<T>> { typedef T Type; };
+    template<class T> struct UnderlyingType<Matrix4<T>> { typedef T Type; };
 }
 
 /**
-@brief Underlying builtin type for a scalar type
+@brief Underlying type of a math type
 
-For builtin types returns the type itself, for wrapped types like @ref Deg or
-@ref Rad returns the underlying builtin type. It's guaranteed that the input
-type is always explicitly convertible to the output type and the output type
-is usable with standard APIs such as @ref std::isinf().
+For builtin scalar types returns the type itself, for wrapped types like
+@ref Deg or @ref Rad returns the underlying builtin type, for vector and matrix
+types the type of their components.
 
-Passed types are required to satisfy @ref IsScalar. All non-scalar Magnum math
-types have a member @cpp typedef @ce ``Type`` containing the underlying type.
+For scalar types it's guaranteed that the input type is always explicitly
+convertible to the output type and the output type is usable with standard APIs
+such as @ref std::isinf().
 */
-template<class T> using UnderlyingTypeOf =  typename Implementation::UnderlyingType<T>::Type;
+template<class T> using UnderlyingTypeOf = typename Implementation::UnderlyingType<T>::Type;
 
 namespace Implementation {
     template<class T> struct TypeTraitsDefault {