From d88ec881877fa3ad900ffba70ed141264100b48d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Tue, 24 Jan 2023 18:17:55 +0100 Subject: [PATCH] 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 | 68 +++++++ src/Magnum/MeshTools/GenerateIndices.h | 88 +++++++++ .../MeshTools/Test/GenerateIndicesTest.cpp | 169 +++++++++++++++++- 3 files changed, 324 insertions(+), 1 deletion(-) diff --git a/src/Magnum/MeshTools/GenerateIndices.cpp b/src/Magnum/MeshTools/GenerateIndices.cpp index 1573c6e4f..24423b693 100644 --- a/src/Magnum/MeshTools/GenerateIndices.cpp +++ b/src/Magnum/MeshTools/GenerateIndices.cpp @@ -136,6 +136,17 @@ void generateLineStripIndicesInto(const Containers::StridedArrayView1D& indices, const Containers::StridedArrayView1D& 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 generateLineStripIndices(const UnsignedInt vertexCount) { Containers::Array output{NoInit, 2*(Math::max(vertexCount, 1u) - 1)}; generateLineStripIndicesInto(vertexCount, output); @@ -160,6 +171,12 @@ Containers::Array generateLineStripIndices(const Containers::Stride return output; } +Containers::Array generateLineStripIndices(const Containers::StridedArrayView2D& indices) { + Containers::Array 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& 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& indices, const Containers::StridedArrayView1D& 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 generateLineLoopIndices(const UnsignedInt vertexCount) { Containers::Array output{NoInit, 2*vertexCount}; generateLineLoopIndicesInto(vertexCount, output); @@ -243,6 +271,12 @@ Containers::Array generateLineLoopIndices(const Containers::Strided return output; } +Containers::Array generateLineLoopIndices(const Containers::StridedArrayView2D& indices) { + Containers::Array output{NoInit, 2*indices.size()[0]}; + generateLineLoopIndicesInto(indices, output); + return output; +} + void generateTriangleStripIndicesInto(const UnsignedInt vertexCount, const Containers::StridedArrayView1D& 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& indices, const Containers::StridedArrayView1D& 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 generateTriangleStripIndices(const UnsignedInt vertexCount) { Containers::Array output{NoInit, 3*(Math::max(vertexCount, 2u) - 2u)}; generateTriangleStripIndicesInto(vertexCount, output); @@ -325,6 +370,12 @@ Containers::Array generateTriangleStripIndices(const Containers::St return output; } +Containers::Array generateTriangleStripIndices(const Containers::StridedArrayView2D& indices) { + Containers::Array 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& 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& indices, const Containers::StridedArrayView1D& 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 generateTriangleFanIndices(const UnsignedInt vertexCount) { Containers::Array output{NoInit, 3*(Math::max(vertexCount, 2u) - 2)}; generateTriangleFanIndicesInto(vertexCount, output); @@ -408,6 +470,12 @@ Containers::Array generateTriangleFanIndices(const Containers::Stri return output; } +Containers::Array generateTriangleFanIndices(const Containers::StridedArrayView2D& indices) { + Containers::Array output{NoInit, 3*(Math::max(indices.size()[0], std::size_t{2}) - 2)}; + generateTriangleFanIndicesInto(indices, output); + return output; +} + namespace { template inline void generateQuadIndicesIntoImplementation(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& quads, const Containers::StridedArrayView1D& output) { diff --git a/src/Magnum/MeshTools/GenerateIndices.h b/src/Magnum/MeshTools/GenerateIndices.h index fda1245b4..ff23b459c 100644 --- a/src/Magnum/MeshTools/GenerateIndices.h +++ b/src/Magnum/MeshTools/GenerateIndices.h @@ -85,6 +85,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineStripIndices( */ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineStripIndices(const Containers::StridedArrayView1D& 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&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineStripIndices(const Containers::StridedArrayView2D& 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& indices, const Containers::StridedArrayView1D& 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 Containers::StridedArrayView1D&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT void generateLineStripIndicesInto(const Containers::StridedArrayView2D& indices, const Containers::StridedArrayView1D& output); + /** @brief Create index buffer for a line loop primitive @m_since{2020,06} @@ -155,6 +177,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineLoopIndices(c */ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineLoopIndices(const Containers::StridedArrayView1D& 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&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT Containers::Array generateLineLoopIndices(const Containers::StridedArrayView2D& 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& indices, const Containers::StridedArrayView1D& 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 Containers::StridedArrayView1D&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT void generateLineLoopIndicesInto(const Containers::StridedArrayView2D& indices, const Containers::StridedArrayView1D& output); + /** @brief Create index buffer for a triangle strip primitive @m_since{2020,06} @@ -225,6 +269,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleStripIndi */ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleStripIndices(const Containers::StridedArrayView1D& 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&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleStripIndices(const Containers::StridedArrayView2D& 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& indices, const Containers::StridedArrayView1D& 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 Containers::StridedArrayView1D&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT void generateTriangleStripIndicesInto(const Containers::StridedArrayView2D& indices, const Containers::StridedArrayView1D& output); + /** @brief Create index buffer for a triangle fan primitive @m_since{2020,06} @@ -295,6 +361,17 @@ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleFanIndice */ MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleFanIndices(const Containers::StridedArrayView1D& 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&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT Containers::Array generateTriangleFanIndices(const Containers::StridedArrayView2D& 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& indices, const Containers::StridedArrayView1D& 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 Containers::StridedArrayView1D&) +etc. overloads. +*/ +MAGNUM_MESHTOOLS_EXPORT void generateTriangleFanIndicesInto(const Containers::StridedArrayView2D& indices, const Containers::StridedArrayView1D& output); + /** @brief Create a triangle index buffer for quad primitives @m_since_latest diff --git a/src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp b/src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp index 3347c3eb7..a249ef80b 100644 --- a/src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp +++ b/src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp @@ -47,23 +47,31 @@ struct GenerateIndicesTest: TestSuite::Tester { void generateLineStripIndices(); template void generateLineStripIndicesIndexed(); + template void generateLineStripIndicesIndexed2D(); void generateLineStripIndicesWrongVertexCount(); void generateLineStripIndicesIntoWrongSize(); + void generateLineStripIndicesIndexed2DInvalid(); void generateLineLoopIndices(); template void generateLineLoopIndicesIndexed(); + template void generateLineLoopIndicesIndexed2D(); void generateLineLoopIndicesWrongVertexCount(); void generateLineLoopIndicesIntoWrongSize(); + void generateLineLoopIndicesIndexed2DInvalid(); void generateTriangleStripIndices(); template void generateTriangleStripIndicesIndexed(); + template void generateTriangleStripIndicesIndexed2D(); void generateTriangleStripIndicesWrongVertexCount(); void generateTriangleStripIndicesIntoWrongSize(); + void generateTriangleStripIndicesIndexed2DInvalid(); void generateTriangleFanIndices(); template void generateTriangleFanIndicesIndexed(); + template void generateTriangleFanIndicesIndexed2D(); void generateTriangleFanIndicesWrongVertexCount(); void generateTriangleFanIndicesIntoWrongSize(); + void generateTriangleFanIndicesIndexed2DInvalid(); template void generateQuadIndices(); template void generateQuadIndicesInto(); @@ -187,29 +195,45 @@ GenerateIndicesTest::GenerateIndicesTest() { &GenerateIndicesTest::generateLineStripIndicesIndexed, &GenerateIndicesTest::generateLineStripIndicesIndexed, &GenerateIndicesTest::generateLineStripIndicesIndexed, + &GenerateIndicesTest::generateLineStripIndicesIndexed2D, + &GenerateIndicesTest::generateLineStripIndicesIndexed2D, + &GenerateIndicesTest::generateLineStripIndicesIndexed2D, &GenerateIndicesTest::generateLineStripIndicesWrongVertexCount, &GenerateIndicesTest::generateLineStripIndicesIntoWrongSize, + &GenerateIndicesTest::generateLineStripIndicesIndexed2DInvalid, &GenerateIndicesTest::generateLineLoopIndices, &GenerateIndicesTest::generateLineLoopIndicesIndexed, &GenerateIndicesTest::generateLineLoopIndicesIndexed, &GenerateIndicesTest::generateLineLoopIndicesIndexed, + &GenerateIndicesTest::generateLineLoopIndicesIndexed2D, + &GenerateIndicesTest::generateLineLoopIndicesIndexed2D, + &GenerateIndicesTest::generateLineLoopIndicesIndexed2D, &GenerateIndicesTest::generateLineLoopIndicesWrongVertexCount, &GenerateIndicesTest::generateLineLoopIndicesIntoWrongSize, + &GenerateIndicesTest::generateLineLoopIndicesIndexed2DInvalid, &GenerateIndicesTest::generateTriangleStripIndices, &GenerateIndicesTest::generateTriangleStripIndicesIndexed, &GenerateIndicesTest::generateTriangleStripIndicesIndexed, &GenerateIndicesTest::generateTriangleStripIndicesIndexed, + &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D, + &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D, + &GenerateIndicesTest::generateTriangleStripIndicesIndexed2D, &GenerateIndicesTest::generateTriangleStripIndicesWrongVertexCount, &GenerateIndicesTest::generateTriangleStripIndicesIntoWrongSize, + &GenerateIndicesTest::generateTriangleStripIndicesIndexed2DInvalid, &GenerateIndicesTest::generateTriangleFanIndices, &GenerateIndicesTest::generateTriangleFanIndicesIndexed, &GenerateIndicesTest::generateTriangleFanIndicesIndexed, &GenerateIndicesTest::generateTriangleFanIndicesIndexed, + &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D, + &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D, + &GenerateIndicesTest::generateTriangleFanIndicesIndexed2D, &GenerateIndicesTest::generateTriangleFanIndicesWrongVertexCount, - &GenerateIndicesTest::generateTriangleFanIndicesIntoWrongSize}); + &GenerateIndicesTest::generateTriangleFanIndicesIntoWrongSize, + &GenerateIndicesTest::generateTriangleFanIndicesIndexed2DInvalid}); addInstancedTests({ &GenerateIndicesTest::generateQuadIndices, @@ -363,6 +387,27 @@ template void GenerateIndicesTest::generateLineStripIndicesIndexed() { }), TestSuite::Compare::Container); } +template void GenerateIndicesTest::generateLineStripIndicesIndexed2D() { + setTestCaseTemplateName(Math::TypeTraits::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{}, + TestSuite::Compare::Container); + + CORRADE_COMPARE_AS(MeshTools::generateLineStripIndices(indices.prefix(5)), + Containers::arrayView({ + 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{indices, {3, 4}}.every({1, 2})); + MeshTools::generateLineStripIndices(Containers::StridedArrayView2D{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 void GenerateIndicesTest::generateLineLoopIndicesIndexed() { }), TestSuite::Compare::Container); } +template void GenerateIndicesTest::generateLineLoopIndicesIndexed2D() { + setTestCaseTemplateName(Math::TypeTraits::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{}, + TestSuite::Compare::Container); + + CORRADE_COMPARE_AS(MeshTools::generateLineLoopIndices(indices.prefix(5)), + Containers::arrayView({ + 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{indices, {3, 4}}.every({1, 2})); + MeshTools::generateLineLoopIndices(Containers::StridedArrayView2D{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 void GenerateIndicesTest::generateTriangleStripIndicesIndexed( }), TestSuite::Compare::Container); } +template void GenerateIndicesTest::generateTriangleStripIndicesIndexed2D() { + setTestCaseTemplateName(Math::TypeTraits::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{}, + TestSuite::Compare::Container); + + CORRADE_COMPARE_AS(MeshTools::generateTriangleStripIndices(indices.prefix(7)), + Containers::arrayView({ + 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{indices, {3, 4}}.every({1, 2})); + MeshTools::generateTriangleStripIndices(Containers::StridedArrayView2D{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 void GenerateIndicesTest::generateTriangleFanIndicesIndexed() }), TestSuite::Compare::Container); } +template void GenerateIndicesTest::generateTriangleFanIndicesIndexed2D() { + setTestCaseTemplateName(Math::TypeTraits::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{}, + TestSuite::Compare::Container); + + CORRADE_COMPARE_AS(MeshTools::generateTriangleFanIndices(indices.prefix(7)), + Containers::arrayView({ + 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{indices, {3, 4}}.every({1, 2})); + MeshTools::generateTriangleFanIndices(Containers::StridedArrayView2D{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