ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10925 Commits
21 Branches
19 Tags
70 MiB
Tree: d8ce013ab6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd8ce013ab6'
${ noResults }
magnum/src/Magnum/SceneTools/FlattenMeshHierarchy.h

101 lines
5.0 KiB
Raw Normal View History Unescape

SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
#ifndef Magnum_SceneTools_FlattenMeshHierarchy_h
#define Magnum_SceneTools_FlattenMeshHierarchy_h
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
It's 2023 already!
3 years ago
2020, 2021, 2022, 2023 Vladimír Vondruš <mosra@centrum.cz>
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
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.
*/
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
/** @file
Doc++
3 years ago
* @brief Function @ref Magnum::SceneTools::flattenMeshHierarchy2D(), @ref Magnum::SceneTools::flattenMeshHierarchy2DInto(), @ref Magnum::SceneTools::flattenMeshHierarchy3D(), @ref Magnum::SceneTools::flattenMeshHierarchy3DInto()
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
* @m_deprecated_since_latest Use @ref Magnum/SceneTools/Hierarchy.h and the
* @relativeref{Magnum,SceneTools::absoluteFieldTransformations2D()} /
* @relativeref{Magnum,SceneTools::absoluteFieldTransformations3D()}
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
* functions instead.
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
*/
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#endif
#include "Magnum/configure.h"
#ifdef MAGNUM_BUILD_DEPRECATED
#include <Corrade/Utility/Macros.h>
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
#include "Magnum/Magnum.h"
SceneTools: don't bother saving compile times in a deprecated header. Just extra cruft to maintain.
3 years ago
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
#include "Magnum/SceneTools/visibility.h"
#include "Magnum/Trade/Trade.h"
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#ifndef _MAGNUM_NO_DEPRECATED_FLATTENMESHHIERARCHY
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
CORRADE_DEPRECATED_FILE("use Magnum/SceneTools/Hierarchy.h and the SceneTools::absoluteFieldTransformations*D() functions instead")
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#endif
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
namespace Magnum { namespace SceneTools {
/**
@brief Flatten a 2D mesh hierarchy
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
@m_deprecated_since_latest Use @ref absoluteFieldTransformations2D(const Trade::SceneData&, Trade::SceneField, const Matrix3&)
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
with @ref Trade::SceneField::Mesh together with
@ref Trade::SceneData::meshesMaterialsAsArray() instead.
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
*/
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
CORRADE_DEPRECATED("use absoluteFieldTransformations2D() instead") MAGNUM_SCENETOOLS_EXPORT Containers::Array<Containers::Triple<UnsignedInt, Int, Matrix3>> flattenMeshHierarchy2D(const Trade::SceneData& scene, const Matrix3& globalTransformation = {});
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
/**
@brief Flatten a 2D mesh hierarchy into an existing array
@param[in] scene Input scene
@param[out] transformations Where to put the calculated transformations
@param[in] globalTransformation Global transformation to prepend
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
@m_deprecated_since_latest Use @ref absoluteFieldTransformations2DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix3>&, const Matrix3&)
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
with @ref Trade::SceneField::Mesh instead.
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
*/
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
CORRADE_DEPRECATED("use absoluteFieldTransformations2DInto() instead") MAGNUM_SCENETOOLS_EXPORT void flattenMeshHierarchy2DInto(const Trade::SceneData& scene, const Containers::StridedArrayView1D<Matrix3>& transformations, const Matrix3& globalTransformation = {});
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
/**
@brief Flatten a 3D mesh hierarchy
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
@m_deprecated_since_latest Use @ref absoluteFieldTransformations3D(const Trade::SceneData&, Trade::SceneField, const Matrix4&)
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
with @ref Trade::SceneField::Mesh together with
@ref Trade::SceneData::meshesMaterialsAsArray() instead.
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
*/
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
CORRADE_DEPRECATED("use absoluteFieldTransformations3D() instead") MAGNUM_SCENETOOLS_EXPORT Containers::Array<Containers::Triple<UnsignedInt, Int, Matrix4>> flattenMeshHierarchy3D(const Trade::SceneData& scene, const Matrix4& globalTransformation = {});
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
/**
@brief Flatten a 3D mesh hierarchy into an existing array
@param[in] scene Input scene
@param[out] transformations Where to put the calculated transformations
@param[in] globalTransformation Global transformation to prepend
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
@m_deprecated_since_latest Use @ref absoluteFieldTransformations3DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix4>&, const Matrix4&)
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
with @ref Trade::SceneField::Mesh instead.
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
*/
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
CORRADE_DEPRECATED("use absoluteFieldTransformations3DInto() instead") MAGNUM_SCENETOOLS_EXPORT void flattenMeshHierarchy3DInto(const Trade::SceneData& scene, const Containers::StridedArrayView1D<Matrix4>& transformations, const Matrix4& globalTransformation = {});
SceneTools: add flattenMeshHierarchyInto(). Now that the data order is pinned down, it's possible to hammer a more efficient underlying API from out under the convenience utility.
4 years ago
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
}}
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#else
SceneTools: flattenTransformHierarchy*D() -> absoluteFieldTransform*D(). That's a second deprecation of this API in a short while, sorry. This variant is hopefully the final one, with the previous one I still had the problem that it contained a verb, which implied that it'd *transform* the SceneData in some way which (unlike combineFields(), filterFields() etc.) it didn't, it just extracts some data in a certain way. This would all cause problems when there are APIs that actually do perform hierarchy flattening. It's also moved to a new, more general Hierarchy.h header which will contain other hierarchy-related APIs. It doesn't make sense to have a tiny header with just a single function, especially given it doesn't depend on any heavy headers on its own. Besides that it also makes the UnsignedInt overloads the main ones, and the Trade::SceneField secondary, as is already done everywhere else (and the opposite way was just bad inheritance from flattenMeshHierarchy() it seems).
3 years ago
#error use Magnum/SceneTools/FlattenTransformationHierarchy.h and the SceneTools::absoluteFieldTransformations*D() functions instead
SceneTools: generalize flatten{Mesh -> Transformation}Hierarchy(). Took me a while to realize that tying this to a certain hardcoded field isn't a good idea. The new variant is useful also for example for getting absolute light positions or just whatever else. Besides taking a SceneField there's now also an overload taking a field ID to avoid double lookups. The only behavioral difference compared to the old API is that the field is now required to exist, instead of the API being a silent no-op if not present. Eventually these APIs may get further extended to take a BitArrayView of objects for which to calculate the transforms, for example to take only meshes that are a part of the hierarchy, or meshes that satisfy an arbitrary other condition. Which will also resolve the remaining concerns with the API. I'm still keeping it marked as experimental tho, the usefulness isn't set in stone yet. The old APIs are marked as deprecated and implemented using the new ones.
3 years ago
#endif
SceneTools: utility to flatten mesh hierarchy. Internals doing a few rather big allocations, will convert that to just a single one in a next step.
4 years ago
#endif