MeshTools: generate*Indices() overloads taking a 2D index buffer.

So these can be used directly in the generateIndices() implementation
that takes a MeshData.

src/Magnum/MeshTools/GenerateIndices.cpp

@@ -136,6 +136,17 @@ void generateLineStripIndicesInto(const Containers::StridedArrayView1D<const Uns
     generateLineStripIndicesIntoImplementation(indices, output);
 }
 
+void generateLineStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) {
+    CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::generateLineStripIndicesInto(): second index view dimension is not contiguous", );
+    if(indices.size()[1] == 4)
+        return generateLineStripIndicesInto(Containers::arrayCast<1, const UnsignedInt>(indices), output);
+    else if(indices.size()[1] == 2)
+        return generateLineStripIndicesInto(Containers::arrayCast<1, const UnsignedShort>(indices), output);
+    else if(indices.size()[1] == 1)
+        return generateLineStripIndicesInto(Containers::arrayCast<1, const UnsignedByte>(indices), output);
+    else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateLineStripIndicesInto(): expected index type size 1, 2 or 4 but got" << indices.size()[1], );
+}
+
 Containers::Array<UnsignedInt> generateLineStripIndices(const UnsignedInt vertexCount) {
     Containers::Array<UnsignedInt> output{NoInit, 2*(Math::max(vertexCount, 1u) - 1)};
     generateLineStripIndicesInto(vertexCount, output);
@@ -160,6 +171,12 @@ Containers::Array<UnsignedInt> generateLineStripIndices(const Containers::Stride
     return output;
 }
 
+Containers::Array<UnsignedInt> generateLineStripIndices(const Containers::StridedArrayView2D<const char>& indices) {
+    Containers::Array<UnsignedInt> output{NoInit, 2*(Math::max(indices.size()[0], std::size_t{1}) - 1)};
+    generateLineStripIndicesInto(indices, output);
+    return output;
+}
+
 void generateLineLoopIndicesInto(const UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) {
     CORRADE_ASSERT(vertexCount == 0 || vertexCount >= 2,
         "MeshTools::generateLineLoopIndicesInto(): expected either zero or at least two vertices, got" << vertexCount, );
@@ -219,6 +236,17 @@ void generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const Unsi
     generateLineLoopIndicesIntoImplementation(indices, output);
 }
 
+void generateLineLoopIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) {
+    CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::generateLineLoopIndicesInto(): second index view dimension is not contiguous", );
+    if(indices.size()[1] == 4)
+        return generateLineLoopIndicesInto(Containers::arrayCast<1, const UnsignedInt>(indices), output);
+    else if(indices.size()[1] == 2)
+        return generateLineLoopIndicesInto(Containers::arrayCast<1, const UnsignedShort>(indices), output);
+    else if(indices.size()[1] == 1)
+        return generateLineLoopIndicesInto(Containers::arrayCast<1, const UnsignedByte>(indices), output);
+    else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateLineLoopIndicesInto(): expected index type size 1, 2 or 4 but got" << indices.size()[1], );
+}
+
 Containers::Array<UnsignedInt> generateLineLoopIndices(const UnsignedInt vertexCount) {
     Containers::Array<UnsignedInt> output{NoInit, 2*vertexCount};
     generateLineLoopIndicesInto(vertexCount, output);
@@ -243,6 +271,12 @@ Containers::Array<UnsignedInt> generateLineLoopIndices(const Containers::Strided
     return output;
 }
 
+Containers::Array<UnsignedInt> generateLineLoopIndices(const Containers::StridedArrayView2D<const char>& indices) {
+    Containers::Array<UnsignedInt> output{NoInit, 2*indices.size()[0]};
+    generateLineLoopIndicesInto(indices, output);
+    return output;
+}
+
 void generateTriangleStripIndicesInto(const UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) {
     CORRADE_ASSERT(vertexCount == 0 || vertexCount >= 3,
         "MeshTools::generateTriangleStripIndicesInto(): expected either zero or at least three vertices, got" << vertexCount, );
@@ -301,6 +335,17 @@ void generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const
     generateTriangleStripIndicesIntoImplementation(indices, output);
 }
 
+void generateTriangleStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) {
+    CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::generateTriangleStripIndicesInto(): second index view dimension is not contiguous", );
+    if(indices.size()[1] == 4)
+        return generateTriangleStripIndicesInto(Containers::arrayCast<1, const UnsignedInt>(indices), output);
+    else if(indices.size()[1] == 2)
+        return generateTriangleStripIndicesInto(Containers::arrayCast<1, const UnsignedShort>(indices), output);
+    else if(indices.size()[1] == 1)
+        return generateTriangleStripIndicesInto(Containers::arrayCast<1, const UnsignedByte>(indices), output);
+    else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateTriangleStripIndicesInto(): expected index type size 1, 2 or 4 but got" << indices.size()[1], );
+}
+
 Containers::Array<UnsignedInt> generateTriangleStripIndices(const UnsignedInt vertexCount) {
     Containers::Array<UnsignedInt> output{NoInit, 3*(Math::max(vertexCount, 2u) - 2u)};
     generateTriangleStripIndicesInto(vertexCount, output);
@@ -325,6 +370,12 @@ Containers::Array<UnsignedInt> generateTriangleStripIndices(const Containers::St
     return output;
 }
 
+Containers::Array<UnsignedInt> generateTriangleStripIndices(const Containers::StridedArrayView2D<const char>& indices) {
+    Containers::Array<UnsignedInt> output{NoInit, 3*(Math::max(indices.size()[0], std::size_t{2}) - 2)};
+    generateTriangleStripIndicesInto(indices, output);
+    return output;
+}
+
 void generateTriangleFanIndicesInto(const UnsignedInt vertexCount, const Containers::StridedArrayView1D<UnsignedInt>& output) {
     CORRADE_ASSERT(vertexCount == 0 || vertexCount >= 3,
         "MeshTools::generateTriangleFanIndicesInto(): expected either zero or at least three vertices, got" << vertexCount, );
@@ -384,6 +435,17 @@ void generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const U
     generateTriangleFanIndicesIntoImplementation(indices, output);
 }
 
+void generateTriangleFanIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output) {
+    CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::generateTriangleFanIndicesInto(): second index view dimension is not contiguous", );
+    if(indices.size()[1] == 4)
+        return generateTriangleFanIndicesInto(Containers::arrayCast<1, const UnsignedInt>(indices), output);
+    else if(indices.size()[1] == 2)
+        return generateTriangleFanIndicesInto(Containers::arrayCast<1, const UnsignedShort>(indices), output);
+    else if(indices.size()[1] == 1)
+        return generateTriangleFanIndicesInto(Containers::arrayCast<1, const UnsignedByte>(indices), output);
+    else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateTriangleFanIndicesInto(): expected index type size 1, 2 or 4 but got" << indices.size()[1], );
+}
+
 Containers::Array<UnsignedInt> generateTriangleFanIndices(const UnsignedInt vertexCount) {
     Containers::Array<UnsignedInt> output{NoInit, 3*(Math::max(vertexCount, 2u) - 2)};
     generateTriangleFanIndicesInto(vertexCount, output);
@@ -408,6 +470,12 @@ Containers::Array<UnsignedInt> generateTriangleFanIndices(const Containers::Stri
     return output;
 }
 
+Containers::Array<UnsignedInt> generateTriangleFanIndices(const Containers::StridedArrayView2D<const char>& indices) {
+    Containers::Array<UnsignedInt> output{NoInit, 3*(Math::max(indices.size()[0], std::size_t{2}) - 2)};
+    generateTriangleFanIndicesInto(indices, output);
+    return output;
+}
+
 namespace {
 
 template<class T> inline void generateQuadIndicesIntoImplementation(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const T>& quads, const Containers::StridedArrayView1D<T>& output) {

src/Magnum/MeshTools/GenerateIndices.h

@@ -85,6 +85,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineStripIndices(
  */
 MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices);
 
+/**
+@brief Create index buffer for a line strip primitive with a type-erased index buffer
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateLineStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineStripIndices(const Containers::StridedArrayView2D<const char>& indices);
+
 /**
 @brief Create index buffer for a line strip primitive into an existing array
 @m_since{2020,06}
@@ -119,6 +130,17 @@ MAGNUM_MESHTOOLS_EXPORT void generateLineStripIndicesInto(const Containers::Stri
  */
 MAGNUM_MESHTOOLS_EXPORT void generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
 
+/**
+@brief Create index buffer for a line strip primitive with a type-erased index buffer into an existing array
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateLineStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT void generateLineStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
+
 /**
 @brief Create index buffer for a line loop primitive
 @m_since{2020,06}
@@ -155,6 +177,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineLoopIndices(c
  */
 MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices);
 
+/**
+@brief Create index buffer for a line loop primitive with a type-erased index buffer
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateLineLoopIndices(const Containers::StridedArrayView1D<const UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateLineLoopIndices(const Containers::StridedArrayView2D<const char>& indices);
+
 /**
 @brief Create index buffer for a line loop primitive into an existing array
 @m_since{2020,06}
@@ -189,6 +222,17 @@ MAGNUM_MESHTOOLS_EXPORT void generateLineLoopIndicesInto(const Containers::Strid
  */
 MAGNUM_MESHTOOLS_EXPORT void generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
 
+/**
+@brief Create index buffer for a line loop primitive with a type-erased index buffer into an existing array
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateLineLoopIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT void generateLineLoopIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
+
 /**
 @brief Create index buffer for a triangle strip primitive
 @m_since{2020,06}
@@ -225,6 +269,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleStripIndi
  */
 MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices);
 
+/**
+@brief Create index buffer for a triangle strip primitive with a type-erased index buffer
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateTriangleStripIndices(const Containers::StridedArrayView1D<const UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleStripIndices(const Containers::StridedArrayView2D<const char>& indices);
+
 /**
 @brief Create index buffer for a triangle strip primitive into an existing array
 @m_since{2020,06}
@@ -259,6 +314,17 @@ MAGNUM_MESHTOOLS_EXPORT void generateTriangleStripIndicesInto(const Containers::
  */
 MAGNUM_MESHTOOLS_EXPORT void generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
 
+/**
+@brief Create index buffer for a triangle strip primitive with a type-erased index buffer into an existing array
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateTriangleStripIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT void generateTriangleStripIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
+
 /**
 @brief Create index buffer for a triangle fan primitive
 @m_since{2020,06}
@@ -295,6 +361,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleFanIndice
  */
 MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices);
 
