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.
10487 Commits
21 Branches
19 Tags
70 MiB
Tree: 21cff30b27
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '21cff30b27'
${ noResults }
magnum/src/Magnum/SceneTools/FlattenTransformationHierar...

133 lines
7.2 KiB
Raw Normal View History Unescape

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_SceneTools_FlattenTransformationHierarchy_h
#define Magnum_SceneTools_FlattenTransformationHierarchy_h
/*
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.
*/
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
#ifdef MAGNUM_BUILD_DEPRECATED
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
/** @file
* @brief Function @ref Magnum::SceneTools::flattenTransformationHierarchy2D(), @ref Magnum::SceneTools::flattenTransformationHierarchy2DInto(), @ref Magnum::SceneTools::flattenTransformationHierarchy3D(), @ref Magnum::SceneTools::flattenTransformationHierarchy3DInto()
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()}
* 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
*/
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
#endif
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
#include "Magnum/configure.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
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
#ifdef MAGNUM_BUILD_DEPRECATED
#include <Corrade/Containers/Array.h>
#include <Corrade/Utility/Macros.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
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
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
#include "Magnum/SceneTools/Hierarchy.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
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
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
namespace Magnum { namespace SceneTools {
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
/* Made header-only to not have to maintain a deprecated source file */
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
/**
@brief Flatten a 2D transformation hierarchy for given field
@m_deprecated_since_latest Use @ref absoluteFieldTransformations2D(const Trade::SceneData&, Trade::SceneField, const Matrix3&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations2D() instead") Containers::Array<Matrix3> flattenTransformationHierarchy2D(const Trade::SceneData& scene, Trade::SceneField field, const Matrix3& globalTransformation = {}) {
return absoluteFieldTransformations2D(scene, field, globalTransformation);
}
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
/**
@brief Flatten a 2D transformation hierarchy for given field ID
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&, UnsignedInt, const Matrix3&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations2D() instead") Containers::Array<Matrix3> flattenTransformationHierarchy2D(const Trade::SceneData& scene, UnsignedInt fieldId, const Matrix3& globalTransformation = {}) {
return absoluteFieldTransformations2D(scene, fieldId, globalTransformation);
}
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
/**
@brief Flatten a 2D transformation hierarchy for given field into an existing array
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&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations2DInto() instead") void flattenTransformationHierarchy2DInto(const Trade::SceneData& scene, Trade::SceneField field, const Containers::StridedArrayView1D<Matrix3>& transformations, const Matrix3& globalTransformation = {}) {
return absoluteFieldTransformations2DInto(scene, field, transformations, globalTransformation);
}
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
/**
@brief Flatten a 2D transformation hierarchy for given field ID into an existing array
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&, UnsignedInt, const Containers::StridedArrayView1D<Matrix3>&, const Matrix3&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations2DInto() instead") void flattenTransformationHierarchy2DInto(const Trade::SceneData& scene, UnsignedInt fieldId, const Containers::StridedArrayView1D<Matrix3>& transformations, const Matrix3& globalTransformation = {}) {
return absoluteFieldTransformations2DInto(scene, fieldId, transformations, globalTransformation);
}
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
/**
@brief Flatten a 3D transformation hierarchy for given field
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&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations3D() instead") Containers::Array<Matrix4> flattenTransformationHierarchy3D(const Trade::SceneData& scene, Trade::SceneField field, const Matrix4& globalTransformation = {}) {
return absoluteFieldTransformations3D(scene, field, globalTransformation);
}
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
/**
@brief Flatten a 3D transformation hierarchy for given field ID
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&, UnsignedInt, const Matrix4&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations3D() instead") Containers::Array<Matrix4> flattenTransformationHierarchy3D(const Trade::SceneData& scene, UnsignedInt fieldId, const Matrix4& globalTransformation = {}) {
return absoluteFieldTransformations3D(scene, fieldId, globalTransformation);
}
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
/**
@brief Flatten a 3D transformation hierarchy for given field into an existing array
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&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations3DInto() instead") void flattenTransformationHierarchy3DInto(const Trade::SceneData& scene, Trade::SceneField field, const Containers::StridedArrayView1D<Matrix4>& transformations, const Matrix4& globalTransformation = {}) {
return absoluteFieldTransformations3DInto(scene, field, transformations, globalTransformation);
}
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
@brief Flatten a 3D transformation hierarchy for given field ID into an existing array
@m_deprecated_since_latest Use @ref absoluteFieldTransformations3DInto(const Trade::SceneData&, UnsignedInt, const Containers::StridedArrayView1D<Matrix4>&, const Matrix4&)
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
*/
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
inline CORRADE_DEPRECATED("use absoluteFieldTransformations3DInto() instead") void flattenTransformationHierarchy3DInto(const Trade::SceneData& scene, UnsignedInt fieldId, const Containers::StridedArrayView1D<Matrix4>& transformations, const Matrix4& globalTransformation = {}) {
return absoluteFieldTransformations3DInto(scene, fieldId, transformations, globalTransformation);
}
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
#else
#error use Magnum/SceneTools/Hierarchy.h and the SceneTools::absoluteFieldTransformations*D() functions instead
#endif
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