mirror of https://github.com/mosra/magnum.git
Browse Source
Same reasoning as before, the verb suggests it's transforming the SceneData in some way, which isn't true, it just retrieves the data in a certain way. And if an API that actually operates on SceneData got added, it would be easily confused with this one. Plus, the "order" isn't just one, this orders objects so they're grouped with a common parent, but what if I wanted to instead order depth first? Thus it's explicitly saying this is a breadth-first order. The API got moved to the Hierarchy.h header, removing a need for a dedicated file and test.pull/620/head
Vladimír Vondruš
3 years ago
9 changed files with 461 additions and 513 deletions
@ -1,136 +0,0 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021, 2022 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/ArrayTuple.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)}; |
||||
orderClusterParentsInto(scene, |
||||
stridedArrayView(out).slice(&decltype(out)::Type::first), |
||||
stridedArrayView(out).slice(&decltype(out)::Type::second)); |
||||
return out; |
||||
} |
||||
|
||||
void orderClusterParentsInto(const Trade::SceneData& scene, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& parentDestination) { |
||||
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(), ); |
||||
|
||||
/* Allocate a single storage for all temporary data */ |
||||
Containers::ArrayView<Containers::Pair<UnsignedInt, Int>> parents; |
||||
Containers::ArrayView<UnsignedInt> childrenOffsets; |
||||
Containers::ArrayView<UnsignedInt> children; |
||||
Containers::ArrayView<Int> parentsToProcess; |
||||
Containers::ArrayTuple storage{ |
||||
/* Output of scene.parentsInto() */ |
||||
{NoInit, parentFieldSize, parents}, |
||||
/* Running children offset (+1) for each node including root (+1), plus
|
||||
one more element when we shift the array by one below */ |
||||
{ValueInit, std::size_t(scene.mappingBound() + 3), childrenOffsets}, |
||||
{NoInit, parentFieldSize, children}, |
||||
/* List of parents to process. Can't reuse mappingDestination because
|
||||
this includes one more element for root objects. */ |
||||
{NoInit, parentFieldSize + 1, parentsToProcess} |
||||
}; |
||||
|
||||
/* Convert the parent list to a child list to sort them toplogically */ |
||||
scene.parentsInto( |
||||
stridedArrayView(parents).slice(&decltype(parents)::Type::first), |
||||
stridedArrayView(parents).slice(&decltype(parents)::Type::second) |
||||
); |
||||
|
||||
/* Children offset for each node including root. First calculate the count
|
||||
of children for each, skipping the first element (parent.second() can be |
||||
-1, accounting for that as well)... */ |
||||
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() + 2]; |
||||
} |
||||
|
||||
/* ... then convert the counts to a running offset. Now
|
||||
`[childrenOffsets[i + 2], childrenOffsets[i + 3])` 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. The
|
||||
childrenOffsets array gets shifted by one element by the process, thus |
||||
now `[childrenOffsets[i + 1], childrenOffsets[i + 2])` contains a range |
||||
in which the `children` array below contains a list of children for |
||||
`i`. */ |
||||
for(const Containers::Pair<UnsignedInt, Int>& parent: parents) |
||||
children[childrenOffsets[parent.second() + 2]++] = parent.first(); |
||||
|
||||
/* 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; |
||||
parentsToProcess[0] = -1; |
||||
for(std::size_t i = 0; i != outputOffset + 1; ++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(outputOffset < parents.size(), |
||||
"SceneTools::orderClusterParents(): hierarchy is cyclic", ); |
||||
parentsToProcess[outputOffset + 1] = 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", ); |
||||
} |
||||
|
||||
}} |
||||
@ -1,324 +0,0 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021, 2022 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 mapping; |
||||
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::mapping), |
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
struct Field { |
||||
UnsignedInt mapping; |
||||
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::mapping), |
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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() { |
||||
CORRADE_SKIP_IF_NO_ASSERT(); |
||||
|
||||
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