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.
10395 Commits
21 Branches
19 Tags
70 MiB
Tree: f43fa6ff95
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f43fa6ff95'
${ noResults }
magnum/src/Magnum/Trade/AnimationData.cpp

318 lines
19 KiB
Raw Normal View History Unescape

Trade: initial AnimationData implementation.
8 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
4 years ago
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
Trade: initial AnimationData implementation.
8 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.
*/
#include "AnimationData.h"
#include <Corrade/Utility/Debug.h>
#include "Magnum/Math/Vector4.h"
#include "Magnum/Math/Quaternion.h"
Trade: make it possible to construct AnimationData from track init list. Easier to write. Need to take extra care with default deleters.
7 years ago
#include "Magnum/Trade/Implementation/arrayUtilities.h"
Trade: initial AnimationData implementation.
8 years ago
namespace Magnum { namespace Trade {
Trade: provide better AnimationTrackData constructors. Taking Animation::TrackViewStorage wasn't really a good idea, as it wasn't solving anything -- in order to create it, there needs to be a TrackView of a concrete type first anyway, and even then it required a lot of additional verbose typing. The new constructors take basically what TrackView takes, plus there's additionally a constructor that takes a typeless value view together with explicitly specified value and result types, allowing a truly type-erased usage. On the other hand, the templated variants directly deduce the types without any additional typing, making the construction similarly straightforward to e.g. SceneFieldData. In case of the type-erased constructors, if the interpolator function isn't supplied explicitly, an implicit one is picked based on the value type, result type and interpolation. Not all combinations make sense of course, so this is a new assertion point, however compared to the previous way where the interpolator was picked from a *typed* TrackView, this doesn't add any new restriction -- what asserted there, asserts now as well, and additionally you can't have e.g. a Quaternion track with a boolean result. I may also be eventually adding assertions to check that the target name matches the result type -- so e.g. a rotation isn't specified as an integer and such. Compared to newer APIs like MeshData, MaterialData or SceneData the AnimationData API has a significant lack of sanity asserts like this.
3 years ago
namespace {
auto animationInterpolatorFor(const Animation::Interpolation interpolation, const AnimationTrackType type, const AnimationTrackType resultType) -> void(*)() {
switch(type) {
/* LCOV_EXCL_START */
#define _ct(value, type_) \
case AnimationTrackType::value: \
if(type == resultType) \
return reinterpret_cast<void(*)()>(Trade::animationInterpolatorFor<type_, type_>(interpolation)); \
break;
#define _c(type_) _ct(type_, type_)
_ct(Bool, bool)
_c(Float)
_c(UnsignedInt)
_c(Int)
_c(BitVector2)
_c(BitVector3)
_c(BitVector4)
_c(Vector2)
_c(Vector2ui)
_c(Vector2i)
_c(Vector3)
_c(Vector3ui)
_c(Vector3i)
_c(Vector4)
_c(Vector4ui)
_c(Vector4i)
_c(Complex)
_c(Quaternion)
_c(DualQuaternion)
#undef _c
#undef _ct
/* LCOV_EXCL_STOP */
/* LCOV_EXCL_START */
#define _cr(type_, resultType_) \
case AnimationTrackType::type_: \
if(resultType == AnimationTrackType::resultType_) \
return reinterpret_cast<void(*)()>(Trade::animationInterpolatorFor<type_, resultType_>(interpolation)); \
break;
_cr(CubicHermite1D, Float)
_cr(CubicHermite2D, Vector2)
_cr(CubicHermite3D, Vector3)
_cr(CubicHermiteComplex, Complex)
_cr(CubicHermiteQuaternion, Quaternion)
#undef _cr
/* LCOV_EXCL_STOP */
}
/** @todo this doesn't print the types when e.g. a spline interpolation is
requested for bool, how to fix? */
CORRADE_ASSERT_UNREACHABLE("Trade::AnimationTrackData: can't deduce interpolator function for" << type << Debug::nospace << "," << resultType << "and" << interpolation, {});
}
}
AnimationTrackData::AnimationTrackData(const AnimationTrackTarget targetName, const UnsignedLong target, const AnimationTrackType type, const AnimationTrackType resultType, const Containers::StridedArrayView1D<const Float>& keys, const Containers::StridedArrayView1D<const void>& values, const Animation::Interpolation interpolation, void(*const interpolator)(), const Animation::Extrapolation before, const Animation::Extrapolation after) noexcept: _type{type}, _resultType{resultType}, _targetName{targetName}, _interpolation{interpolation}, _before{before}, _after{after}, _target{target}, _size{UnsignedInt(keys.size())}, _keysStride{Short(keys.stride())}, _valuesStride{Short(values.stride())}, _keysData{keys.data()}, _valuesData{values.data()}, _interpolator{interpolator} {
CORRADE_ASSERT(keys.size() == values.size(),
"Trade::AnimationTrackData: expected key and value view to have the same size but got" << keys.size() << "and" << values.size(), );
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
#ifndef CORRADE_TARGET_32BIT
Trade: provide better AnimationTrackData constructors. Taking Animation::TrackViewStorage wasn't really a good idea, as it wasn't solving anything -- in order to create it, there needs to be a TrackView of a concrete type first anyway, and even then it required a lot of additional verbose typing. The new constructors take basically what TrackView takes, plus there's additionally a constructor that takes a typeless value view together with explicitly specified value and result types, allowing a truly type-erased usage. On the other hand, the templated variants directly deduce the types without any additional typing, making the construction similarly straightforward to e.g. SceneFieldData. In case of the type-erased constructors, if the interpolator function isn't supplied explicitly, an implicit one is picked based on the value type, result type and interpolation. Not all combinations make sense of course, so this is a new assertion point, however compared to the previous way where the interpolator was picked from a *typed* TrackView, this doesn't add any new restriction -- what asserted there, asserts now as well, and additionally you can't have e.g. a Quaternion track with a boolean result. I may also be eventually adding assertions to check that the target name matches the result type -- so e.g. a rotation isn't specified as an integer and such. Compared to newer APIs like MeshData, MaterialData or SceneData the AnimationData API has a significant lack of sanity asserts like this.
3 years ago
CORRADE_ASSERT(keys.size() <= 0xffffffffu,
"Trade::AnimationTrackData: expected keyframe count to fit into 32 bits but got" << keys.size(), );
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
#endif
Trade: provide better AnimationTrackData constructors. Taking Animation::TrackViewStorage wasn't really a good idea, as it wasn't solving anything -- in order to create it, there needs to be a TrackView of a concrete type first anyway, and even then it required a lot of additional verbose typing. The new constructors take basically what TrackView takes, plus there's additionally a constructor that takes a typeless value view together with explicitly specified value and result types, allowing a truly type-erased usage. On the other hand, the templated variants directly deduce the types without any additional typing, making the construction similarly straightforward to e.g. SceneFieldData. In case of the type-erased constructors, if the interpolator function isn't supplied explicitly, an implicit one is picked based on the value type, result type and interpolation. Not all combinations make sense of course, so this is a new assertion point, however compared to the previous way where the interpolator was picked from a *typed* TrackView, this doesn't add any new restriction -- what asserted there, asserts now as well, and additionally you can't have e.g. a Quaternion track with a boolean result. I may also be eventually adding assertions to check that the target name matches the result type -- so e.g. a rotation isn't specified as an integer and such. Compared to newer APIs like MeshData, MaterialData or SceneData the AnimationData API has a significant lack of sanity asserts like this.
3 years ago
CORRADE_ASSERT(keys.stride() >= -32768 && keys.stride() <= 32767,
"Trade::AnimationTrackData: expected key stride to fit into 16 bits but got" << keys.stride(), );
CORRADE_ASSERT(values.stride() >= -32768 && values.stride() <= 32767,
"Trade::AnimationTrackData: expected value stride to fit into 16 bits but got" << values.stride(), );
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
}
Trade: provide better AnimationTrackData constructors. Taking Animation::TrackViewStorage wasn't really a good idea, as it wasn't solving anything -- in order to create it, there needs to be a TrackView of a concrete type first anyway, and even then it required a lot of additional verbose typing. The new constructors take basically what TrackView takes, plus there's additionally a constructor that takes a typeless value view together with explicitly specified value and result types, allowing a truly type-erased usage. On the other hand, the templated variants directly deduce the types without any additional typing, making the construction similarly straightforward to e.g. SceneFieldData. In case of the type-erased constructors, if the interpolator function isn't supplied explicitly, an implicit one is picked based on the value type, result type and interpolation. Not all combinations make sense of course, so this is a new assertion point, however compared to the previous way where the interpolator was picked from a *typed* TrackView, this doesn't add any new restriction -- what asserted there, asserts now as well, and additionally you can't have e.g. a Quaternion track with a boolean result. I may also be eventually adding assertions to check that the target name matches the result type -- so e.g. a rotation isn't specified as an integer and such. Compared to newer APIs like MeshData, MaterialData or SceneData the AnimationData API has a significant lack of sanity asserts like this.
3 years ago
AnimationTrackData::AnimationTrackData(const AnimationTrackTarget targetName, const UnsignedLong target, const AnimationTrackType type, const AnimationTrackType resultType, const Containers::StridedArrayView1D<const Float>& keys, const Containers::StridedArrayView1D<const void>& values, const Animation::Interpolation interpolation, const Animation::Extrapolation before, const Animation::Extrapolation after) noexcept: AnimationTrackData{targetName, target, type, resultType, keys, values, interpolation, animationInterpolatorFor(interpolation, type, resultType), before, after} {}
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
Animation::TrackViewStorage<const Float> AnimationTrackData::track() const {
return Animation::TrackViewStorage<const Float>{
/* We're sure the views are correct, circumventing the asserts */
Containers::StridedArrayView1D<const Float>{{nullptr, ~std::size_t{}}, static_cast<const Float*>(_keysData), _size, _keysStride},
Containers::StridedArrayView1D<const char>{{nullptr, ~std::size_t{}}, static_cast<const char*>(_valuesData), _size, _valuesStride},
_interpolation, _interpolator, _before, _after};
}
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
AnimationData::AnimationData(Containers::Array<char>&& data, Containers::Array<AnimationTrackData>&& tracks, const Range1D& duration, const void* importerState) noexcept: _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _duration{duration}, _data{std::move(data)}, _tracks{std::move(tracks)}, _importerState{importerState} {}
Trade: support both implicit and explicit duration in AnimationData.
8 years ago
Trade: make it possible to construct AnimationData from track init list. Easier to write. Need to take extra care with default deleters.
7 years ago
AnimationData::AnimationData(Containers::Array<char>&& data, std::initializer_list<AnimationTrackData> tracks, const Range1D& duration, const void* importerState): AnimationData{std::move(data), Implementation::initializerListToArrayWithDefaultDeleter(tracks), duration, importerState} {}
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
AnimationData::AnimationData(const DataFlags dataFlags, const Containers::ArrayView<const void> data, Containers::Array<AnimationTrackData>&& tracks, const Range1D& duration, const void* importerState) noexcept: AnimationData{Containers::Array<char>{const_cast<char*>(static_cast<const char*>(data.data())), data.size(), Implementation::nonOwnedArrayDeleter}, std::move(tracks), duration, importerState} {
CORRADE_ASSERT(!(dataFlags & DataFlag::Owned),
"Trade::AnimationData: can't construct a non-owned instance with" << dataFlags, );
_dataFlags = dataFlags;
}
Trade: make it possible to construct AnimationData from track init list. Easier to write. Need to take extra care with default deleters.
7 years ago
AnimationData::AnimationData(const DataFlags dataFlags, const Containers::ArrayView<const void> data, std::initializer_list<AnimationTrackData> tracks, const Range1D& duration, const void* importerState): AnimationData{dataFlags, data, Implementation::initializerListToArrayWithDefaultDeleter(tracks), duration, importerState} {}
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
AnimationData::AnimationData(Containers::Array<char>&& data, Containers::Array<AnimationTrackData>&& tracks, const void* importerState) noexcept: _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _data{std::move(data)}, _tracks{std::move(tracks)}, _importerState{importerState} {
Adapt to Corrade changes.
4 years ago
if(!_tracks.isEmpty()) {
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
const auto duration = [](const AnimationTrackData& track) {
if(!track._size) return Range1D{};
/* We're sure the view is correct, circumventing the assert */
Containers::StridedArrayView1D<const Float> keys{{nullptr, ~std::size_t{}}, static_cast<const Float*>(track._keysData), track._size, track._keysStride};
return Range1D{keys.front(), keys.back()};
};
Trade: support both implicit and explicit duration in AnimationData.
8 years ago
/* Reset duration to duration of the first track so it properly support
cases where tracks don't start at 0 */
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
_duration = duration(_tracks.front());
Trade: support both implicit and explicit duration in AnimationData.
8 years ago
for(std::size_t i = 1; i != _tracks.size(); ++i)
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
_duration = Math::join(_duration, duration(_tracks[i]));
Trade: support both implicit and explicit duration in AnimationData.
8 years ago
}
}
Trade: initial AnimationData implementation.
8 years ago
Trade: make it possible to construct AnimationData from track init list. Easier to write. Need to take extra care with default deleters.
7 years ago
AnimationData::AnimationData(Containers::Array<char>&& data, std::initializer_list<AnimationTrackData> tracks, const void* importerState): AnimationData{std::move(data), Implementation::initializerListToArrayWithDefaultDeleter(tracks), importerState} {}
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
AnimationData::AnimationData(const DataFlags dataFlags, const Containers::ArrayView<const void> data, Containers::Array<AnimationTrackData>&& tracks, const void* importerState) noexcept: AnimationData{Containers::Array<char>{const_cast<char*>(static_cast<const char*>(data.data())), data.size(), Implementation::nonOwnedArrayDeleter}, std::move(tracks), importerState} {
CORRADE_ASSERT(!(dataFlags & DataFlag::Owned),
"Trade::AnimationData: can't construct a non-owned instance with" << dataFlags, );
_dataFlags = dataFlags;
}
Trade: make it possible to construct AnimationData from track init list. Easier to write. Need to take extra care with default deleters.
7 years ago
AnimationData::AnimationData(const DataFlags dataFlags, const Containers::ArrayView<const void> data, std::initializer_list<AnimationTrackData> tracks, const void* importerState): AnimationData{dataFlags, data, Implementation::initializerListToArrayWithDefaultDeleter(tracks), importerState} {}
Trade: initial AnimationData implementation.
8 years ago
AnimationData::~AnimationData() = default;
AnimationData::AnimationData(AnimationData&&) noexcept = default;
AnimationData& AnimationData::operator=(AnimationData&&) noexcept = default;
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
Containers::ArrayView<char> AnimationData::mutableData() & {
CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
"Trade::AnimationData::mutableData(): the animation is not mutable", {});
return _data;
}
Trade: initial AnimationData implementation.
8 years ago
AnimationTrackType AnimationData::trackType(UnsignedInt id) const {
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
"Trade::AnimationData::trackType(): index" << id << "out of range for" << _tracks.size() << "tracks", {});
Trade: initial AnimationData implementation.
8 years ago
return _tracks[id]._type;
}
AnimationTrackType AnimationData::trackResultType(UnsignedInt id) const {
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
"Trade::AnimationData::trackResultType(): index" << id << "out of range for" << _tracks.size() << "tracks", {});
Trade: initial AnimationData implementation.
8 years ago
return _tracks[id]._resultType;
}
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
AnimationTrackTarget AnimationData::trackTargetName(UnsignedInt id) const {
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
"Trade::AnimationData::trackTargetName(): index" << id << "out of range for" << _tracks.size() << "tracks", {});
return _tracks[id]._targetName;
Trade: initial AnimationData implementation.
8 years ago
}
Trade: make AnimationData object reference 64-bit. To align with the new SceneData.
4 years ago
UnsignedLong AnimationData::trackTarget(UnsignedInt id) const {
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
"Trade::AnimationData::trackTarget(): index" << id << "out of range for" << _tracks.size() << "tracks", {});
Trade: change animation track target to target type and target ID to target. This is in line with how the other APIs are named (for example ObjectDataXD have instance type and instance). This would be very hard to change later without breaking backwards compatibility, so I'm doing it now, until the animation APIs get widely used.
8 years ago
return _tracks[id]._target;
Trade: initial AnimationData implementation.
8 years ago
}
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
Animation::TrackViewStorage<const Float> AnimationData::track(UnsignedInt id) const {
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
"Trade::AnimationData::track(): index" << id << "out of range for" << _tracks.size() << "tracks", _tracks[0].track());
return _tracks[id].track();
Trade: provide untyped access to tracks in AnimationData. This reduces the templated code a bit, as I moved the index assertion to the *.cpp file. Also the function now returns a reference to avoid needless copies -- it's a view, but still quite a heavy view.
8 years ago
}
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
Animation::TrackViewStorage<Float> AnimationData::mutableTrack(UnsignedInt id) {
/* EW those casts! */
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
"Trade::AnimationData::mutableTrack(): the animation is not mutable",
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
reinterpret_cast<const Animation::TrackViewStorage<Float>&>(static_cast<const Animation::TrackViewStorage<const Float>&>(_tracks[0].track())));
Trade: improve AnimationData OOB assertion messages. This still contained the original message which didn't say the index. Times changed significantly since then, and the printed index really proved to be useful. Also fixing a OOB assertion in the test triggered by the new ArrayView element access assertions -- the graceful assertion returns the first element, so we have to have at least one there to return.
3 years ago
CORRADE_ASSERT(id < _tracks.size(),
"Trade::AnimationData::mutableTrack(): index" << id << "out of range for" << _tracks.size() << "tracks",
Trade: pack AnimationTrackData internals better. Instead of storing Animation::TrackViewStorage directly it now contains the view pointers, strides and size (where the size is shared by both keys and values) together with packing the non-pointer values into existing paddings. Together with reducing the keyframe count to 32 bits and strides to 16 bits (which is consistent with MeshData and SceneData), this reduces the size from 80 bytes to 48. Not using TrackViewStorage also means we can directly accept the key/value views in constructors, significantly improving the usability. This also makes it possible to add support for (constexpr) offset-only track data and thus easy serializability, again similarly to MeshAttributeData and SceneFieldData.
3 years ago
reinterpret_cast<const Animation::TrackViewStorage<Float>&>(static_cast<const Animation::TrackViewStorage<const Float>&>(_tracks[0].track())));
return reinterpret_cast<const Animation::TrackViewStorage<Float>&>(static_cast<const Animation::TrackViewStorage<const Float>&>(_tracks[id].track()));
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
}
Trade: make AnimationData::release() consistent with MeshData.
7 years ago
Containers::Array<char> AnimationData::release() {
_tracks = nullptr;
return std::move(_data);
}
Trade: initial AnimationData implementation.
8 years ago
template<class V, class R> auto animationInterpolatorFor(Animation::Interpolation interpolation) -> R(*)(const V&, const V&, Float) {
return Animation::interpolatorFor<V, R>(interpolation);
}
#ifndef DOXYGEN_GENERATING_OUTPUT
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<bool, bool>(Animation::Interpolation) -> bool(*)(const bool&, const bool&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Float, Float>(Animation::Interpolation) -> Float(*)(const Float&, const Float&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<UnsignedInt, UnsignedInt>(Animation::Interpolation) -> UnsignedInt(*)(const UnsignedInt&, const UnsignedInt&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Int, Int>(Animation::Interpolation) -> Int(*)(const Int&, const Int&, Float);
Math: rename BoolVector to BitVector. Because it somewhat confusingly may have implied that it's really composed of 8-bit bools, and not bits. The same reasoning was used to pick the name for Corrade's Containers::BitArray. Backwards compatibility aliases are in place as usual, however the internal BoolVectorConverter is now BitVectorConverter and there unfortunately cannot be any backwards compatibility. This breaks only GLM and Eigen integration in the magnum-integration repo, which I'm fixing immediately. I don't expect any user code to use this internal helper. For regular vectors maybe, for this one definitely not.
4 years ago
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Math::BitVector<2>, Math::BitVector<2>>(Animation::Interpolation) -> Math::BitVector<2>(*)(const Math::BitVector<2>&, const Math::BitVector<2>&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Math::BitVector<3>, Math::BitVector<3>>(Animation::Interpolation) -> Math::BitVector<3>(*)(const Math::BitVector<3>&, const Math::BitVector<3>&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Math::BitVector<4>, Math::BitVector<4>>(Animation::Interpolation) -> Math::BitVector<4>(*)(const Math::BitVector<4>&, const Math::BitVector<4>&, Float);
Trade: initial AnimationData implementation.
8 years ago
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector2, Vector2>(Animation::Interpolation) -> Vector2(*)(const Vector2&, const Vector2&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector2i, Vector2i>(Animation::Interpolation) -> Vector2i(*)(const Vector2i&, const Vector2i&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector2ui, Vector2ui>(Animation::Interpolation) -> Vector2ui(*)(const Vector2ui&, const Vector2ui&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector3, Vector3>(Animation::Interpolation) -> Vector3(*)(const Vector3&, const Vector3&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector3i, Vector3i>(Animation::Interpolation) -> Vector3i(*)(const Vector3i&, const Vector3i&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector3ui, Vector3ui>(Animation::Interpolation) -> Vector3ui(*)(const Vector3ui&, const Vector3ui&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector4, Vector4>(Animation::Interpolation) -> Vector4(*)(const Vector4&, const Vector4&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector4d, Vector4d>(Animation::Interpolation) -> Vector4d(*)(const Vector4d&, const Vector4d&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector4i, Vector4i>(Animation::Interpolation) -> Vector4i(*)(const Vector4i&, const Vector4i&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Vector4ui, Vector4ui>(Animation::Interpolation) -> Vector4ui(*)(const Vector4ui&, const Vector4ui&, Float);
Animation, Trade: support Complex for rotation animations. Since there's now lerp() and slerp() for it.
8 years ago
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Complex, Complex>(Animation::Interpolation) -> Complex(*)(const Complex&, const Complex&, Float);
Trade: initial AnimationData implementation.
8 years ago
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<Quaternion, Quaternion>(Animation::Interpolation) -> Quaternion(*)(const Quaternion&, const Quaternion&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<DualQuaternion, DualQuaternion>(Animation::Interpolation) -> DualQuaternion(*)(const DualQuaternion&, const DualQuaternion&, Float);
Trade: support for spline interpolation in AnimationData.
8 years ago
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<CubicHermite2D, Math::Vector2<Float>>(Animation::Interpolation) -> Math::Vector2<Float>(*)(const CubicHermite2D&, const CubicHermite2D&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<CubicHermite3D, Math::Vector3<Float>>(Animation::Interpolation) -> Math::Vector3<Float>(*)(const CubicHermite3D&, const CubicHermite3D&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<CubicHermiteComplex, Complex>(Animation::Interpolation) -> Complex(*)(const CubicHermiteComplex&, const CubicHermiteComplex&, Float);
template MAGNUM_TRADE_EXPORT auto animationInterpolatorFor<CubicHermiteQuaternion, Quaternion>(Animation::Interpolation) -> Quaternion(*)(const CubicHermiteQuaternion&, const CubicHermiteQuaternion&, Float);
Trade: initial AnimationData implementation.
8 years ago
Debug& operator<<(Debug& debug, const AnimationTrackType value) {
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
const bool packed = debug.immediateFlags() >= Debug::Flag::Packed;
if(!packed)
debug << "Trade::AnimationTrackType" << Debug::nospace;
Reduce string duplication in enum debug output operators. Bloaty says it saved 10 kB in Debug build of MagnumGL: VM SIZE FILE SIZE -------------- -------------- [ = ] 0 .debug_info +1.59Ki +0.0% +0.4% +1.50Ki .text +1.50Ki +0.4% [ = ] 0 .debug_str +409 +0.0% [ = ] 0 .debug_line +276 +0.1% [ = ] 0 .debug_abbrev +20 +0.0% -28.6% -2 [LOAD [RX]] -2 -28.6% [ = ] 0 [Unmapped] -4.28Ki -41.0% -22.7% -9.23Ki .rodata -9.23Ki -22.7% -0.8% -7.73Ki TOTAL -9.73Ki -0.1% And 4 kB in Release: VM SIZE FILE SIZE -------------- -------------- +1.1% +3.44Ki .text +3.44Ki +1.1% +1.7% +1.39Ki .eh_frame +1.39Ki +1.7% [ = ] 0 [Unmapped] +656 +51% -25.5% -9.47Ki .rodata -9.47Ki -25.5% -0.7% -4.64Ki TOTAL -4.00Ki -0.4% That's not negative, so I guess that's good. This change is of course more significant in the context of a minimal WebGL build, where the exe can be as little as 50 kB -- there 4 kB is almost 10% of the size.
7 years ago
Trade: initial AnimationData implementation.
8 years ago
switch(value) {
/* LCOV_EXCL_START */
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
#define _c(value) case AnimationTrackType::value: return debug << (packed ? "" : "::") << Debug::nospace << #value;
Trade: initial AnimationData implementation.
8 years ago
_c(Bool)
_c(Float)
_c(UnsignedInt)
_c(Int)
Math: rename BoolVector to BitVector. Because it somewhat confusingly may have implied that it's really composed of 8-bit bools, and not bits. The same reasoning was used to pick the name for Corrade's Containers::BitArray. Backwards compatibility aliases are in place as usual, however the internal BoolVectorConverter is now BitVectorConverter and there unfortunately cannot be any backwards compatibility. This breaks only GLM and Eigen integration in the magnum-integration repo, which I'm fixing immediately. I don't expect any user code to use this internal helper. For regular vectors maybe, for this one definitely not.
4 years ago
_c(BitVector2)
_c(BitVector3)
_c(BitVector4)
Trade: initial AnimationData implementation.
8 years ago
_c(Vector2)
_c(Vector2ui)
_c(Vector2i)
_c(Vector3)
_c(Vector3ui)
_c(Vector3i)
_c(Vector4)
_c(Vector4ui)
_c(Vector4i)
Animation, Trade: support Complex for rotation animations. Since there's now lerp() and slerp() for it.
8 years ago
_c(Complex)
Trade: initial AnimationData implementation.
8 years ago
_c(Quaternion)
_c(DualQuaternion)
Trade: support for spline interpolation in AnimationData.
8 years ago
_c(CubicHermite1D)
_c(CubicHermite2D)
_c(CubicHermite3D)
_c(CubicHermiteComplex)
_c(CubicHermiteQuaternion)
Trade: initial AnimationData implementation.
8 years ago
#undef _c
/* LCOV_EXCL_STOP */
}
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
return debug << (packed ? "" : "(") << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << (packed ? "" : ")");
Trade: initial AnimationData implementation.
8 years ago
}
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
Debug& operator<<(Debug& debug, const AnimationTrackTarget value) {
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
const bool packed = debug.immediateFlags() >= Debug::Flag::Packed;
if(!packed)
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
debug << "Trade::AnimationTrackTarget" << Debug::nospace;
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
Trade: add isAnimationTrackTargetCustom() etc. helpers. For consistency with what's already done for MeshAttribute and SceneField. The ::Custom enum value is deprecated in favor of these, the only actually breaking change is that the debug printer now subtracts 32768 for custom values (consistently with custom mesh attributes and scene fields), while it printed the absolute enum value before.
3 years ago
if(isAnimationTrackTargetCustom(value))
return debug << (packed ? "Custom(" : "::Custom(") << Debug::nospace << animationTrackTargetCustom(value) << Debug::nospace << ")";
Trade: initial AnimationData implementation.
8 years ago
switch(value) {
/* LCOV_EXCL_START */
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
#define _c(value) case AnimationTrackTarget::value: return debug << (packed ? "" : "::") << Debug::nospace << #value;
Trade: initial AnimationData implementation.
8 years ago
_c(Translation2D)
_c(Translation3D)
_c(Rotation2D)
_c(Rotation3D)
_c(Scaling2D)
_c(Scaling3D)
#undef _c
/* LCOV_EXCL_STOP */
Trade: add isAnimationTrackTargetCustom() etc. helpers. For consistency with what's already done for MeshAttribute and SceneField. The ::Custom enum value is deprecated in favor of these, the only actually breaking change is that the debug printer now subtracts 32768 for custom values (consistently with custom mesh attributes and scene fields), while it printed the absolute enum value before.
3 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
CORRADE_IGNORE_DEPRECATED_PUSH
Trade: rename AnimationTrackTargetType to AnimationTrackTarget. The `Type` was suggesting it'd be some C++ type, definitely not values like Scaling3D or Translation2D, resulting in a significant "brain autocompletion error" every time I was using that type. Unfortunately on AnimationData the trackTargetType() couldn't similarly get renamed to trackTarget() as there's already trackTarget() that contains the node ID the target points to, so it's trackTargetName() instead. Renaming trackTarget() to trackTargetId() wasn't an option as that would be inconsistent with everything else (TextureTools::image(), MaterialAttribute::BaseColorTexture, SceneField::Mesh are all IDs but they don't have an `Id` suffix); renaming to AnimationTrackTargetName would keep it insanely long and wouldn't make it consistent either (MeshAttribute, SceneFIeld, MaterialAttribute are all referred to as "names" yet they don't have a `Name` suffix).
3 years ago
/* To silence compiler warnings about unhandled values */
case AnimationTrackTarget::Custom: CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
Trade: add isAnimationTrackTargetCustom() etc. helpers. For consistency with what's already done for MeshAttribute and SceneField. The ::Custom enum value is deprecated in favor of these, the only actually breaking change is that the debug printer now subtracts 32768 for custom values (consistently with custom mesh attributes and scene fields), while it printed the absolute enum value before.
3 years ago
CORRADE_IGNORE_DEPRECATED_POP
#endif
Trade: initial AnimationData implementation.
8 years ago
}
Trade: expand AnimationTrackTargetType to 16 bits. So it has 32k values for custom targets, instead of just 127. This makes it consistent with MeshAttribute, which also provides 32k values, while SceneField has a whole 31-bit range to make it possible to store arbitrary ECS identifiers as well. Since this is an ABI break, I'm also shifting the values by 1 to have zero used for an invalid value, consistently with SceneField, MeshAttribute etc.
3 years ago
return debug << (packed ? "" : "(") << Debug::nospace << reinterpret_cast<void*>(UnsignedShort(value)) << Debug::nospace << (packed ? "" : ")");
Trade: initial AnimationData implementation.
8 years ago
}
#endif
}}