Math: ability to convert Bezier underlying type.

src/Magnum/Math/Bezier.h

@@ -50,6 +50,8 @@ Implementation of M-order N-dimensional
 template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
     static_assert(order != 0, "Bezier cannot have zero order");
 
+    template<UnsignedInt, UnsignedInt, class> friend class Bezier;
+
     public:
         typedef T Type;             /**< @brief Underlying data type */
 
@@ -85,6 +87,14 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
             static_assert(sizeof...(U) + 1 == order + 1, "Wrong number of arguments");
         }
 
+        /**
+         * @brief Construct Bézier curve from another of different type
+         *
+         * Performs only default casting on the values, no rounding or
+         * anything else.
+         */
+        template<class U> constexpr explicit Bezier(const Bezier<order, dimensions, U>& other) noexcept: Bezier{typename Implementation::GenerateSequence<order + 1>::Type(), other} {}
+
         /**
          * @brief Subdivide the curve
          * @param t The interpolation factor
@@ -137,6 +147,9 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
         }
 
     private:
+        /* Implementation for Bezier<order, dimensions, T>::Bezier(const Bezier<order, dimensions, U>&) */
+        template<class U, std::size_t ...sequence> constexpr explicit Bezier(Implementation::Sequence<sequence...>, const Bezier<order, dimensions, U>& other) noexcept: _data{Vector<dimensions, T>(other._data[sequence])...} {}
+
         /* Implementation for Bezier<order, dimensions, T>::Bezier(ZeroInitT) and Bezier<order, dimensions, T>::Bezier(NoInitT) */
         /* MSVC 2015 can't handle {} here */
         template<class U, std::size_t ...sequence> constexpr explicit Bezier(Implementation::Sequence<sequence...>, U): _data{Vector<dimensions, T>((static_cast<void>(sequence), U{typename U::Init{}}))...} {}

src/Magnum/Math/Test/BezierTest.cpp

@@ -35,7 +35,9 @@
 namespace Magnum { namespace Math { namespace Test {
 
 typedef Math::Vector2<Float> Vector2;
+typedef Math::Vector2<Double> Vector2d;
 typedef Math::QuadraticBezier2D<Float> QuadraticBezier2D;
+typedef Math::QuadraticBezier2D<Double> QuadraticBezier2Dd;
 typedef Math::CubicBezier2D<Float> CubicBezier2D;
 
 struct BezierTest : Corrade::TestSuite::Tester {
@@ -44,6 +46,7 @@ struct BezierTest : Corrade::TestSuite::Tester {
     void construct();
     void constructDefault();
     void constructNoInit();
+    void constructConversion();
     void constructCopy();
 
     void data();
@@ -61,6 +64,7 @@ BezierTest::BezierTest() {
     addTests({&BezierTest::construct,
               &BezierTest::constructDefault,
               &BezierTest::constructNoInit,
+              &BezierTest::constructConversion,
               &BezierTest::constructCopy,
 
               &BezierTest::data,
@@ -100,6 +104,18 @@ void BezierTest::constructNoInit() {
     CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, NoInitT>::value));
 }
 
+void BezierTest::constructConversion() {
+    constexpr QuadraticBezier2Dd a{Vector2d{0.5, 1.0}, Vector2d{1.1, 0.3}, Vector2d{0.1, 1.2}};
+    constexpr QuadraticBezier2D b{a};
+
+    CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
+
+    /* Implicit conversion is not allowed */
+    CORRADE_VERIFY(!(std::is_convertible<QuadraticBezier2Dd, QuadraticBezier2D>::value));
+
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, QuadraticBezier2Dd>::value));
+}
+
 void BezierTest::constructCopy() {
     constexpr QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
     constexpr QuadraticBezier2D b{a};