Math: ability to use [Dual]Complex and [Dual]Quaternion in configuration.

doc/changelog.dox

@@ -83,6 +83,9 @@ See also:
     @ref Math::Distance::pointPlane() and others
 -   Ability to convert @ref Math::BoolVector from and to external
     representation
+-   Ability to use @ref Math::Complex, @ref Math::DualComplex,
+    @ref Math::Quaternion, @ref Math::DualQuaternion with
+    @ref Corrade::Utility::Configuration and @ref Corrade::Utility::Arguments
 
 @subsubsection changelog-latest-new-platform Platform libraries
 

src/Magnum/Math/Complex.h

@@ -471,4 +471,26 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 
 }}
 
+namespace Corrade { namespace Utility {
+
+/** @configurationvalue{Magnum::Math::Complex} */
+template<class T> struct ConfigurationValue<Magnum::Math::Complex<T>> {
+    ConfigurationValue() = delete;
+
+    /** @brief Writes elements separated with spaces */
+    static std::string toString(const Magnum::Math::Complex<T>& value, ConfigurationValueFlags flags) {
+        return ConfigurationValue<Magnum::Math::Vector<2, T>>::toString(reinterpret_cast<const Magnum::Math::Vector<2, T>&>(value), flags);
+    }
+
+    /** @brief Reads elements separated with whitespace */
+    static Magnum::Math::Complex<T> fromString(const std::string& stringValue, ConfigurationValueFlags flags) {
+        const Magnum::Math::Vector<2, T> value = ConfigurationValue<Magnum::Math::Vector<2, T>>::fromString(stringValue, flags);
+        return reinterpret_cast<const Magnum::Math::Complex<T>&>(value);
+    }
+};
+
+/* No explicit instantiation needed, as Vector<2, T> is instantiated already */
+
+}}
+
 #endif

src/Magnum/Math/DualComplex.h

@@ -372,4 +372,26 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 
 }}
 
+namespace Corrade { namespace Utility {
+
+/** @configurationvalue{Magnum::Math::DualComplex} */
+template<class T> struct ConfigurationValue<Magnum::Math::DualComplex<T>> {
+    ConfigurationValue() = delete;
+
+    /** @brief Writes elements separated with spaces */
+    static std::string toString(const Magnum::Math::DualComplex<T>& value, ConfigurationValueFlags flags) {
+        return ConfigurationValue<Magnum::Math::Vector<4, T>>::toString(reinterpret_cast<const Magnum::Math::Vector<4, T>&>(value), flags);
+    }
+
+    /** @brief Reads elements separated with whitespace */
+    static Magnum::Math::DualComplex<T> fromString(const std::string& stringValue, ConfigurationValueFlags flags) {
+        const Magnum::Math::Vector<4, T> value = ConfigurationValue<Magnum::Math::Vector<4, T>>::fromString(stringValue, flags);
+        return reinterpret_cast<const Magnum::Math::DualComplex<T>&>(value);
+    }
+};
+
+/* No explicit instantiation needed, as Vector<4, T> is instantiated already */
+
+}}
+
 #endif

src/Magnum/Math/DualQuaternion.h

@@ -451,4 +451,30 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 
 }}
 
+namespace Corrade { namespace Utility {
+
+/** @configurationvalue{Magnum::Math::DualQuaternion} */
+template<class T> struct ConfigurationValue<Magnum::Math::DualQuaternion<T>> {
+    ConfigurationValue() = delete;
+
+    /** @brief Writes elements separated with spaces */
+    static std::string toString(const Magnum::Math::DualQuaternion<T>& value, ConfigurationValueFlags flags) {
+        return ConfigurationValue<Magnum::Math::Vector<8, T>>::toString(reinterpret_cast<const Magnum::Math::Vector<8, T>&>(value), flags);
+    }
+
+    /** @brief Reads elements separated with whitespace */
+    static Magnum::Math::DualQuaternion<T> fromString(const std::string& stringValue, ConfigurationValueFlags flags) {
+        const Magnum::Math::Vector<8, T> value = ConfigurationValue<Magnum::Math::Vector<8, T>>::fromString(stringValue, flags);
+        return reinterpret_cast<const Magnum::Math::DualQuaternion<T>&>(value);
+    }
+};
+
+/* Explicit instantiation for commonly used types */
+#if !defined(DOXYGEN_GENERATING_OUTPUT) && !defined(__MINGW32__)
+extern template struct MAGNUM_EXPORT ConfigurationValue<Magnum::Math::DualQuaternion<Magnum::Float>>;
+extern template struct MAGNUM_EXPORT ConfigurationValue<Magnum::Math::DualQuaternion<Magnum::Double>>;
+#endif
+
+}}
+
 #endif

src/Magnum/Math/Quaternion.h

@@ -614,4 +614,26 @@ template<class T> inline Vector3<T> Quaternion<T>::transformVectorNormalized(con
 
 }}
 