+/**
+@brief Create index buffer for a triangle fan primitive with a type-erased index buffer
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateTriangleFanIndices(const Containers::StridedArrayView1D<const UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT Containers::Array<UnsignedInt> generateTriangleFanIndices(const Containers::StridedArrayView2D<const char>& indices);
+
 /**
 @brief Create index buffer for a triangle fan primitive into an existing array
 @m_since{2020,06}
@@ -329,6 +406,17 @@ MAGNUM_MESHTOOLS_EXPORT void generateTriangleFanIndicesInto(const Containers::St
  */
 MAGNUM_MESHTOOLS_EXPORT void generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
 
+/**
+@brief Create index buffer for a triangle fan primitive with a type-erased index buffer into an existing array
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref generateTriangleFanIndicesInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView1D<UnsignedInt>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT void generateTriangleFanIndicesInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<UnsignedInt>& output);
+
 /**
 @brief Create a triangle index buffer for quad primitives
 @m_since_latest

src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp

@@ -47,23 +47,31 @@ struct GenerateIndicesTest: TestSuite::Tester {
 
     void generateLineStripIndices();
     template<class T> void generateLineStripIndicesIndexed();
+    template<class T> void generateLineStripIndicesIndexed2D();
     void generateLineStripIndicesWrongVertexCount();
     void generateLineStripIndicesIntoWrongSize();
+    void generateLineStripIndicesIndexed2DInvalid();
 
     void generateLineLoopIndices();
     template<class T> void generateLineLoopIndicesIndexed();
+    template<class T> void generateLineLoopIndicesIndexed2D();
     void generateLineLoopIndicesWrongVertexCount();
     void generateLineLoopIndicesIntoWrongSize();
+    void generateLineLoopIndicesIndexed2DInvalid();
 
     void generateTriangleStripIndices();
     template<class T> void generateTriangleStripIndicesIndexed();
+    template<class T> void generateTriangleStripIndicesIndexed2D();
     void generateTriangleStripIndicesWrongVertexCount();
     void generateTriangleStripIndicesIntoWrongSize();
+    void generateTriangleStripIndicesIndexed2DInvalid();
 
     void generateTriangleFanIndices();
     template<class T> void generateTriangleFanIndicesIndexed();
+    template<class T> void generateTriangleFanIndicesIndexed2D();
     void generateTriangleFanIndicesWrongVertexCount();
     void generateTriangleFanIndicesIntoWrongSize();
+    void generateTriangleFanIndicesIndexed2DInvalid();
 
     template<class T> void generateQuadIndices();
     template<class T> void generateQuadIndicesInto();
@@ -187,29 +195,45 @@ GenerateIndicesTest::GenerateIndicesTest() {
               &GenerateIndicesTest::generateLineStripIndicesIndexed<UnsignedInt>,
               &GenerateIndicesTest::generateLineStripIndicesIndexed<UnsignedShort>,
               &GenerateIndicesTest::generateLineStripIndicesIndexed<UnsignedByte>,
+              &GenerateIndicesTest::generateLineStripIndicesIndexed2D<UnsignedInt>,
+              &GenerateIndicesTest::generateLineStripIndicesIndexed2D<UnsignedShort>,
+              &GenerateIndicesTest::generateLineStripIndicesIndexed2D<UnsignedByte>,
               &GenerateIndicesTest::generateLineStripIndicesWrongVertexCount,
               &GenerateIndicesTest::generateLineStripIndicesIntoWrongSize,
+              &GenerateIndicesTest::generateLineStripIndicesIndexed2DInvalid,
 
               &GenerateIndicesTest::generateLineLoopIndices,
               &GenerateIndicesTest::generateLineLoopIndicesIndexed<UnsignedInt>,
               &GenerateIndicesTest::generateLineLoopIndicesIndexed<UnsignedShort>,
               &GenerateIndicesTest::generateLineLoopIndicesIndexed<UnsignedByte>,
+              &GenerateIndicesTest::generateLineLoopIndicesIndexed2D<UnsignedInt>,
+              &GenerateIndicesTest::generateLineLoopIndicesIndexed2D<UnsignedShort>,
+              &GenerateIndicesTest::generateLineLoopIndicesIndexed2D<UnsignedByte>,
               &GenerateIndicesTest::generateLineLoopIndicesWrongVertexCount,
               &GenerateIndicesTest::generateLineLoopIndicesIntoWrongSize,
+              &GenerateIndicesTest::generateLineLoopIndicesIndexed2DInvalid,
 
               &GenerateIndicesTest::generateTriangleStripIndices,
               &GenerateIndicesTest::generateTriangleStripIndicesIndexed<UnsignedInt>,
               &GenerateIndicesTest::generateTriangleStripIndicesIndexed<UnsignedShort>,
               &GenerateIndicesTest::generateTriangleStripIndicesIndexed<UnsignedByte>,
+              &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D<UnsignedInt>,
+              &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D<UnsignedShort>,
+              &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D<UnsignedByte>,
               &GenerateIndicesTest::generateTriangleStripIndicesWrongVertexCount,
               &GenerateIndicesTest::generateTriangleStripIndicesIntoWrongSize,
+              &GenerateIndicesTest::generateTriangleStripIndicesIndexed2DInvalid,
 
               &GenerateIndicesTest::generateTriangleFanIndices,
               &GenerateIndicesTest::generateTriangleFanIndicesIndexed<UnsignedInt>,
               &GenerateIndicesTest::generateTriangleFanIndicesIndexed<UnsignedShort>,
               &GenerateIndicesTest::generateTriangleFanIndicesIndexed<UnsignedByte>,
+              &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D<UnsignedInt>,
+              &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D<UnsignedShort>,
+              &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D<UnsignedByte>,
               &GenerateIndicesTest::generateTriangleFanIndicesWrongVertexCount,
-              &GenerateIndicesTest::generateTriangleFanIndicesIntoWrongSize});
+              &GenerateIndicesTest::generateTriangleFanIndicesIntoWrongSize,
+              &GenerateIndicesTest::generateTriangleFanIndicesIndexed2DInvalid});
 
     addInstancedTests<GenerateIndicesTest>({
         &GenerateIndicesTest::generateQuadIndices<UnsignedInt>,
@@ -363,6 +387,27 @@ template<class T> void GenerateIndicesTest::generateLineStripIndicesIndexed() {
         }), TestSuite::Compare::Container);
 }
 
+template<class T> void GenerateIndicesTest::generateLineStripIndicesIndexed2D() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    /* Subset of the above, testing the empty and non-empty case with a 2D
+       index array */
+    T indexData[]{60, 21, 72, 93, 44, 85};
+    auto indices = Containers::arrayCast<2, char>(Containers::stridedArrayView(indexData));
+
+    CORRADE_COMPARE_AS(MeshTools::generateLineStripIndices(indices.prefix(std::size_t{})),
+        Containers::ArrayView<const UnsignedInt>{},
+        TestSuite::Compare::Container);
+
+    CORRADE_COMPARE_AS(MeshTools::generateLineStripIndices(indices.prefix(5)),
+        Containers::arrayView<UnsignedInt>({
+            60, 21,
+            21, 72,
+            72, 93,
+            93, 44
+        }), TestSuite::Compare::Container);
+}
+
 void GenerateIndicesTest::generateLineStripIndicesWrongVertexCount() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
