Math: add [Unsigned]Byte/[Unsigned]Short variants of castInto().

doc/changelog.dox

@@ -171,6 +171,11 @@ See also:
     isn't available on ES3 or desktop GL, but NVidia drivers are known to emit
     it, which is why it got added.
 
+@subsubsection changelog-latest-changes-math Math library
+
+-   Added @ref Math::castInto() overloads for casting between @ref UnsignedByte
+    and @ref UnsignedShort or @ref Byte and @ref Short
+
 @subsubsection changelog-latest-changes-meshtools MeshTools library
 
 -   Added a `--bounds` option to @ref magnum-sceneconverter "magnum-sceneconverter",

src/Magnum/Math/PackingBatch.cpp

@@ -272,6 +272,22 @@ void castInto(const Corrade::Containers::StridedArrayView2D<const Int>& src, con
     castIntoImplementation(src, dst);
 }
 
+void castInto(const Corrade::Containers::StridedArrayView2D<const UnsignedByte>& src, const Corrade::Containers::StridedArrayView2D<UnsignedShort>& dst) {
+    castIntoImplementation(src, dst);
+}
+
+void castInto(const Corrade::Containers::StridedArrayView2D<const Byte>& src, const Corrade::Containers::StridedArrayView2D<Short>& dst) {
+    castIntoImplementation(src, dst);
+}
+
+void castInto(const Corrade::Containers::StridedArrayView2D<const UnsignedShort>& src, const Corrade::Containers::StridedArrayView2D<UnsignedByte>& dst) {
+    castIntoImplementation(src, dst);
+}
+
+void castInto(const Corrade::Containers::StridedArrayView2D<const Short>& src, const Corrade::Containers::StridedArrayView2D<Byte>& dst) {
+    castIntoImplementation(src, dst);
+}
+
 static_assert(sizeof(HalfMantissaTable) + sizeof(HalfOffsetTable) + sizeof(HalfExponentTable) == 8576,
     "improper size of half->float conversion tables");
 

src/Magnum/Math/PackingBatch.h

@@ -324,6 +324,30 @@ MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const
  */
 MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const Int>& src, const Corrade::Containers::StridedArrayView2D<Byte>& dst);
 
+/**
+ * @overload
+ * @m_since_latest
+ */
+MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const UnsignedByte>& src, const Corrade::Containers::StridedArrayView2D<UnsignedShort>& dst);
+
+/**
+ * @overload
+ * @m_since_latest
+ */
+MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const Byte>& src, const Corrade::Containers::StridedArrayView2D<Short>& dst);
+
+/**
+ * @overload
+ * @m_since_latest
+ */
+MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const UnsignedShort>& src, const Corrade::Containers::StridedArrayView2D<UnsignedByte>& dst);
+
+/**
+ * @overload
+ * @m_since_latest
+ */
+MAGNUM_EXPORT void castInto(const Corrade::Containers::StridedArrayView2D<const Short>& src, const Corrade::Containers::StridedArrayView2D<Byte>& dst);
+
 /* Since 1.8.17, the original short-hand group closing doesn't work anymore.
    FFS. */
 /**

src/Magnum/Math/Test/PackingBatchTest.cpp

@@ -54,8 +54,8 @@ struct PackingBatchTest: Corrade::TestSuite::Tester {
     template<class T> void castUnsignedFloat();
     template<class T> void castSignedFloat();
 
-    template<class T> void castUnsignedInteger();
+    template<class T, class U> void castUnsignedInteger();
-    template<class T> void castSignedInteger();
+    template<class T, class U> void castSignedInteger();
 
     template<class T> void assertionsPackUnpack();
     void assertionsPackUnpackHalf();
@@ -82,10 +82,12 @@ PackingBatchTest::PackingBatchTest() {
               &PackingBatchTest::castSignedFloat<Short>,
               &PackingBatchTest::castSignedFloat<Int>,
 
-              &PackingBatchTest::castUnsignedInteger<UnsignedByte>,
+              &PackingBatchTest::castUnsignedInteger<UnsignedByte, UnsignedInt>,
-              &PackingBatchTest::castUnsignedInteger<UnsignedShort>,
+              &PackingBatchTest::castUnsignedInteger<UnsignedShort, UnsignedInt>,
-              &PackingBatchTest::castSignedInteger<Byte>,
+              &PackingBatchTest::castUnsignedInteger<UnsignedByte, UnsignedShort>,
-              &PackingBatchTest::castSignedInteger<Short>,
+              &PackingBatchTest::castSignedInteger<Byte, Int>,
+              &PackingBatchTest::castSignedInteger<Short, Int>,
+              &PackingBatchTest::castSignedInteger<Byte, Short>,
 
               &PackingBatchTest::assertionsPackUnpack<UnsignedByte>,
               &PackingBatchTest::assertionsPackUnpack<Byte>,
@@ -100,8 +102,10 @@ PackingBatchTest::PackingBatchTest() {
               &PackingBatchTest::assertionsCast<Float, Int>,
               &PackingBatchTest::assertionsCast<UnsignedInt, UnsignedByte>,
               &PackingBatchTest::assertionsCast<UnsignedInt, UnsignedShort>,
+              &PackingBatchTest::assertionsCast<UnsignedShort, UnsignedByte>,
               &PackingBatchTest::assertionsCast<Int, Byte>,
-              &PackingBatchTest::assertionsCast<Int, Short>});
+              &PackingBatchTest::assertionsCast<Int, Short>,
+              &PackingBatchTest::assertionsCast<Short, Byte>});
 }
 
 typedef Math::Constants<Float> Constants;
@@ -493,21 +497,19 @@ template<class T> void PackingBatchTest::castSignedFloat() {
         Corrade::TestSuite::Compare::Container);
 }
 
-template<class T> void PackingBatchTest::castUnsignedInteger() {
+template<class T, class U> void PackingBatchTest::castUnsignedInteger() {
-    setTestCaseTemplateName(TypeTraits<T>::name());
+    setTestCaseTemplateName({TypeTraits<T>::name(), TypeTraits<U>::name()});
 
     struct Data {
         Math::Vector2<T> src;
-        Vector2ui dst;
+        Math::Vector2<U> dst;
     } data[]{
         {{0, 89}, {}},
         {{149, 22}, {}},
         {{13, 255}, {}}
     };
 
-    /* GCC 4.8 doesn't like constexpr here (cannot initialize aggregate of type
+    constexpr Math::Vector2<U> expectedTargetType[] {
-       ‘const Vector2 [3]’ with a compound literal), wtf */
-    const Vector2ui expectedTargetType[] {
         {0, 89},
         {149, 22},
         {13, 255}
@@ -520,34 +522,32 @@ template<class T> void PackingBatchTest::castUnsignedInteger() {
     };
 
     Corrade::Containers::StridedArrayView1D<Math::Vector2<T>> src{data, &data[0].src, 3, sizeof(Data)};
-    Corrade::Containers::StridedArrayView1D<Vector2ui> dst{data, &data[0].dst, 3, sizeof(Data)};
+    Corrade::Containers::StridedArrayView1D<Math::Vector2<U>> dst{data, &data[0].dst, 3, sizeof(Data)};
     castInto(Corrade::Containers::arrayCast<2, T>(src),
-             Corrade::Containers::arrayCast<2, UnsignedInt>(dst));
+             Corrade::Containers::arrayCast<2, U>(dst));
     CORRADE_COMPARE_AS(dst, Corrade::Containers::stridedArrayView(expectedTargetType),
         Corrade::TestSuite::Compare::Container);
 
     /* Test the other way around as well */
