From 1de258a6b21e16907bcf0d0c3a448278682af4d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Mon, 27 May 2019 10:36:20 +0200 Subject: [PATCH] MeshTools: de-STL-ify generateFlatNormals(). Also move it to a new GenerateNormals.h header so we can easily add generateSmoothNormals() to it. The old API and header is deprecated and will be removed in the future. I can't be bothered rewriting the old code using the new thing, so it's preserved there as a mausoleum until it gets finally nuked from the orbit. --- doc/changelog.dox | 9 ++ doc/snippets/MagnumMeshTools.cpp | 21 ++- src/Magnum/MeshTools/CMakeLists.txt | 8 +- src/Magnum/MeshTools/GenerateFlatNormals.h | 39 ++---- ...ateFlatNormals.cpp => GenerateNormals.cpp} | 38 ++++- src/Magnum/MeshTools/GenerateNormals.h | 94 +++++++++++++ src/Magnum/MeshTools/Test/CMakeLists.txt | 4 +- .../Test/GenerateFlatNormalsTest.cpp | 87 ------------ .../MeshTools/Test/GenerateNormalsTest.cpp | 131 ++++++++++++++++++ 9 files changed, 292 insertions(+), 139 deletions(-) rename src/Magnum/MeshTools/{GenerateFlatNormals.cpp => GenerateNormals.cpp} (59%) create mode 100644 src/Magnum/MeshTools/GenerateNormals.h delete mode 100644 src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp create mode 100644 src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp diff --git a/doc/changelog.dox b/doc/changelog.dox index 8c52a4a5a..5ce2dad2b 100644 --- a/doc/changelog.dox +++ b/doc/changelog.dox @@ -137,6 +137,9 @@ See also: - @ref MeshTools::duplicateInto() alternative to @ref MeshTools::duplicate() that writes the output to an existing location +- @ref MeshTools::generateFlatNormalsInto() alternative to + @ref MeshTools::generateFlatNormals() that writes the output to an existing + location @subsubsection changelog-latest-new-platform Platform libraries @@ -415,6 +418,12 @@ See also: @ref Corrade::Containers::ArrayView. This header is included automatically when @ref MAGNUM_BUILD_DEPRECATED is enabled, include it explicitly to stay forward compatible. +- @cpp Magnum/MeshTools/GenerateFlatNormals.h @ce is deprecated, use + @cpp Magnum/MeshTools/GenerateNormals.h @ce instead +- @cpp MeshTools::generateFlatNormals(const std::vector&, const std::vector&) @ce + is deprecated for doing too many things at once and being too tied to one + particular STL container, use @ref MeshTools::generateFlatNormals(const Containers::StridedArrayView1D&) + instead @subsection changelog-latest-compatibility Potential compatibility breakages, removed APIs diff --git a/doc/snippets/MagnumMeshTools.cpp b/doc/snippets/MagnumMeshTools.cpp index e24f1bbca..ef59b6126 100644 --- a/doc/snippets/MagnumMeshTools.cpp +++ b/doc/snippets/MagnumMeshTools.cpp @@ -29,7 +29,7 @@ #include "Magnum/MeshTools/CombineIndexedArrays.h" #include "Magnum/MeshTools/CompressIndices.h" #include "Magnum/MeshTools/Duplicate.h" -#include "Magnum/MeshTools/GenerateFlatNormals.h" +#include "Magnum/MeshTools/GenerateNormals.h" #include "Magnum/MeshTools/Interleave.h" #include "Magnum/MeshTools/RemoveDuplicates.h" #include "Magnum/MeshTools/Transform.h" @@ -84,20 +84,15 @@ Containers::Array indexData = { /* [generateFlatNormals] */ -std::vector vertexIndices; -std::vector positions; +Containers::ArrayView indices; +Containers::ArrayView indexedPositions; -std::vector normalIndices; -std::vector normals; -std::tie(normalIndices, normals) = - MeshTools::generateFlatNormals(vertexIndices, positions); -/* [generateFlatNormals] */ +Containers::Array positions = + MeshTools::duplicate(indices, indexedPositions); -/* [generateFlatNormals-recombine] */ -std::vector indices = MeshTools::combineIndexedArrays( - std::make_pair(std::cref(vertexIndices), std::ref(positions)), - std::make_pair(std::cref(normalIndices), std::ref(normals))); -/* [generateFlatNormals-recombine] */ +Containers::Array normals = + MeshTools::generateFlatNormals(positions); +/* [generateFlatNormals] */ } { diff --git a/src/Magnum/MeshTools/CMakeLists.txt b/src/Magnum/MeshTools/CMakeLists.txt index 4f2e74c44..d23487fdb 100644 --- a/src/Magnum/MeshTools/CMakeLists.txt +++ b/src/Magnum/MeshTools/CMakeLists.txt @@ -32,14 +32,14 @@ set(MagnumMeshTools_GracefulAssert_SRCS CombineIndexedArrays.cpp CompressIndices.cpp FlipNormals.cpp - GenerateFlatNormals.cpp) + GenerateNormals.cpp) set(MagnumMeshTools_HEADERS CombineIndexedArrays.h CompressIndices.h Duplicate.h FlipNormals.h - GenerateFlatNormals.h + GenerateNormals.h Interleave.h RemoveDuplicates.h Subdivide.h @@ -48,6 +48,10 @@ set(MagnumMeshTools_HEADERS visibility.h) +if(BUILD_DEPRECATED) + list(APPEND MagnumMeshTools_HEADERS GenerateFlatNormals.h) +endif() + if(TARGET_GL) list(APPEND MagnumMeshTools_SRCS Compile.cpp diff --git a/src/Magnum/MeshTools/GenerateFlatNormals.h b/src/Magnum/MeshTools/GenerateFlatNormals.h index fa9061dce..bc0baef3d 100644 --- a/src/Magnum/MeshTools/GenerateFlatNormals.h +++ b/src/Magnum/MeshTools/GenerateFlatNormals.h @@ -26,39 +26,16 @@ */ /** @file - * @brief Function @ref Magnum::MeshTools::generateFlatNormals() + * @deprecated Use @ref Magnum/MeshTools/GenerateNormals.h instead. */ -#include -#include +#include "Magnum/configure.h" -#include "Magnum/Magnum.h" -#include "Magnum/MeshTools/visibility.h" - -namespace Magnum { namespace MeshTools { - -/** -@brief Generate flat normals -@param indices Array of triangle face indices -@param positions Array of vertex positions -@return Normal indices and vectors - -All vertices in each triangle face get the same normal vector. Removes -duplicates before returning. Example usage: - -@snippet MagnumMeshTools.cpp generateFlatNormals - -This will generate index buffer that's different from the input @p indices -array, so you'll need to recombine them using @ref combineIndexedArrays() in -order to have a single index array for both vertices and normals: - -@snippet MagnumMeshTools.cpp generateFlatNormals-recombine - -@attention The function requires the mesh to have triangle faces, thus index - count must be divisible by 3. -*/ -std::tuple, std::vector> MAGNUM_MESHTOOLS_EXPORT generateFlatNormals(const std::vector& indices, const std::vector& positions); - -}} +#ifdef MAGNUM_BUILD_DEPRECATED +#include "Magnum/MeshTools/GenerateNormals.h" +CORRADE_DEPRECATED_FILE("use Magnum/MeshTools/GenerateNormals.h instead") +#else +#error use Magnum/MeshTools/GenerateNormals.h instead +#endif #endif diff --git a/src/Magnum/MeshTools/GenerateFlatNormals.cpp b/src/Magnum/MeshTools/GenerateNormals.cpp similarity index 59% rename from src/Magnum/MeshTools/GenerateFlatNormals.cpp rename to src/Magnum/MeshTools/GenerateNormals.cpp index e7560194d..08691fb1e 100644 --- a/src/Magnum/MeshTools/GenerateFlatNormals.cpp +++ b/src/Magnum/MeshTools/GenerateNormals.cpp @@ -23,16 +23,45 @@ DEALINGS IN THE SOFTWARE. */ -#include "GenerateFlatNormals.h" +#include "GenerateNormals.h" + +#include +#include #include "Magnum/Math/Vector3.h" + +#ifdef MAGNUM_BUILD_DEPRECATED +#include + #include "Magnum/MeshTools/Duplicate.h" #include "Magnum/MeshTools/RemoveDuplicates.h" +#endif namespace Magnum { namespace MeshTools { -std::tuple, std::vector> generateFlatNormals(const std::vector& indices, const std::vector& positions) { - CORRADE_ASSERT(!(indices.size()%3), "MeshTools::generateFlatNormals(): index count is not divisible by 3!", (std::tuple, std::vector>())); +void generateFlatNormalsInto(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& normals) { + CORRADE_ASSERT(positions.size() % 3 == 0, + "MeshTools::generateFlatNormalsInto(): position count not divisible by 3", ); + CORRADE_ASSERT(normals.size() == positions.size(), + "MeshTools::generateFlatNormalsInto(): bad output size, expected" << positions.size() << "but got" << normals.size(), ); + + for(std::size_t i = 0; i != positions.size(); i += 3) + normals[i] = normals[i + 1] = normals[i + 2] = Math::cross( + positions[i + 2] - positions[i + 1], + positions[i] - positions[i+1]).normalized(); +} + +Containers::Array generateFlatNormals(const Containers::StridedArrayView1D& positions) { + Containers::Array out{Containers::NoInit, positions.size()}; + generateFlatNormalsInto(positions, Containers::arrayView(out)); + return out; +} + +#ifdef MAGNUM_BUILD_DEPRECATED +/* Original implementation kept verbatim as I can't be bothered rewriting it + using the new APIs (the original test is kept as well) */ +std::pair, std::vector> generateFlatNormals(const std::vector& indices, const std::vector& positions) { + CORRADE_ASSERT(!(indices.size()%3), "MeshTools::generateFlatNormals(): index count is not divisible by 3!", {}); /* Create normal for every triangle (assuming counterclockwise winding) */ std::vector normalIndices; @@ -52,7 +81,8 @@ std::tuple, std::vector> generateFlatNormals(c /* Remove duplicate normals and return */ normalIndices = MeshTools::duplicate(normalIndices, MeshTools::removeDuplicates(normals)); - return std::make_tuple(std::move(normalIndices), std::move(normals)); + return {std::move(normalIndices), std::move(normals)}; } +#endif }} diff --git a/src/Magnum/MeshTools/GenerateNormals.h b/src/Magnum/MeshTools/GenerateNormals.h new file mode 100644 index 000000000..e1ffe8787 --- /dev/null +++ b/src/Magnum/MeshTools/GenerateNormals.h @@ -0,0 +1,94 @@ +#ifndef Magnum_MeshTools_GenerateNormals_h +#define Magnum_MeshTools_GenerateNormals_h +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 + Vladimír Vondruš + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +/** @file + * @brief Function @ref Magnum::MeshTools::generateFlatNormals(), @ref Magnum::MeshTools::generateFlatNormalsInto() + */ + +#include "Magnum/Magnum.h" +#include "Magnum/MeshTools/visibility.h" + +#ifdef MAGNUM_BUILD_DEPRECATED +#include +#include +#endif + +namespace Magnum { namespace MeshTools { + +/** +@brief Generate flat normals +@param positions Triangle vertex positions +@return Per-vertex normals + +All vertices in each triangle face get the same normal vector. Expects that the +position count is divisible by 3. If you need to generate flat normals for an +indexed mesh, @ref duplicate() the vertices first, after the operation you +might want to remove the duplicates again using @ref removeDuplicates(). +Example usage: + +@snippet MagnumMeshTools.cpp generateFlatNormals + +@see @ref generateFlatNormalsInto() +*/ +MAGNUM_MESHTOOLS_EXPORT Containers::Array generateFlatNormals(const Containers::StridedArrayView1D& positions); + +/** +@brief Generate flat normals into an existing array +@param[in] positions Triangle vertex positions +@param[out] normals Where to put the generated normals + +A variant of @ref generateFlatNormals() that fills existing memory instead of +allocating a new array. +*/ +MAGNUM_MESHTOOLS_EXPORT void generateFlatNormalsInto(const Containers::StridedArrayView1D& positions, const Containers::StridedArrayView1D& normals); + +#ifdef MAGNUM_BUILD_DEPRECATED +/** +@brief Generate flat normals +@param indices Array of triangle face indices +@param positions Array of vertex positions +@return Normal indices and vectors + +All vertices in each triangle face get the same normal vector. Removes +duplicates before returning. + +@attention The function requires the mesh to have triangle faces, thus index + count must be divisible by 3. + +@deprecated This will generate index buffer that's different from the input + @p indices array, so you'll need to recombine them using + @ref combineIndexedArrays() in order to have a single index array for both + vertices and normals. Because this makes the usage more complex than + strictly neccessary, this function is deprecated in favor of + @ref generateFlatNormals(const Containers::StridedArrayView1D&). +*/ +CORRADE_DEPRECATED("use generateFlatNormals(const Containers::StridedArrayView1D&) instead") std::pair, std::vector> MAGNUM_MESHTOOLS_EXPORT generateFlatNormals(const std::vector& indices, const std::vector& positions); +#endif + +}} + +#endif diff --git a/src/Magnum/MeshTools/Test/CMakeLists.txt b/src/Magnum/MeshTools/Test/CMakeLists.txt index e5ffaa63a..5ccfcd85b 100644 --- a/src/Magnum/MeshTools/Test/CMakeLists.txt +++ b/src/Magnum/MeshTools/Test/CMakeLists.txt @@ -27,7 +27,7 @@ corrade_add_test(MeshToolsCombineIndexedArraysTest CombineIndexedArraysTest.cpp corrade_add_test(MeshToolsCompressIndicesTest CompressIndicesTest.cpp LIBRARIES MagnumMeshToolsTestLib) corrade_add_test(MeshToolsDuplicateTest DuplicateTest.cpp LIBRARIES Magnum) corrade_add_test(MeshToolsFlipNormalsTest FlipNormalsTest.cpp LIBRARIES MagnumMeshToolsTestLib) -corrade_add_test(MeshToolsGenerateFlatNormalsTest GenerateFlatNormalsTest.cpp LIBRARIES MagnumMeshToolsTestLib) +corrade_add_test(MeshToolsGenerateNormalsTest GenerateNormalsTest.cpp LIBRARIES MagnumMeshToolsTestLib) corrade_add_test(MeshToolsInterleaveTest InterleaveTest.cpp LIBRARIES Magnum) corrade_add_test(MeshToolsRemoveDuplicatesTest RemoveDuplicatesTest.cpp LIBRARIES Magnum) corrade_add_test(MeshToolsSubdivideTest SubdivideTest.cpp LIBRARIES Magnum) @@ -47,7 +47,7 @@ set_target_properties( MeshToolsCompressIndicesTest MeshToolsDuplicateTest MeshToolsFlipNormalsTest - MeshToolsGenerateFlatNormalsTest + MeshToolsGenerateNormalsTest MeshToolsInterleaveTest MeshToolsRemoveDuplicatesTest MeshToolsSubdivideTest diff --git a/src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp b/src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp deleted file mode 100644 index 4344d8a5f..000000000 --- a/src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp +++ /dev/null @@ -1,87 +0,0 @@ -/* - This file is part of Magnum. - - Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 - Vladimír Vondruš - - Permission is hereby granted, free of charge, to any person obtaining a - copy of this software and associated documentation files (the "Software"), - to deal in the Software without restriction, including without limitation - the rights to use, copy, modify, merge, publish, distribute, sublicense, - and/or sell copies of the Software, and to permit persons to whom the - Software is furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included - in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - DEALINGS IN THE SOFTWARE. -*/ - -#include -#include -#include - -#include "Magnum/Math/Vector3.h" -#include "Magnum/MeshTools/GenerateFlatNormals.h" - -namespace Magnum { namespace MeshTools { namespace Test { namespace { - -struct GenerateFlatNormalsTest: TestSuite::Tester { - explicit GenerateFlatNormalsTest(); - - void wrongIndexCount(); - void generate(); -}; - -GenerateFlatNormalsTest::GenerateFlatNormalsTest() { - addTests({&GenerateFlatNormalsTest::wrongIndexCount, - &GenerateFlatNormalsTest::generate}); -} - -void GenerateFlatNormalsTest::wrongIndexCount() { - std::stringstream ss; - Error redirectError{&ss}; - std::vector indices; - std::vector normals; - std::tie(indices, normals) = MeshTools::generateFlatNormals({ - 0, 1 - }, {}); - - CORRADE_COMPARE(indices.size(), 0); - CORRADE_COMPARE(normals.size(), 0); - CORRADE_COMPARE(ss.str(), "MeshTools::generateFlatNormals(): index count is not divisible by 3!\n"); -} - -void GenerateFlatNormalsTest::generate() { - /* Two vertices connected by one edge, each winded in another direction */ - std::vector indices; - std::vector normals; - std::tie(indices, normals) = MeshTools::generateFlatNormals({ - 0, 1, 2, - 1, 2, 3 - }, { - {-1.0f, 0.0f, 0.0f}, - {0.0f, -1.0f, 0.0f}, - {0.0f, 1.0f, 0.0f}, - {1.0f, 0.0f, 0.0f} - }); - - CORRADE_COMPARE(indices, (std::vector{ - 0, 0, 0, - 1, 1, 1 - })); - CORRADE_COMPARE(normals, (std::vector{ - Vector3::zAxis(), - -Vector3::zAxis() - })); -} - -}}}} - -CORRADE_TEST_MAIN(Magnum::MeshTools::Test::GenerateFlatNormalsTest) diff --git a/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp b/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp new file mode 100644 index 000000000..13eaa676a --- /dev/null +++ b/src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp @@ -0,0 +1,131 @@ +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 + Vladimír Vondruš + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "Magnum/Math/Vector3.h" +#include "Magnum/MeshTools/GenerateNormals.h" + +namespace Magnum { namespace MeshTools { namespace Test { namespace { + +struct GenerateNormalsTest: TestSuite::Tester { + explicit GenerateNormalsTest(); + + void flat(); + void flatWrongCount(); + #ifdef MAGNUM_BUILD_DEPRECATED + void flatDeprecated(); + #endif + void flatIntoWrongSize(); +}; + +GenerateNormalsTest::GenerateNormalsTest() { + addTests({&GenerateNormalsTest::flat, + &GenerateNormalsTest::flatWrongCount, + #ifdef MAGNUM_BUILD_DEPRECATED + &GenerateNormalsTest::flatDeprecated, + #endif + &GenerateNormalsTest::flatIntoWrongSize}); +} + +/* Two vertices connected by one edge, each wound in another direction */ +constexpr Vector3 TwoTriangles[]{ + {-1.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + + {0.0f, -1.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {1.0f, 0.0f, 0.0f} +}; + +void GenerateNormalsTest::flat() { + CORRADE_COMPARE_AS(generateFlatNormals(TwoTriangles), + (Containers::Array{Containers::InPlaceInit, { + Vector3::zAxis(), + Vector3::zAxis(), + Vector3::zAxis(), + -Vector3::zAxis(), + -Vector3::zAxis(), + -Vector3::zAxis() + }}), TestSuite::Compare::Container); +} + +void GenerateNormalsTest::flatWrongCount() { + std::stringstream out; + Error redirectError{&out}; + + const Vector3 positions[7]; + generateFlatNormals(positions); + CORRADE_COMPARE(out.str(), "MeshTools::generateFlatNormalsInto(): position count not divisible by 3\n"); +} + +#ifdef MAGNUM_BUILD_DEPRECATED +void GenerateNormalsTest::flatDeprecated() { + /* Two vertices connected by one edge, each wound in another direction */ + std::vector indices; + std::vector normals; + CORRADE_IGNORE_DEPRECATED_PUSH + std::tie(indices, normals) = MeshTools::generateFlatNormals({ + 0, 1, 2, + 1, 2, 3 + }, { + {-1.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {1.0f, 0.0f, 0.0f} + }); + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(indices, (std::vector{ + 0, 0, 0, + 1, 1, 1 + })); + CORRADE_COMPARE(normals, (std::vector{ + Vector3::zAxis(), + -Vector3::zAxis() + })); +} +#endif + +void GenerateNormalsTest::flatIntoWrongSize() { + std::stringstream out; + Error redirectError{&out}; + + const Vector3 positions[6]; + Vector3 normals[7]; + generateFlatNormalsInto(positions, normals); + CORRADE_COMPARE(out.str(), "MeshTools::generateFlatNormalsInto(): bad output size, expected 6 but got 7\n"); +} + +}}}} + +CORRADE_TEST_MAIN(Magnum::MeshTools::Test::GenerateNormalsTest)