@@ -396,6 +441,20 @@ void GenerateIndicesTest::generateLineStripIndicesIntoWrongSize() {
         "MeshTools::generateLineStripIndicesInto(): bad output size, expected 8 but got 7\n");
 }
 
+void GenerateIndicesTest::generateLineStripIndicesIndexed2DInvalid() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    char indices[3*4];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    MeshTools::generateLineStripIndices(Containers::StridedArrayView2D<char>{indices, {3, 4}}.every({1, 2}));
+    MeshTools::generateLineStripIndices(Containers::StridedArrayView2D<char>{indices, {4, 3}});
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::generateLineStripIndicesInto(): second index view dimension is not contiguous\n"
+        "MeshTools::generateLineStripIndicesInto(): expected index type size 1, 2 or 4 but got 3\n");
+}
+
 void GenerateIndicesTest::generateLineLoopIndices() {
     /* Empty input */
     CORRADE_COMPARE_AS(MeshTools::generateLineLoopIndices(0),
@@ -474,6 +533,28 @@ template<class T> void GenerateIndicesTest::generateLineLoopIndicesIndexed() {
         }), TestSuite::Compare::Container);
 }
 
+template<class T> void GenerateIndicesTest::generateLineLoopIndicesIndexed2D() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    /* Subset of the above, testing the empty and non-empty case with a 2D
+       index array */
+    T indexData[]{60, 21, 72, 93, 44, 85};
+    auto indices = Containers::arrayCast<2, char>(Containers::arrayView(indexData));
+
+    CORRADE_COMPARE_AS(MeshTools::generateLineLoopIndices(indices.prefix(std::size_t{})),
+        Containers::ArrayView<const UnsignedInt>{},
+        TestSuite::Compare::Container);
+
+    CORRADE_COMPARE_AS(MeshTools::generateLineLoopIndices(indices.prefix(5)),
+        Containers::arrayView<UnsignedInt>({
+            60, 21,
+            21, 72,
+            72, 93,
+            93, 44,
+            44, 60
+        }), TestSuite::Compare::Container);
+}
+
 void GenerateIndicesTest::generateLineLoopIndicesWrongVertexCount() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