+namespace Corrade { namespace Utility {
+
+/** @configurationvalue{Magnum::Math::Quaternion} */
+template<class T> struct ConfigurationValue<Magnum::Math::Quaternion<T>> {
+    ConfigurationValue() = delete;
+
+    /** @brief Writes elements separated with spaces */
+    static std::string toString(const Magnum::Math::Quaternion<T>& value, ConfigurationValueFlags flags) {
+        return ConfigurationValue<Magnum::Math::Vector<4, T>>::toString(reinterpret_cast<const Magnum::Math::Vector<4, T>&>(value), flags);
+    }
+
+    /** @brief Reads elements separated with whitespace */
+    static Magnum::Math::Quaternion<T> fromString(const std::string& stringValue, ConfigurationValueFlags flags) {
+        const Magnum::Math::Vector<4, T> value = ConfigurationValue<Magnum::Math::Vector<4, T>>::fromString(stringValue, flags);
+        return reinterpret_cast<const Magnum::Math::Quaternion<T>&>(value);
+    }
+};
+
+/* No explicit instantiation needed, as Vector<4, T> is instantiated already */
+
+}}
+
 #endif

src/Magnum/Math/Test/ComplexTest.cpp

@@ -25,6 +25,7 @@
 
 #include <sstream>
 #include <Corrade/TestSuite/Tester.h>
+#include <Corrade/Utility/Configuration.h>
 
 #include "Magnum/Math/Complex.h"
 #include "Magnum/Math/Matrix3.h"
@@ -88,6 +89,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
     void transformVector();
 
     void debug();
+    void configuration();
 };
 
 ComplexTest::ComplexTest() {
@@ -128,7 +130,8 @@ ComplexTest::ComplexTest() {
               &ComplexTest::matrix,
               &ComplexTest::transformVector,
 
-              &ComplexTest::debug});
+              &ComplexTest::debug,
+              &ComplexTest::configuration});
 }
 
 typedef Math::Deg<Float> Deg;
@@ -425,6 +428,25 @@ void ComplexTest::debug() {
     CORRADE_COMPARE(o.str(), "Complex(2.5, -7.5)\n");
 }
 
+void ComplexTest::configuration() {
+    Corrade::Utility::Configuration c;
+
+    Complex x{3.0f, 3.125f};
+    std::string value{"3 3.125"};
+
+    c.setValue("complex", x);
+    CORRADE_COMPARE(c.value("complex"), value);
+    CORRADE_COMPARE(c.value<Complex>("complex"), x);
+
+    /* Underflow */
+    c.setValue("underflow", "2.1");
+    CORRADE_COMPARE(c.value<Complex>("underflow"), (Complex{2.1f, 0.0f}));
+
+    /* Overflow */
+    c.setValue("overflow", "2 9 16 33");
+    CORRADE_COMPARE(c.value<Complex>("overflow"), (Complex{2.0f, 9.0f}));
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::ComplexTest)

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -25,6 +25,7 @@
 
 #include <sstream>
 #include <Corrade/TestSuite/Tester.h>
+#include <Corrade/Utility/Configuration.h>
 
 #include "Magnum/Math/DualComplex.h"
 #include "Magnum/Math/DualQuaternion.h"
@@ -87,6 +88,7 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
     void transformPoint();
 
     void debug();
+    void configuration();
 };
 
 typedef Math::Deg<Float> Deg;
@@ -135,7 +137,8 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::matrix,
               &DualComplexTest::transformPoint,
 
-              &DualComplexTest::debug});
+              &DualComplexTest::debug,
+              &DualComplexTest::configuration});
 }
 
 void DualComplexTest::construct() {
@@ -418,6 +421,25 @@ void DualComplexTest::debug() {
     CORRADE_COMPARE(o.str(), "DualComplex({-1, -2.5}, {-3, -7.5})\n");
 }
 
+void DualComplexTest::configuration() {
+    Corrade::Utility::Configuration c;
+
+    DualComplex a{{3.0f, 3.125f}, {9.0f, 9.55f}};
+    std::string value("3 3.125 9 9.55");
+
+    c.setValue("dualcomplex", a);
+    CORRADE_COMPARE(c.value("dualcomplex"), value);
+    CORRADE_COMPARE(c.value<DualComplex>("dualcomplex"), a);
+
+    /* Underflow */
+    c.setValue("underflow", "2.1 8.9");
+    CORRADE_COMPARE(c.value<DualComplex>("underflow"), (DualComplex{{2.1f, 8.9f}, {0.0f, 0.0f}}));
+
+    /* Overflow */
+    c.setValue("overflow", "2 1 8 9 16 33");
+    CORRADE_COMPARE(c.value<DualComplex>("overflow"), (DualComplex{{2.0f, 1.0f}, {8.0f, 9.0f}}));
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DualComplexTest)

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -25,6 +25,7 @@
 
 #include <sstream>
 #include <Corrade/TestSuite/Tester.h>
+#include <Corrade/Utility/Configuration.h>
 
 #include "Magnum/Math/DualQuaternion.h"
 
@@ -91,6 +92,7 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     void sclerp();
 
     void debug();
+    void configuration();
 };
 
 typedef Math::Deg<Float> Deg;
