mirror of https://github.com/mosra/magnum.git
Vladimír Vondruš
4 years ago
7 changed files with 637 additions and 13 deletions
@ -0,0 +1,65 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021 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 <Corrade/Containers/Array.h> |
||||
#include <Corrade/Containers/Pair.h> |
||||
|
||||
#include "Magnum/Math/Matrix4.h" |
||||
#include "Magnum/SceneTools/OrderClusterParents.h" |
||||
#include "Magnum/Trade/SceneData.h" |
||||
|
||||
#define DOXYGEN_ELLIPSIS(...) __VA_ARGS__ |
||||
|
||||
using namespace Magnum; |
||||
|
||||
int main() { |
||||
{ |
||||
/* [orderClusterParents-transformations] */ |
||||
Trade::SceneData scene = DOXYGEN_ELLIPSIS(Trade::SceneData{{}, 0, nullptr, {}}); |
||||
|
||||
/* Put all transformations into an array indexed by object ID. Objects
|
||||
implicitly have an identity transformation, first element is reserved for |
||||
the global transformation. */ |
||||
Containers::Array<Matrix4> transformations{std::size_t(scene.mappingBound() + 1)}; |
||||
for(const Containers::Pair<UnsignedInt, Matrix4>& transformation: |
||||
scene.transformations3DAsArray()) |
||||
{ |
||||
transformations[transformation.first() + 1] = transformation.second(); |
||||
} |
||||
|
||||
/* Go through ordered parents and compose absolute transformations for all
|
||||
nodes in the hierarchy, objects in the root use transformations[0]. The |
||||
function ensures that the parent transformation is already calculated when |
||||
referenced by child nodes. */ |
||||
for(const Containers::Pair<UnsignedInt, Int>& parent: |
||||
SceneTools::orderClusterParents(scene)) |
||||
{ |
||||
transformations[parent.first() + 1] = |
||||
transformations[parent.second() + 1]* |
||||
transformations[parent.first() + 1]; |
||||
} |
||||
/* [orderClusterParents-transformations] */ |
||||
} |
||||
} |
||||
@ -0,0 +1,122 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021 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 "OrderClusterParents.h" |
||||
|
||||
#include <Corrade/Containers/Array.h> |
||||
#include <Corrade/Containers/GrowableArray.h> |
||||
#include <Corrade/Containers/Optional.h> |
||||
#include <Corrade/Containers/Pair.h> |
||||
|
||||
#include "Magnum/Trade/SceneData.h" |
||||
|
||||
namespace Magnum { namespace SceneTools { |
||||
|
||||
Containers::Array<Containers::Pair<UnsignedInt, Int>> orderClusterParents(const Trade::SceneData& scene) { |
||||
const Containers::Optional<UnsignedInt> parentFieldId = scene.findFieldId(Trade::SceneField::Parent); |
||||
CORRADE_ASSERT(parentFieldId, |
||||
"SceneTools::orderClusterParents(): the scene has no hierarchy", {}); |
||||
Containers::Array<Containers::Pair<UnsignedInt, Int>> out{NoInit, scene.fieldSize(*parentFieldId)}; |
||||
Containers::StridedArrayView1D<UnsignedInt> mapping{out, &out.data()->first(), out.size(), sizeof(decltype(out)::Type)}; |
||||
Containers::StridedArrayView1D<Int> parentOffset{out, &out.data()->second(), out.size(), sizeof(decltype(out)::Type)}; |
||||
orderClusterParentsInto(scene, mapping, parentOffset); |
||||
return out; |
||||
} |
||||
|
||||
void orderClusterParentsInto(const Trade::SceneData& scene, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& parentDestination) { |
||||
#ifndef CORRADE_NO_ASSERT |
||||
const Containers::Optional<UnsignedInt> parentFieldId = scene.findFieldId(Trade::SceneField::Parent); |
||||
CORRADE_ASSERT(parentFieldId, |
||||
"SceneTools::orderClusterParentsInto(): the scene has no hierarchy", ); |
||||
const std::size_t parentFieldSize = scene.fieldSize(*parentFieldId); |
||||
CORRADE_ASSERT(mappingDestination.size() == parentFieldSize, |
||||
"SceneTools::orderClusterParentsInto(): expected mapping destination view with" << parentFieldSize << "elements but got" << mappingDestination.size(), ); |
||||
CORRADE_ASSERT(parentDestination.size() == scene.fieldSize(*parentFieldId), |
||||
"SceneTools::orderClusterParentsInto(): expected parent destination view with" << parentFieldSize << "elements but got" << parentDestination.size(), ); |
||||
#endif |
||||
|
||||
/* Convert the parent list to a child list to sort them toplogically */ |
||||
const Containers::Array<Containers::Pair<UnsignedInt, Int>> parents = scene.parentsAsArray(); |
||||
|
||||
/* Children offset for each node including root. First calculate the count
|
||||
of children for each ... */ |
||||
Containers::Array<UnsignedInt> childrenOffsets{DirectInit, scene.mappingBound() + 2, 0u}; |
||||
for(const Containers::Pair<UnsignedInt, Int>& parent: parents) { |
||||
CORRADE_INTERNAL_ASSERT(parent.first() < scene.mappingBound() && (parent.second() == -1 || UnsignedInt(parent.second()) < scene.mappingBound())); |
||||
++childrenOffsets[parent.second() + 1]; |
||||
} |
||||
|
||||
/* ... then convert the counts to a running offset. Now
|
||||
`[childrenOffsets[i + 1], childrenOffsets[i + 2])` contains a range in |
||||
which the `children` array below contains a list of children for `i`. */ |
||||
UnsignedInt offset = 0; |
||||
for(UnsignedInt& i: childrenOffsets) { |
||||
UnsignedInt nextOffset = offset + i; |
||||
i = offset; |
||||
offset = nextOffset; |
||||
} |
||||
CORRADE_INTERNAL_ASSERT(offset == parents.size()); |
||||
|
||||
/* Go through the parent list again, convert that to child ranges */ |
||||
Containers::Array<UnsignedInt> children{NoInit, parents.size()}; |
||||
{ |
||||
Containers::Array<UnsignedInt> currentChildrenOffsets{DirectInit, scene.mappingBound() + 1, 0u}; |
||||
for(const Containers::Pair<UnsignedInt, Int>& parent: parents) { |
||||
UnsignedInt& currentChildrenOffset = currentChildrenOffsets[parent.second() + 1]; |
||||
children[childrenOffsets[parent.second() + 1] + currentChildrenOffset] = parent.first(); |
||||
++currentChildrenOffset; |
||||
} |
||||
} |
||||
|
||||
/* Go breadth-first (so we have nodes sharing the same parent next to each
|
||||
other) and build a list of (id, parent id) where a parent is always |
||||
before its children */ |
||||
std::size_t outputOffset = 0; |
||||
Containers::Array<Int> parentsToProcess; |
||||
arrayAppend(parentsToProcess, -1); |
||||
for(std::size_t i = 0; i != parentsToProcess.size(); ++i) { |
||||
const Int objectId = parentsToProcess[i]; |
||||
for(std::size_t j = childrenOffsets[objectId + 1], jMax = childrenOffsets[objectId + 2]; j != jMax; ++j) { |
||||
/** @todo better diagnostic once we can use a BitArray to detect
|
||||
which nodes are parented more than once (OTOH maybe that's |
||||
unnecessary extra work which isn't desired to be done here but |
||||
should be instead in a dedicated cycle/sparse checker utility?) */ |
||||
CORRADE_ASSERT_OUTPUT(outputOffset < parents.size(), |
||||
"SceneTools::orderClusterParents(): hierarchy is cyclic", ); |
||||
arrayAppend(parentsToProcess, children[j]); |
||||
mappingDestination[outputOffset] = children[j]; |
||||
parentDestination[outputOffset] = objectId; |
||||
++outputOffset; |
||||
} |
||||
} |
||||
|
||||
/** @todo better diagnostic once we can use a BitArray to detect which
|
||||
nodes are unreachable from root (OTOH again maybe that's undesirable |
||||
extra work that doesn't belong here?) */ |
||||
CORRADE_ASSERT(outputOffset == parents.size(), |
||||
"SceneTools::orderClusterParents(): hierarchy is sparse", ); |
||||
} |
||||
|
||||
}} |
||||
@ -0,0 +1,77 @@
|
||||
#ifndef Magnum_SceneTools_OrderClusterParents_h |
||||
#define Magnum_SceneTools_OrderClusterParents_h |
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021 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::SceneTools::orderClusterParents(), @ref Magnum::SceneTools::orderClusterParentsInto() |
||||
* @m_since_latest |
||||
*/ |
||||
|
||||
#include "Magnum/Magnum.h" |
||||
#include "Magnum/SceneTools/visibility.h" |
||||
#include "Magnum/Trade/Trade.h" |
||||
|
||||
namespace Magnum { namespace SceneTools { |
||||
|
||||
/**
|
||||
@brief Calculate ordered and clustered parents |
||||
@m_since_latest |
||||
|
||||
Extracts the @ref Trade::SceneField::Parent field from @p scene and converts it |
||||
to match the following rules: |
||||
|
||||
- a parent object reference appears always before any of its children |
||||
- the array is clustered so children sharing the same parent are together |
||||
|
||||
This form is useful primarily for calculating absolute object transformations, |
||||
for example: |
||||
|
||||
@snippet MagnumSceneTools.cpp orderClusterParents-transformations |
||||
|
||||
The operation is done in an @f$ \mathcal{O}(n) @f$ execution time and memory |
||||
complexity, with @f$ n @f$ being @ref Trade::SceneData::mappingBound(). The |
||||
@ref Trade::SceneField::Parent field is expected to be contained in the scene, |
||||
having no cycles (i.e., every node listed just once) and not being sparse |
||||
(i.e., every node listed in the field reachable from the root). |
||||
@see @ref Trade::SceneData::hasField() |
||||
*/ |
||||
MAGNUM_SCENETOOLS_EXPORT Containers::Array<Containers::Pair<UnsignedInt, Int>> orderClusterParents(const Trade::SceneData& scene); |
||||
|
||||
/**
|
||||
@brief Calculate ordered and clustered parents into a pre-allocated view |
||||
@m_since_latest |
||||
|
||||
Like @ref orderClusterParents(), but puts the result into |
||||
@p mappingDestination and @p parentDestination instead of allocating a new |
||||
array. Expect that both views have a size equal to size of the |
||||
@ref Trade::SceneField::Parent view in @p scene. |
||||
@see @ref Trade::SceneData::fieldSize(SceneField) const |
||||
*/ |
||||
MAGNUM_SCENETOOLS_EXPORT void orderClusterParentsInto(const Trade::SceneData& scene, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& parentDestination); |
||||
|
||||
}} |
||||
|
||||
#endif |
||||
@ -0,0 +1,324 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021 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/Containers/Pair.h> |
||||
#include <Corrade/TestSuite/Tester.h> |
||||
#include <Corrade/TestSuite/Compare/Container.h> |
||||
#include <Corrade/Utility/DebugStl.h> |
||||
|
||||
#include "Magnum/SceneTools/OrderClusterParents.h" |
||||
#include "Magnum/Trade/SceneData.h" |
||||
|
||||
namespace Magnum { namespace SceneTools { namespace Test { namespace { |
||||
|
||||
struct OrderClusterParentsTest: TestSuite::Tester { |
||||
explicit OrderClusterParentsTest(); |
||||
|
||||
void test(); |
||||
void noParentField(); |
||||
void emptyParentField(); |
||||
|
||||
void intoNoParentField(); |
||||
void intoEmptyParentField(); |
||||
void intoWrongDestinationSize(); |
||||
|
||||
void sparse(); |
||||
void cyclic(); |
||||
void cyclicDeep(); |
||||
void sparseAndCyclic(); |
||||
}; |
||||
|
||||
OrderClusterParentsTest::OrderClusterParentsTest() { |
||||
addTests({&OrderClusterParentsTest::test, |
||||
&OrderClusterParentsTest::noParentField, |
||||
&OrderClusterParentsTest::emptyParentField, |
||||
|
||||
&OrderClusterParentsTest::intoNoParentField, |
||||
&OrderClusterParentsTest::intoEmptyParentField, |
||||
&OrderClusterParentsTest::intoWrongDestinationSize, |
||||
|
||||
&OrderClusterParentsTest::sparse, |
||||
&OrderClusterParentsTest::cyclic, |
||||
&OrderClusterParentsTest::cyclicDeep, |
||||
&OrderClusterParentsTest::sparseAndCyclic}); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::test() { |
||||
struct Field { |
||||
/* To verify we don't have unnecessarily hardcoded 32-bit types */ |
||||
UnsignedShort object; |
||||
Byte parent; |
||||
} data[]{ |
||||
/* Backward parent reference */ |
||||
{5, 1}, |
||||
/* Forward parent reference */ |
||||
{6, 9}, |
||||
/* Root elements */ |
||||
{3, -1}, |
||||
{1, -1}, |
||||
/* Deep hierarchy */ |
||||
{9, 10}, |
||||
{10, 3}, |
||||
/* Multiple children */ |
||||
{7, 3}, |
||||
{157, 3}, |
||||
{143, 6}, |
||||
/* More root elements */ |
||||
{2, -1} |
||||
/* Elements 0, 4, 8, 11-142, 144-156 deliberately not used */ |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedShort, 158, {}, data, { |
||||
/* To verify it doesn't just pick the first field ever */ |
||||
Trade::SceneFieldData{Trade::SceneField::Mesh, Trade::SceneMappingType::UnsignedShort, nullptr, Trade::SceneFieldType::UnsignedInt, nullptr}, |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
CORRADE_COMPARE_AS(orderClusterParents(scene), (Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({ |
||||
/* Root objects first, in order as found */ |
||||
{3, -1}, |
||||
{1, -1}, |
||||
{2, -1}, |
||||
/* Then children of node 3, clustered together, in order as found */ |
||||
{10, 3}, |
||||
{7, 3}, |
||||
{157, 3}, |
||||
/* Then children of node 1 */ |
||||
{5, 1}, |
||||
/* Children of node 10 */ |
||||
{9, 10}, |
||||
/* Children of node 9 */ |
||||
{6, 9}, |
||||
/* Children of node 6 */ |
||||
{143, 6}, |
||||
})), TestSuite::Compare::Container); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::noParentField() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedByte, 0, nullptr, {}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParents(scene); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParents(): the scene has no hierarchy\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::emptyParentField() { |
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 0, nullptr, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, Trade::SceneMappingType::UnsignedInt, nullptr, Trade::SceneFieldType::Int, nullptr} |
||||
}}; |
||||
|
||||
CORRADE_COMPARE_AS(orderClusterParents(scene), |
||||
(Containers::ArrayView<const Containers::Pair<UnsignedInt, Int>>{}), |
||||
TestSuite::Compare::Container); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::intoNoParentField() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedByte, 0, nullptr, {}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParentsInto(scene, nullptr, nullptr); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParentsInto(): the scene has no hierarchy\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::intoEmptyParentField() { |
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 0, nullptr, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, Trade::SceneMappingType::UnsignedInt, nullptr, Trade::SceneFieldType::Int, nullptr} |
||||
}}; |
||||
|
||||
orderClusterParentsInto(scene, nullptr, nullptr); |
||||
CORRADE_VERIFY(true); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::intoWrongDestinationSize() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
struct Field { |
||||
UnsignedInt object; |
||||
Int parent; |
||||
} data[]{ |
||||
{2, -1}, |
||||
{3, 2}, |
||||
{7, -1} |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 8, {}, data, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
UnsignedInt mappingCorrect[3]; |
||||
UnsignedInt mapping[2]; |
||||
Int parentOffsetCorrect[3]; |
||||
Int parentOffset[2]; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParentsInto(scene, mappingCorrect, parentOffset); |
||||
orderClusterParentsInto(scene, mapping, parentOffsetCorrect); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParentsInto(): expected parent destination view with 3 elements but got 2\n" |
||||
"SceneTools::orderClusterParentsInto(): expected mapping destination view with 3 elements but got 2\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::sparse() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
struct Field { |
||||
UnsignedInt object; |
||||
Int parent; |
||||
} data[]{ |
||||
{2, -1}, |
||||
{3, 2}, |
||||
{7, -1}, |
||||
/* Not reachable from root */ |
||||
{15, 6}, |
||||
{14, 6}, |
||||
{11, 15}, |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 16, {}, data, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParents(scene); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParents(): hierarchy is sparse\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::cyclic() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
struct Field { |
||||
UnsignedInt object; |
||||
Int parent; |
||||
} data[]{ |
||||
{2, -1}, |
||||
{3, 2}, |
||||
{7, -1}, |
||||
/* Cycle of length 1, which will be treated as sparse hierarchy */ |
||||
{13, 13} |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 16, {}, data, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParents(scene); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParents(): hierarchy is sparse\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::cyclicDeep() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
struct Field { |
||||
UnsignedInt object; |
||||
Int parent; |
||||
} data[]{ |
||||
{2, -1}, |
||||
{3, 2}, |
||||
{7, -1}, |
||||
/* Cycle of length 3 */ |
||||
{13, -1}, |
||||
{5, 13}, |
||||
{13, 3} |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 16, {}, data, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParents(scene); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParents(): hierarchy is cyclic\n"); |
||||
} |
||||
|
||||
void OrderClusterParentsTest::sparseAndCyclic() { |
||||
#ifdef CORRADE_NO_ASSERT |
||||
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); |
||||
#endif |
||||
|
||||
struct Field { |
||||
UnsignedInt object; |
||||
Int parent; |
||||
} data[]{ |
||||
{2, -1}, |
||||
{3, 2}, |
||||
{7, -1}, |
||||
/* Cycle of length 3 */ |
||||
{13, -1}, |
||||
{5, 13}, |
||||
{13, 3}, |
||||
/* Not reachable from root */ |
||||
{15, 6} |
||||
}; |
||||
Containers::StridedArrayView1D<Field> view = data; |
||||
|
||||
Trade::SceneData scene{Trade::SceneMappingType::UnsignedInt, 16, {}, data, { |
||||
Trade::SceneFieldData{Trade::SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)} |
||||
}}; |
||||
|
||||
std::ostringstream out; |
||||
Error redirectError{&out}; |
||||
orderClusterParents(scene); |
||||
CORRADE_EXPECT_FAIL("The implementation needs to track already visited objects with a BitArray to detect this, it'd also provide a much better diagnostic."); |
||||
CORRADE_COMPARE(out.str(), |
||||
"SceneTools::orderClusterParents(): hierarchy is cyclic\n"); |
||||
} |
||||
|
||||
}}}} |
||||
|
||||
CORRADE_TEST_MAIN(Magnum::SceneTools::Test::OrderClusterParentsTest) |
||||
Loading…
Reference in new issue