@@ -507,6 +588,20 @@ void GenerateIndicesTest::generateLineLoopIndicesIntoWrongSize() {
         "MeshTools::generateLineLoopIndicesInto(): bad output size, expected 10 but got 9\n");
 }
 
+void GenerateIndicesTest::generateLineLoopIndicesIndexed2DInvalid() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    char indices[3*4];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    MeshTools::generateLineLoopIndices(Containers::StridedArrayView2D<char>{indices, {3, 4}}.every({1, 2}));
+    MeshTools::generateLineLoopIndices(Containers::StridedArrayView2D<char>{indices, {4, 3}});
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::generateLineLoopIndicesInto(): second index view dimension is not contiguous\n"
+        "MeshTools::generateLineLoopIndicesInto(): expected index type size 1, 2 or 4 but got 3\n");
+}
+
 void GenerateIndicesTest::generateTriangleStripIndices() {
     /* Empty input */
     CORRADE_COMPARE_AS(MeshTools::generateTriangleStripIndices(0),
@@ -583,6 +678,28 @@ template<class T> void GenerateIndicesTest::generateTriangleStripIndicesIndexed(
         }), TestSuite::Compare::Container);
 }
 
+template<class T> void GenerateIndicesTest::generateTriangleStripIndicesIndexed2D() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    /* Subset of the above, testing the empty and non-empty case with a 2D
+       index array */
+    T indexData[]{60, 21, 72, 93, 44, 85, 36, 17};
+    auto indices = Containers::arrayCast<2, char>(Containers::arrayView(indexData));
+
+    CORRADE_COMPARE_AS(MeshTools::generateTriangleStripIndices(indices.prefix(std::size_t{})),
+        Containers::ArrayView<const UnsignedInt>{},
+        TestSuite::Compare::Container);
+
+    CORRADE_COMPARE_AS(MeshTools::generateTriangleStripIndices(indices.prefix(7)),
+        Containers::arrayView<UnsignedInt>({
+            60, 21, 72,
+            72, 21, 93, /* Reversed */
+            72, 93, 44,
+            44, 93, 85, /* Reversed */
+            44, 85, 36
+        }), TestSuite::Compare::Container);
+}
+
 void GenerateIndicesTest::generateTriangleStripIndicesWrongVertexCount() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