@@ -143,7 +145,8 @@ DualQuaternionTest::DualQuaternionTest() {
 
               &DualQuaternionTest::sclerp,
 
-              &DualQuaternionTest::debug});
+              &DualQuaternionTest::debug,
+              &DualQuaternionTest::configuration});
 }
 
 void DualQuaternionTest::construct() {
@@ -513,6 +516,25 @@ void DualQuaternionTest::debug() {
     CORRADE_COMPARE(o.str(), "DualQuaternion({{1, 2, 3}, -4}, {{0.5, -3.1, 3.3}, 2})\n");
 }
 
+void DualQuaternionTest::configuration() {
+    Corrade::Utility::Configuration c;
+
+    DualQuaternion a{{{3.0f, 3.125f, 9.0f}, 9.55f}, {{-1.2f, 0.3f, 1.1f}, 92.05f}};
+    std::string value{"3 3.125 9 9.55 -1.2 0.3 1.1 92.05"};
+
+    c.setValue("dualquat", a);
+    CORRADE_COMPARE(c.value("dualquat"), value);
+    CORRADE_COMPARE(c.value<DualQuaternion>("dualquat"), a);
+
+    /* Underflow */
+    c.setValue("underflow", "2.1 8.9");
+    CORRADE_COMPARE(c.value<DualQuaternion>("underflow"), (DualQuaternion{{{2.1f, 8.9f, 0.0f}, 0.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}}));
+
+    /* Overflow */
+    c.setValue("overflow", "2 1 8 9 16 33 -1 5 2 10");
+    CORRADE_COMPARE(c.value<DualQuaternion>("overflow"), (DualQuaternion{{{2.0f, 1.0f, 8.0f}, 9.0f}, {{16.0f, 33.0f, -1.0f}, 5.0f}}));
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DualQuaternionTest)

src/Magnum/Math/Test/QuaternionTest.cpp

@@ -26,6 +26,7 @@
 #include <sstream>
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/TestSuite/Compare/Numeric.h>
+#include <Corrade/Utility/Configuration.h>
 
 #include "Magnum/Math/Matrix4.h"
 #include "Magnum/Math/Quaternion.h"
@@ -92,6 +93,7 @@ struct QuaternionTest: Corrade::TestSuite::Tester {
     void transformVectorNormalized();
 
     void debug();
+    void configuration();
 };
 
 typedef Math::Deg<Float> Deg;
@@ -143,7 +145,8 @@ QuaternionTest::QuaternionTest() {
               &QuaternionTest::transformVector,
               &QuaternionTest::transformVectorNormalized,
 
-              &QuaternionTest::debug});
+              &QuaternionTest::debug,
+              &QuaternionTest::configuration});
 }
 
 void QuaternionTest::construct() {
@@ -523,6 +526,25 @@ void QuaternionTest::debug() {
     CORRADE_COMPARE(o.str(), "Quaternion({1, 2, 3}, -4)\n");
 }
 
+void QuaternionTest::configuration() {
+    Corrade::Utility::Configuration c;
+
+    Quaternion q{{3.0f, 3.125f, 9.0f}, 9.55f};
+    std::string value{"3 3.125 9 9.55"};
+
+    c.setValue("quat", q);
+    CORRADE_COMPARE(c.value("quat"), value);
+    CORRADE_COMPARE(c.value<Quaternion>("quat"), q);
+
+    /* Underflow */
+    c.setValue("underflow", "2.1 8.9");
+    CORRADE_COMPARE(c.value<Quaternion>("underflow"), (Quaternion{{2.1f, 8.9f, 0.0f}, 0.0f}));
+
+    /* Overflow */
+    c.setValue("overflow", "2 1 8 9 16 33");
+    CORRADE_COMPARE(c.value<Quaternion>("overflow"), (Quaternion{{2.0f, 1.0f, 8.0f}, 9.0f}));
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::QuaternionTest)

src/Magnum/Math/instantiation.cpp

@@ -80,6 +80,11 @@ template struct ConfigurationValue<Magnum::Math::Range<3, Magnum::Float>>;
 template struct ConfigurationValue<Magnum::Math::Range<3, Magnum::Int>>;
 template struct ConfigurationValue<Magnum::Math::Range<2, Magnum::Double>>;
 template struct ConfigurationValue<Magnum::Math::Range<3, Magnum::Double>>;
+
+/* Other (complex, dual complex, quaternion) just reinterpret to 2/4-component
+   vectors instantiated above */
+template struct ConfigurationValue<Magnum::Math::DualQuaternion<Magnum::Float>>;
+template struct ConfigurationValue<Magnum::Math::DualQuaternion<Magnum::Double>>;
 #endif
 
 }}