ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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

So these can be used directly in the generateIndices() implementation
that takes a MeshData.
pull/601/head
Vladimír Vondruš 3 years ago
parent
cfb5b015f7
commit
d88ec88187
3 changed files with 324 additions and 1 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 68
      src/Magnum/MeshTools/GenerateIndices.cpp
  2. 88
      src/Magnum/MeshTools/GenerateIndices.h
  3. 169
      src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp

68
src/Magnum/MeshTools/GenerateIndices.cpp
Unescape View File

@ -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) {

88
src/Magnum/MeshTools/GenerateIndices.h
Unescape View File

@ -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

169
src/Magnum/MeshTools/Test/GenerateIndicesTest.cpp
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save