-    castInto(Corrade::Containers::arrayCast<2, UnsignedInt>(dst),
+    castInto(Corrade::Containers::arrayCast<2, U>(dst),
              Corrade::Containers::arrayCast<2, T>(src));
     CORRADE_COMPARE_AS(src, Corrade::Containers::stridedArrayView(expectedOriginalType),
         Corrade::TestSuite::Compare::Container);
 }
 
-template<class T> void PackingBatchTest::castSignedInteger() {
+template<class T, class U> void PackingBatchTest::castSignedInteger() {
-    setTestCaseTemplateName(TypeTraits<T>::name());
+    setTestCaseTemplateName({TypeTraits<T>::name(), TypeTraits<U>::name()});
 
     struct Data {
         Math::Vector2<T> src;
-        Vector2i dst;
+        Math::Vector2<U> dst;
     } data[]{
         {{0, -89}, {}},
         {{-119, 22}, {}},
         {{13, 127}, {}}
     };
 
-    /* GCC 4.8 doesn't like constexpr here (cannot initialize aggregate of type
+    constexpr Math::Vector2<U> expectedTargetType[] {
-       ‘const Vector2 [3]’ with a compound literal), wtf */
-    const Vector2i expectedTargetType[] {
         {0, -89},
         {-119, 22},
         {13, 127}
@@ -560,14 +560,14 @@ template<class T> void PackingBatchTest::castSignedInteger() {
     };
 
     Corrade::Containers::StridedArrayView1D<Math::Vector2<T>> src{data, &data[0].src, 3, sizeof(Data)};
-    Corrade::Containers::StridedArrayView1D<Vector2i> dst{data, &data[0].dst, 3, sizeof(Data)};
+    Corrade::Containers::StridedArrayView1D<Math::Vector2<U>> dst{data, &data[0].dst, 3, sizeof(Data)};
     castInto(Corrade::Containers::arrayCast<2, T>(src),
-             Corrade::Containers::arrayCast<2, Int>(dst));
+             Corrade::Containers::arrayCast<2, U>(dst));
     CORRADE_COMPARE_AS(dst, Corrade::Containers::stridedArrayView(expectedTargetType),
         Corrade::TestSuite::Compare::Container);
 
     /* Test the other way around as well */
-    castInto(Corrade::Containers::arrayCast<2, Int>(dst),
+    castInto(Corrade::Containers::arrayCast<2, U>(dst),
              Corrade::Containers::arrayCast<2, T>(src));
     CORRADE_COMPARE_AS(src, Corrade::Containers::stridedArrayView(expectedOriginalType),
         Corrade::TestSuite::Compare::Container);