@@ -616,6 +733,20 @@ void GenerateIndicesTest::generateTriangleStripIndicesIntoWrongSize() {
         "MeshTools::generateTriangleStripIndicesInto(): bad output size, expected 9 but got 8\n");
 }
 
+void GenerateIndicesTest::generateTriangleStripIndicesIndexed2DInvalid() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    char indices[3*4];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    MeshTools::generateTriangleStripIndices(Containers::StridedArrayView2D<char>{indices, {3, 4}}.every({1, 2}));
+    MeshTools::generateTriangleStripIndices(Containers::StridedArrayView2D<char>{indices, {4, 3}});
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::generateTriangleStripIndicesInto(): second index view dimension is not contiguous\n"
+        "MeshTools::generateTriangleStripIndicesInto(): expected index type size 1, 2 or 4 but got 3\n");
+}
+
 void GenerateIndicesTest::generateTriangleFanIndices() {
     /* Empty input */
     CORRADE_COMPARE_AS(MeshTools::generateTriangleFanIndices(0),
@@ -692,6 +823,28 @@ template<class T> void GenerateIndicesTest::generateTriangleFanIndicesIndexed()
         }), TestSuite::Compare::Container);
 }
 
+template<class T> void GenerateIndicesTest::generateTriangleFanIndicesIndexed2D() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    /* Subset of the above, testing the empty and non-empty case with a 2D
+       index array */
+    T indexData[]{60, 21, 72, 93, 44, 85, 36, 17};
+    auto indices = Containers::arrayCast<2, char>(Containers::arrayView(indexData));
+
+    CORRADE_COMPARE_AS(MeshTools::generateTriangleFanIndices(indices.prefix(std::size_t{})),
+        Containers::ArrayView<const UnsignedInt>{},
+        TestSuite::Compare::Container);
+
+    CORRADE_COMPARE_AS(MeshTools::generateTriangleFanIndices(indices.prefix(7)),
+        Containers::arrayView<UnsignedInt>({
+            60, 21, 72,
+            60, 72, 93,
+            60, 93, 44,
+            60, 44, 85,
+            60, 85, 36
+        }), TestSuite::Compare::Container);
+}
+
 void GenerateIndicesTest::generateTriangleFanIndicesWrongVertexCount() {
     CORRADE_SKIP_IF_NO_ASSERT();
 
@@ -725,6 +878,20 @@ void GenerateIndicesTest::generateTriangleFanIndicesIntoWrongSize() {
         "MeshTools::generateTriangleFanIndicesInto(): bad output size, expected 9 but got 8\n");
 }
 
+void GenerateIndicesTest::generateTriangleFanIndicesIndexed2DInvalid() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    char indices[3*4];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    MeshTools::generateTriangleFanIndices(Containers::StridedArrayView2D<char>{indices, {3, 4}}.every({1, 2}));
+    MeshTools::generateTriangleFanIndices(Containers::StridedArrayView2D<char>{indices, {4, 3}});
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::generateTriangleFanIndicesInto(): second index view dimension is not contiguous\n"
+        "MeshTools::generateTriangleFanIndicesInto(): expected index type size 1, 2 or 4 but got 3\n");
+}
+
 constexpr Vector3 QuadPositions[] {
     /*
         D    C