Browse Source

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.
pull/229/head
Vladimír Vondruš 7 years ago
parent
commit
1de258a6b2
  1. 9
      doc/changelog.dox
  2. 21
      doc/snippets/MagnumMeshTools.cpp
  3. 8
      src/Magnum/MeshTools/CMakeLists.txt
  4. 39
      src/Magnum/MeshTools/GenerateFlatNormals.h
  5. 38
      src/Magnum/MeshTools/GenerateNormals.cpp
  6. 94
      src/Magnum/MeshTools/GenerateNormals.h
  7. 4
      src/Magnum/MeshTools/Test/CMakeLists.txt
  8. 87
      src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp
  9. 131
      src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp

9
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<UnsignedInt>&, const std::vector<Vector3>&) @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<const Vector3>&)
instead
@subsection changelog-latest-compatibility Potential compatibility breakages, removed APIs

21
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<UnsignedShort> indexData =
{
/* [generateFlatNormals] */
std::vector<UnsignedInt> vertexIndices;
std::vector<Vector3> positions;
Containers::ArrayView<UnsignedInt> indices;
Containers::ArrayView<Vector3> indexedPositions;
std::vector<UnsignedInt> normalIndices;
std::vector<Vector3> normals;
std::tie(normalIndices, normals) =
MeshTools::generateFlatNormals(vertexIndices, positions);
/* [generateFlatNormals] */
Containers::Array<Vector3> positions =
MeshTools::duplicate<UnsignedInt, Vector3>(indices, indexedPositions);
/* [generateFlatNormals-recombine] */
std::vector<UnsignedInt> 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<Vector3> normals =
MeshTools::generateFlatNormals(positions);
/* [generateFlatNormals] */
}
{

8
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

39
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 <tuple>
#include <vector>
#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<UnsignedInt>, std::vector<Vector3>> MAGNUM_MESHTOOLS_EXPORT generateFlatNormals(const std::vector<UnsignedInt>& indices, const std::vector<Vector3>& 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

38
src/Magnum/MeshTools/GenerateFlatNormals.cpp → src/Magnum/MeshTools/GenerateNormals.cpp

@ -23,16 +23,45 @@
DEALINGS IN THE SOFTWARE.
*/
#include "GenerateFlatNormals.h"
#include "GenerateNormals.h"
#include <Corrade/Containers/Array.h>
#include <Corrade/Containers/StridedArrayView.h>
#include "Magnum/Math/Vector3.h"
#ifdef MAGNUM_BUILD_DEPRECATED
#include <vector>
#include "Magnum/MeshTools/Duplicate.h"
#include "Magnum/MeshTools/RemoveDuplicates.h"
#endif
namespace Magnum { namespace MeshTools {
std::tuple<std::vector<UnsignedInt>, std::vector<Vector3>> generateFlatNormals(const std::vector<UnsignedInt>& indices, const std::vector<Vector3>& positions) {
CORRADE_ASSERT(!(indices.size()%3), "MeshTools::generateFlatNormals(): index count is not divisible by 3!", (std::tuple<std::vector<UnsignedInt>, std::vector<Vector3>>()));
void generateFlatNormalsInto(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<Vector3>& 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<Vector3> generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>& positions) {
Containers::Array<Vector3> 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<UnsignedInt>, std::vector<Vector3>> generateFlatNormals(const std::vector<UnsignedInt>& indices, const std::vector<Vector3>& 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<UnsignedInt> normalIndices;
@ -52,7 +81,8 @@ std::tuple<std::vector<UnsignedInt>, std::vector<Vector3>> 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
}}

94
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š <mosra@centrum.cz>
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 <Corrade/Utility/StlForwardVector.h>
#include <Corrade/Utility/Macros.h>
#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<Vector3> generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>& 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<const Vector3>& positions, const Containers::StridedArrayView1D<Vector3>& 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<const Vector3>&).
*/
CORRADE_DEPRECATED("use generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>&) instead") std::pair<std::vector<UnsignedInt>, std::vector<Vector3>> MAGNUM_MESHTOOLS_EXPORT generateFlatNormals(const std::vector<UnsignedInt>& indices, const std::vector<Vector3>& positions);
#endif
}}
#endif

4
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

87
src/Magnum/MeshTools/Test/GenerateFlatNormalsTest.cpp

@ -1,87 +0,0 @@
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Vladimír Vondruš <mosra@centrum.cz>
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 <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/Utility/DebugStl.h>
#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<UnsignedInt> indices;
std::vector<Vector3> 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<UnsignedInt> indices;
std::vector<Vector3> 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<UnsignedInt>{
0, 0, 0,
1, 1, 1
}));
CORRADE_COMPARE(normals, (std::vector<Vector3>{
Vector3::zAxis(),
-Vector3::zAxis()
}));
}
}}}}
CORRADE_TEST_MAIN(Magnum::MeshTools::Test::GenerateFlatNormalsTest)

131
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š <mosra@centrum.cz>
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 <sstream>
#include <vector>
#include <Corrade/Containers/Array.h>
#include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/Utility/DebugStl.h>
#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<Vector3>{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<UnsignedInt> indices;
std::vector<Vector3> 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<UnsignedInt>{
0, 0, 0,
1, 1, 1
}));
CORRADE_COMPARE(normals, (std::vector<Vector3>{
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)
Loading…
Cancel
Save