Trade: add animationTrackType{Size,Alignment}().

doc/changelog.dox

@@ -382,6 +382,9 @@ See also:
     also exposed via a `--map` option in the
     @ref magnum-sceneconverter "magnum-sceneconverter" and
     @ref magnum-imageconverter "magnum-imageconverter" utilities
+-   Added @ref Trade::animationTrackTypeSize() and
+    @ref Trade::animationTrackTypeAlignment() for API consistency with other
+    type enums
 -   Added @ref Trade::isAnimationTrackTargetCustom() and
     @ref Trade::animationTrackTargetCustom() helpers as well as
     @ref Trade::AbstractImporter::animationTrackTargetName() and

src/Magnum/Trade/AnimationData.cpp

@@ -73,6 +73,93 @@ Debug& operator<<(Debug& debug, const AnimationTrackType value) {
     return debug << (packed ? "" : "(") << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << (packed ? "" : ")");
 }
 
+UnsignedInt animationTrackTypeSize(const AnimationTrackType type) {
+    #ifdef CORRADE_TARGET_GCC
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic error "-Wswitch"
+    #endif
+    switch(type) {
+        case AnimationTrackType::Bool:
+        case AnimationTrackType::BitVector2:
+        case AnimationTrackType::BitVector3:
+        case AnimationTrackType::BitVector4:
+            return 1;
+        case AnimationTrackType::Float:
+        case AnimationTrackType::UnsignedInt:
+        case AnimationTrackType::Int:
+            return 4;
+        case AnimationTrackType::Vector2:
+        case AnimationTrackType::Vector2ui:
+        case AnimationTrackType::Vector2i:
+        case AnimationTrackType::Complex:
+            return 8;
+        case AnimationTrackType::Vector3:
+        case AnimationTrackType::Vector3ui:
+        case AnimationTrackType::Vector3i:
+        case AnimationTrackType::CubicHermite1D:
+            return 12;
+        case AnimationTrackType::Vector4:
+        case AnimationTrackType::Vector4ui:
+        case AnimationTrackType::Vector4i:
+        case AnimationTrackType::Quaternion:
+            return 16;
+        case AnimationTrackType::CubicHermite2D:
+        case AnimationTrackType::CubicHermiteComplex:
+            return 24;
+        case AnimationTrackType::DualQuaternion:
+            return 32;
+        case AnimationTrackType::CubicHermite3D:
+            return 36;
+        case AnimationTrackType::CubicHermiteQuaternion:
+            return 48;
+    }
+    #ifdef CORRADE_TARGET_GCC
+    #pragma GCC diagnostic pop
+    #endif
+
+    CORRADE_ASSERT_UNREACHABLE("Trade::animationTrackTypeSize(): invalid type" << type, {});
+}
+
+UnsignedInt animationTrackTypeAlignment(const AnimationTrackType type) {
+    #ifdef CORRADE_TARGET_GCC
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic error "-Wswitch"
+    #endif
+    switch(type) {
+        case AnimationTrackType::Bool:
+        case AnimationTrackType::BitVector2:
+        case AnimationTrackType::BitVector3:
+        case AnimationTrackType::BitVector4:
+            return 1;
+        case AnimationTrackType::Float:
+        case AnimationTrackType::UnsignedInt:
+        case AnimationTrackType::Int:
+        case AnimationTrackType::Vector2:
+        case AnimationTrackType::Vector2ui:
+        case AnimationTrackType::Vector2i:
+        case AnimationTrackType::Complex:
+        case AnimationTrackType::Vector3:
+        case AnimationTrackType::Vector3ui:
+        case AnimationTrackType::Vector3i:
+        case AnimationTrackType::CubicHermite1D:
+        case AnimationTrackType::Vector4:
+        case AnimationTrackType::Vector4ui:
+        case AnimationTrackType::Vector4i:
+        case AnimationTrackType::Quaternion:
+        case AnimationTrackType::CubicHermite2D:
+        case AnimationTrackType::CubicHermiteComplex:
+        case AnimationTrackType::DualQuaternion:
+        case AnimationTrackType::CubicHermite3D:
+        case AnimationTrackType::CubicHermiteQuaternion:
+            return 4;
+    }
+    #ifdef CORRADE_TARGET_GCC
+    #pragma GCC diagnostic pop
+    #endif
+
+    CORRADE_ASSERT_UNREACHABLE("Trade::animationTrackTypeAlignment(): invalid type" << type, {});
+}
+
 Debug& operator<<(Debug& debug, const AnimationTrackTarget value) {
     const bool packed = debug.immediateFlags() >= Debug::Flag::Packed;
 

src/Magnum/Trade/AnimationData.h

@@ -41,7 +41,10 @@ namespace Magnum { namespace Trade {
 /**
 @brief Type of animation track data
 
-@see @ref AnimationData
+A type in which track data for given @ref AnimationTrackTarget is stored, See
+@ref AnimationData for more information.
+@see @ref AnimationData, @ref animationTrackTypeSize(),
+    @ref animationTrackTypeAlignment()
 @experimental
 */
 enum class AnimationTrackType: UnsignedByte {
@@ -165,6 +168,22 @@ enum class AnimationTrackType: UnsignedByte {
 /** @debugoperatorenum{AnimationTrackType} */
 MAGNUM_TRADE_EXPORT Debug& operator<<(Debug& debug, AnimationTrackType value);
 
+/**
+@brief Size of given animation track data type
+@m_since_latest
+
+@see @ref animationTrackTypeAlignment()
+*/
+MAGNUM_TRADE_EXPORT UnsignedInt animationTrackTypeSize(AnimationTrackType type);
+
+/**
+@brief Alignment of given animation track data type
+@m_since_latest
+
+@see @ref animationTrackTypeSize()
+*/
+MAGNUM_TRADE_EXPORT UnsignedInt animationTrackTypeAlignment(AnimationTrackType type);
+
 namespace Implementation {
     enum: UnsignedShort { AnimationTrackTargetCustom = 32768 };
 }

src/Magnum/Trade/Test/AnimationDataTest.cpp

@@ -28,7 +28,7 @@
 #include <Corrade/Utility/DebugStl.h>
 
 #include "Magnum/Math/CubicHermite.h"
-#include "Magnum/Math/Quaternion.h"
+#include "Magnum/Math/DualQuaternion.h"
 #include "Magnum/Trade/AnimationData.h"
 
 namespace Magnum { namespace Trade { namespace Test { namespace {
@@ -36,6 +36,8 @@ namespace Magnum { namespace Trade { namespace Test { namespace {
 struct AnimationDataTest: TestSuite::Tester {
     explicit AnimationDataTest();
 
+    void trackTypeSizeAlignment();
+    void trackTypeSizeAlignmentInvalid();
     void debugTrackType();
     void debugTrackTypePacked();
 
@@ -97,7 +99,9 @@ struct {
 };
 
 AnimationDataTest::AnimationDataTest() {
-    addTests({&AnimationDataTest::debugTrackType,
+    addTests({&AnimationDataTest::trackTypeSizeAlignment,
+              &AnimationDataTest::trackTypeSizeAlignmentInvalid,
+              &AnimationDataTest::debugTrackType,
               &AnimationDataTest::debugTrackTypePacked,
 
               &AnimationDataTest::customTrackTarget,
@@ -154,6 +158,41 @@ AnimationDataTest::AnimationDataTest() {
 
 using namespace Math::Literals;
 
+void AnimationDataTest::trackTypeSizeAlignment() {
+    /* Obvious cases */
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::BitVector3), sizeof(BitVector3));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::UnsignedInt), sizeof(UnsignedInt));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::Vector2), sizeof(Vector2));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::Vector4i), sizeof(Vector4i));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::DualQuaternion), sizeof(DualQuaternion));
+    /* Possibly non-obvious */
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::CubicHermite1D), sizeof(CubicHermite1D));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::CubicHermiteComplex), sizeof(CubicHermiteComplex));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::CubicHermite3D), sizeof(CubicHermite3D));
+    CORRADE_COMPARE(animationTrackTypeSize(AnimationTrackType::CubicHermiteQuaternion), sizeof(CubicHermiteQuaternion));
+
+    /* Alignment is 4 for most types, except for bit-sized ones */
+    CORRADE_COMPARE(animationTrackTypeAlignment(AnimationTrackType::BitVector4), 1);
+    CORRADE_COMPARE(animationTrackTypeAlignment(AnimationTrackType::Float), alignof(Float));
+    CORRADE_COMPARE(animationTrackTypeAlignment(AnimationTrackType::CubicHermiteQuaternion), alignof(CubicHermiteQuaternion));
+}
+
+void AnimationDataTest::trackTypeSizeAlignmentInvalid() {
+    CORRADE_SKIP_IF_NO_ASSERT();
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    animationTrackTypeSize(AnimationTrackType{});
+    animationTrackTypeAlignment(AnimationTrackType{});
+    animationTrackTypeSize(AnimationTrackType(0x73));
+    animationTrackTypeAlignment(AnimationTrackType(0x73));
+    CORRADE_COMPARE(out.str(),
+        "Trade::animationTrackTypeSize(): invalid type Trade::AnimationTrackType(0x0)\n"
+        "Trade::animationTrackTypeAlignment(): invalid type Trade::AnimationTrackType(0x0)\n"
+        "Trade::animationTrackTypeSize(): invalid type Trade::AnimationTrackType(0x73)\n"
+        "Trade::animationTrackTypeAlignment(): invalid type Trade::AnimationTrackType(0x73)\n");
+}
+
 void AnimationDataTest::debugTrackType() {
     std::ostringstream out;