From 3a8ac0290937f48580da61aa50e7d97d03ceb57a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Sat, 20 Jun 2015 23:03:14 +0200
Subject: [PATCH] Math: more explicit default zero/identity constructors.

Some classes are by default constructed zero-filled while other are set
to identity and the only way to to check this is to look into the
documentation. This changes the default constructor of all classes to
take an optional "tag" which acts as documentation about how the type is
constructed. Note that this result in no behavioral changes, just
ability to be more explicit when writing the code. Example:

    // These two are equivalent
    Quaternion q1;
    Quaternion q2{Math::IdentityInit};

    // These two are equivalent
    Vector4 vec1;
    Vector4 vec2{Math::ZeroInit};

    Matrix4 a{Math::IdentityInit, 2}; // 2 on diagonal
    Matrix4 b{Math::ZeroInit};        // all zero

This functionality was already present in some ugly form in Matrix,
Matrix3 and Matrix4 classes. It was long and ugly to write, so it is
now generalized into the new Math::IdentityInit and Math::ZeroInit tags,
the original Matrix::IdentityType, Matrix::Identity, Matrix::ZeroType
and Matrix::Zero are deprecated and will be removed in the future
release.

    Math::Matrix<7, Int> m{Math::Matrix<7, Int>::Identity}; // before
    Math::Matrix<7, Int> m{Math::IdentityInit};             // now
---
 src/Magnum/Color.h                            |  2 +-
 src/Magnum/Math/Algorithms/Svd.h              |  4 +-
 src/Magnum/Math/Algorithms/Test/SvdTest.cpp   |  8 ++--
 src/Magnum/Math/Angle.h                       |  6 +--
 src/Magnum/Math/BoolVector.h                  |  3 +-
 src/Magnum/Math/Complex.h                     |  2 +-
 src/Magnum/Math/DualComplex.h                 |  4 +-
 src/Magnum/Math/DualQuaternion.h              |  4 +-
 src/Magnum/Math/Matrix.h                      | 39 ++++++++++++-------
 src/Magnum/Math/Matrix3.h                     | 13 +++----
 src/Magnum/Math/Matrix4.h                     | 13 +++----
 src/Magnum/Math/Quaternion.h                  |  2 +-
 src/Magnum/Math/Range.h                       | 12 +++---
 src/Magnum/Math/RectangularMatrix.h           |  5 ++-
 src/Magnum/Math/Test/AngleTest.cpp            | 18 ++++++---
 src/Magnum/Math/Test/BoolVectorTest.cpp       |  2 +
 src/Magnum/Math/Test/ComplexTest.cpp          |  9 +++--
 src/Magnum/Math/Test/DualComplexTest.cpp      |  9 +++--
 src/Magnum/Math/Test/DualQuaternionTest.cpp   |  9 +++--
 src/Magnum/Math/Test/Matrix3Test.cpp          |  6 +--
 src/Magnum/Math/Test/Matrix4Test.cpp          |  6 +--
 src/Magnum/Math/Test/MatrixTest.cpp           |  6 +--
 src/Magnum/Math/Test/QuaternionTest.cpp       |  9 +++--
 src/Magnum/Math/Test/RangeTest.cpp            | 20 ++++++----
 .../Math/Test/RectangularMatrixTest.cpp       |  5 +++
 src/Magnum/Math/Test/Vector2Test.cpp          |  2 +
 src/Magnum/Math/Test/Vector3Test.cpp          |  2 +
 src/Magnum/Math/Test/Vector4Test.cpp          |  2 +
 src/Magnum/Math/Test/VectorTest.cpp           |  2 +
 src/Magnum/Math/Unit.h                        |  5 ++-
 src/Magnum/Math/Vector.h                      |  2 +-
 src/Magnum/Math/Vector2.h                     |  4 +-
 src/Magnum/Math/Vector3.h                     |  4 +-
 src/Magnum/Math/Vector4.h                     |  4 +-
 src/Magnum/SceneGraph/Test/ObjectTest.cpp     | 12 +++---
 src/Magnum/Shapes/Box.h                       |  2 +-
 src/Magnum/Test/ColorTest.cpp                 |  6 ++-
 37 files changed, 160 insertions(+), 103 deletions(-)

diff --git a/src/Magnum/Color.h b/src/Magnum/Color.h
index 66ce2c3b6..6ff9c2976 100644
--- a/src/Magnum/Color.h
+++ b/src/Magnum/Color.h
@@ -254,7 +254,7 @@ template<class T> class BasicColor3: public Math::Vector3<T> {
          *
          * All components are set to zero.
          */
-        constexpr /*implicit*/ BasicColor3() {}
+        constexpr /*implicit*/ BasicColor3(Math::ZeroInitT = Math::ZeroInit): Math::Vector3<T>{Math::ZeroInit} {}
 
         /**
          * @brief Gray constructor
diff --git a/src/Magnum/Math/Algorithms/Svd.h b/src/Magnum/Math/Algorithms/Svd.h
index 824edc3f5..5dfa4e93f 100644
--- a/src/Magnum/Math/Algorithms/Svd.h
+++ b/src/Magnum/Math/Algorithms/Svd.h
@@ -102,7 +102,7 @@ template<std::size_t cols, std::size_t rows, class T> std::tuple<RectangularMatr
     static_assert(tol > T(0), "Tol too small");
     constexpr std::size_t maxIterations = 50;
 
-    Matrix<cols, T> v(Matrix<cols, T>::Zero);
+    Matrix<cols, T> v{ZeroInit};
     Vector<cols, T> e, q;
 
     /* Householder's reduction to bidiagonal form */
@@ -270,7 +270,7 @@ template<std::size_t cols, std::size_t rows, class T> std::tuple<RectangularMatr
             /* Exceeded iteration count, done */
             } else if(iteration >= maxIterations-1) {
                 Corrade::Utility::Error() << "Magnum::Math::Algorithms::svd(): no convergence";
-                return std::make_tuple(RectangularMatrix<cols, rows, T>(), Vector<cols, T>(), Matrix<cols, T>(Matrix<cols, T>::Zero));
+                return std::make_tuple(RectangularMatrix<cols, rows, T>{}, Vector<cols, T>{}, Matrix<cols, T>{ZeroInit});
             }
 
             /* Shift from bottom 2x2 minor */
diff --git a/src/Magnum/Math/Algorithms/Test/SvdTest.cpp b/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
index e17de15bf..6cc826c27 100644
--- a/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
+++ b/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
@@ -88,8 +88,8 @@ void SvdTest::testDouble() {
     CORRADE_COMPARE(u2*w2*v.transposed(), ad);
 
     /* Test that V is unitary */
-    CORRADE_COMPARE(v*v.transposed(), Matrix5d(Matrix5d::Identity));
-    CORRADE_COMPARE(v.transposed()*v, Matrix5d(Matrix5d::Identity));
+    CORRADE_COMPARE(v*v.transposed(), Matrix5d{IdentityInit});
+    CORRADE_COMPARE(v.transposed()*v, Matrix5d{IdentityInit});
 
     /* Test W */
     CORRADE_COMPARE(w, expectedd);
@@ -110,8 +110,8 @@ void SvdTest::testFloat() {
     CORRADE_VERIFY(Math::abs((u2*w2*v.transposed()-af).toVector()).max() < 1.0e-5f);
 
     /* Test that V is unitary */
-    CORRADE_COMPARE(v*v.transposed(), Matrix5f(Matrix5f::Identity));
-    CORRADE_COMPARE(v.transposed()*v, Matrix5f(Matrix5f::Identity));
+    CORRADE_COMPARE(v*v.transposed(), Matrix5f{IdentityInit});
+    CORRADE_COMPARE(v.transposed()*v, Matrix5f{IdentityInit});
 
     /* Test W (single precision is not enough, test for similarity) */
     CORRADE_VERIFY(Math::abs(w-expectedf).max() < 1.0e-5f);
diff --git a/src/Magnum/Math/Angle.h b/src/Magnum/Math/Angle.h
index 79ea78849..6a4c83092 100644
--- a/src/Magnum/Math/Angle.h
+++ b/src/Magnum/Math/Angle.h
@@ -123,8 +123,8 @@ std::sin(Float(Rad<Float>(b));  // required explicit conversion hints to user
 */
 template<class T> class Deg: public Unit<Deg, T> {
     public:
-        /** @brief Default constructor */
-        constexpr /*implicit*/ Deg() {}
+        /** @brief Construct zero angle */
+        constexpr /*implicit*/ Deg(ZeroInitT = ZeroInit): Unit<Deg, T>{ZeroInit} {}
 
         /** @brief Explicit constructor from unitless type */
         constexpr explicit Deg(T value): Unit<Math::Deg, T>(value) {}
@@ -182,7 +182,7 @@ See @ref Deg for more information.
 template<class T> class Rad: public Unit<Rad, T> {
     public:
         /** @brief Default constructor */
-        constexpr /*implicit*/ Rad() {}
+        constexpr /*implicit*/ Rad(ZeroInitT = ZeroInit): Unit<Rad, T>{ZeroInit} {}
 
         /** @brief Construct from unitless type */
         constexpr explicit Rad(T value): Unit<Math::Rad, T>(value) {}
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 8b1edefa5..3e4c951f8 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -33,6 +33,7 @@
 #include <Corrade/Utility/Debug.h>
 
 #include "Magnum/Types.h"
+#include "Magnum/Math/Tags.h"
 
 namespace Magnum { namespace Math {
 
@@ -70,7 +71,7 @@ template<std::size_t size> class BoolVector {
         static const std::size_t DataSize = (size-1)/8+1;   /**< @brief Vector storage size */
 
         /** @brief Construct zero-filled boolean vector */
-        constexpr BoolVector(): _data() {}
+        constexpr /*implicit*/ BoolVector(ZeroInitT = ZeroInit): _data{} {}
 
         /**
          * @brief Construct boolean vector from segment values
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index b299edbee..19ee98fbc 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -140,7 +140,7 @@ template<class T> class Complex {
          *      c = 1 + i0
          * @f]
          */
-        constexpr /*implicit*/ Complex(): _real(T(1)), _imaginary(T(0)) {}
+        constexpr /*implicit*/ Complex(IdentityInitT = IdentityInit): _real(T(1)), _imaginary(T(0)) {}
 
         /**
          * @brief Construct complex number from real and imaginary part
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index 0b6c90b66..7ffb80b28 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -104,9 +104,9 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
          * @f]
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr /*implicit*/ DualComplex();
+        constexpr /*implicit*/ DualComplex(IdentityInitT = IdentityInit);
         #else
-        constexpr /*implicit*/ DualComplex(): Dual<Complex<T>>({}, {T(0), T(0)}) {}
+        constexpr /*implicit*/ DualComplex(IdentityInitT = IdentityInit): Dual<Complex<T>>({}, {T(0), T(0)}) {}
         #endif
 
         /**
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index a9415d67b..09cf6a4d1 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -110,9 +110,9 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
          * @f]
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr /*implicit*/ DualQuaternion();
+        constexpr /*implicit*/ DualQuaternion(IdentityInitT = IdentityInit);
         #else
-        constexpr /*implicit*/ DualQuaternion(): Dual<Quaternion<T>>({}, {{}, T(0)}) {}
+        constexpr /*implicit*/ DualQuaternion(IdentityInitT = IdentityInit): Dual<Quaternion<T>>({}, {{}, T(0)}) {}
         #endif
 
         /**
diff --git a/src/Magnum/Math/Matrix.h b/src/Magnum/Math/Matrix.h
index 380df95e4..be5c8fe37 100644
--- a/src/Magnum/Math/Matrix.h
+++ b/src/Magnum/Math/Matrix.h
@@ -51,27 +51,40 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
     public:
         const static std::size_t Size = size; /**< @brief Matrix size */
 
-        /** @brief Pass to constructor to create zero-filled matrix */
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief Pass to constructor to create zero-filled matrix
+         * @deprecated Use @ref ZeroInitT and @ref ZeroInit instead.
+         */
+        #ifdef DOXYGEN_GENERATING_OUTPUT
         enum ZeroType { Zero };
+        #else
+        CORRADE_DEPRECATED("use Math::ZeroInitT instead") typedef ZeroInitT ZeroType;
+        CORRADE_DEPRECATED("use Math::ZeroInit instead") constexpr static ZeroInitT Zero{};
+        #endif
 
         /**
-         * @brief Zero-filled matrix constructor
-         *
-         * Use this constructor by calling `Matrix m(Matrix::Zero);`.
+         * @brief Pass to constructor to create identity matrix
+         * @deprecated Use @ref IdentityInitT and @ref IdentityInit instead.
          */
-        constexpr explicit Matrix(ZeroType) {}
-
-        /** @brief Pass to constructor to create identity matrix */
+        #ifdef DOXYGEN_GENERATING_OUTPUT
         enum IdentityType { Identity };
+        #else
+        CORRADE_DEPRECATED("use Math::IdentityInitT instead") typedef IdentityInitT IdentityType;
+        CORRADE_DEPRECATED("use Math::IdentityInit instead") constexpr static IdentityInitT Identity{};
+        #endif
+        #endif
 
         /**
          * @brief Default constructor
          *
-         * You can also explicitly call this constructor with
-         * `Matrix m(Matrix::Identity);`. Optional parameter @p value allows
-         * you to specify value on diagonal.
+         * Creates identity matrix. @p value allows you to specify value on
+         * diagonal.
          */
-        constexpr /*implicit*/ Matrix(IdentityType = Identity, T value = T(1)): RectangularMatrix<size, size, T>(typename Implementation::GenerateSequence<size>::Type(), Vector<size, T>(value)) {}
+        constexpr /*implicit*/ Matrix(IdentityInitT = IdentityInit, T value = T(1)): RectangularMatrix<size, size, T>(typename Implementation::GenerateSequence<size>::Type(), Vector<size, T>(value)) {}
+
+        /** @copydoc RectangularMatrix::RectangularMatrix(ZeroInitT) */
+        constexpr explicit Matrix(ZeroInitT): RectangularMatrix<size, size, T>{ZeroInit} {}
 
         /**
          * @brief Matrix from column vectors
@@ -291,7 +304,7 @@ template<std::size_t size, class T> bool Matrix<size, T>::isOrthogonal() const {
 }
 
 template<std::size_t size, class T> Matrix<size-1, T> Matrix<size, T>::ij(const std::size_t skipCol, const std::size_t skipRow) const {
-    Matrix<size-1, T> out(Matrix<size-1, T>::Zero);
+    Matrix<size-1, T> out{ZeroInit};
 
     for(std::size_t col = 0; col != size-1; ++col)
         for(std::size_t row = 0; row != size-1; ++row)
@@ -302,7 +315,7 @@ template<std::size_t size, class T> Matrix<size-1, T> Matrix<size, T>::ij(const
 }
 
 template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::inverted() const {
-    Matrix<size, T> out(Zero);
+    Matrix<size, T> out{ZeroInit};
 
     const T _determinant = determinant();
 
diff --git a/src/Magnum/Math/Matrix3.h b/src/Magnum/Math/Matrix3.h
index cf9d1ad35..52cc74fb1 100644
--- a/src/Magnum/Math/Matrix3.h
+++ b/src/Magnum/Math/Matrix3.h
@@ -153,17 +153,16 @@ template<class T> class Matrix3: public Matrix3x3<T> {
                     {       translation, T(1)}};
         }
 
-        /** @copydoc Matrix::Matrix(ZeroType) */
-        constexpr explicit Matrix3(typename Matrix3x3<T>::ZeroType): Matrix3x3<T>(Matrix3x3<T>::Zero) {}
-
         /**
          * @brief Default constructor
          *
-         * Creates identity matrix. You can also explicitly call this
-         * constructor with `Matrix3 m(Matrix3::Identity);`. Optional
-         * parameter @p value allows you to specify value on diagonal.
+         * Creates identity matrix. @p value allows you to specify value on
+         * diagonal.
          */
-        constexpr /*implicit*/ Matrix3(typename Matrix3x3<T>::IdentityType = (Matrix3x3<T>::Identity), T value = T(1)): Matrix3x3<T>(Matrix3x3<T>::Identity, value) {}
+        constexpr /*implicit*/ Matrix3(IdentityInitT = IdentityInit, T value = T{1}): Matrix3x3<T>{IdentityInit, value} {}
+
+        /** @copydoc Matrix::Matrix(ZeroInitT) */
+        constexpr explicit Matrix3(ZeroInitT): Matrix3x3<T>{ZeroInit} {}
 
         /** @brief Matrix from column vectors */
         constexpr /*implicit*/ Matrix3(const Vector3<T>& first, const Vector3<T>& second, const Vector3<T>& third): Matrix3x3<T>(first, second, third) {}
diff --git a/src/Magnum/Math/Matrix4.h b/src/Magnum/Math/Matrix4.h
index d38d34eea..ca60d272a 100644
--- a/src/Magnum/Math/Matrix4.h
+++ b/src/Magnum/Math/Matrix4.h
@@ -249,17 +249,16 @@ template<class T> class Matrix4: public Matrix4x4<T> {
                     {       translation, T(1)}};
         }
 
-        /** @copydoc Matrix::Matrix(ZeroType) */
-        constexpr explicit Matrix4(typename Matrix4x4<T>::ZeroType): Matrix4x4<T>(Matrix4x4<T>::Zero) {}
-
         /**
          * @brief Default constructor
          *
-         * Creates identity matrix. You can also explicitly call this
-         * constructor with `Matrix4 m(Matrix4::Identity);`. Optional
-         * parameter @p value allows you to specify value on diagonal.
+         * Creates identity matrix. @p value allows you to specify value on
+         * diagonal.
          */
-        constexpr /*implicit*/ Matrix4(typename Matrix4x4<T>::IdentityType = (Matrix4x4<T>::Identity), T value = T(1)): Matrix4x4<T>(Matrix4x4<T>::Identity, value) {}
+        constexpr /*implicit*/ Matrix4(IdentityInitT = IdentityInit, T value = T{1}): Matrix4x4<T>{IdentityInit, value} {}
+
+        /** @copydoc Matrix::Matrix(ZeroInitT) */
+        constexpr explicit Matrix4(ZeroInitT): Matrix4x4<T>{ZeroInit} {}
 
         /** @brief Matrix from column vectors */
         constexpr /*implicit*/ Matrix4(const Vector4<T>& first, const Vector4<T>& second, const Vector4<T>& third, const Vector4<T>& fourth): Matrix4x4<T>(first, second, third, fourth) {}
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index a7274e744..07d35787c 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -197,7 +197,7 @@ template<class T> class Quaternion {
          *      q = [\boldsymbol 0, 1]
          * @f]
          */
-        constexpr /*implicit*/ Quaternion(): _scalar(T(1)) {}
+        constexpr /*implicit*/ Quaternion(IdentityInitT = IdentityInit): _vector{T(0)}, _scalar{T(1)} {}
 
         /**
          * @brief Construct quaternion from vector and scalar
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 3821f3719..13396346d 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -75,10 +75,10 @@ template<UnsignedInt dimensions, class T> class Range {
          *
          * Construct zero-size range positioned at origin.
          */
-        constexpr Range(): _min{}, _max{} {}
+        constexpr /*implicit*/ Range(ZeroInitT = ZeroInit): _min{ZeroInit}, _max{ZeroInit} {}
 
         /** @brief Construct range from minimal and maximal coordinates */
-        constexpr Range(const VectorType& min, const VectorType& max): _min(min), _max(max) {}
+        constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max): _min{min}, _max{max} {}
 
         /** @brief Copy constructor */
         constexpr Range(const Range<dimensions, T>&) = default;
@@ -218,8 +218,8 @@ See @ref Range for more information.
 */
 template<class T> class Range2D: public Range<2, T> {
     public:
-        /** @copydoc Range() */
-        constexpr /*implicit*/ Range2D() {}
+        /** @copydoc Range(ZeroInitT) */
+        constexpr /*implicit*/ Range2D(ZeroInitT = ZeroInit): Range<2, T>{ZeroInit} {}
 
         /** @copydoc Range(const VectorType&, const VectorType&) */
         constexpr /*implicit*/ Range2D(const Vector2<T>& min, const Vector2<T>& max): Range<2, T>(min, max) {}
@@ -329,8 +329,8 @@ See @ref Range for more information.
 */
 template<class T> class Range3D: public Range<3, T> {
     public:
-        /** @copydoc Range() */
-        constexpr /*implicit*/ Range3D() {}
+        /** @copydoc Range(ZeroInitT) */
+        constexpr /*implicit*/ Range3D(ZeroInitT = ZeroInit): Range<3, T>{ZeroInit} {}
 
         /** @copydoc Range(const VectorType&, const VectorType&) */
         constexpr /*implicit*/ Range3D(const Vector3<T>& min, const Vector3<T>& max): Range<3, T>(min, max) {}
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index da933abe2..e2f731023 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -106,7 +106,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         }
 
         /** @brief Construct zero-filled matrix */
-        constexpr /*implicit*/ RectangularMatrix() {}
+        constexpr /*implicit*/ RectangularMatrix(ZeroInitT = ZeroInit): RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, ZeroInit} {}
 
         /**
          * @brief Construct matrix from column vectors
@@ -361,6 +361,9 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /* Implementation for RectangularMatrix<cols, rows, T>::RectangularMatrix(const RectangularMatrix<cols, rows, U>&) */
         template<class U, std::size_t ...sequence> constexpr explicit RectangularMatrix(Implementation::Sequence<sequence...>, const RectangularMatrix<cols, rows, U>& matrix): _data{Vector<rows, T>(matrix[sequence])...} {}
 
+        /* Implementation for RectangularMatrix<cols, rows, T>::RectangularMatrix(ZeroInitT) */
+        template<class U, std::size_t ...sequence> constexpr explicit RectangularMatrix(Implementation::Sequence<sequence...>, U): _data{Vector<rows, T>{(static_cast<void>(sequence), U{})}...} {}
+
         template<std::size_t ...sequence> constexpr Vector<DiagonalSize, T> diagonalInternal(Implementation::Sequence<sequence...>) const;
 
         Vector<rows, T> _data[cols];
diff --git a/src/Magnum/Math/Test/AngleTest.cpp b/src/Magnum/Math/Test/AngleTest.cpp
index 06d477d90..50a8708a2 100644
--- a/src/Magnum/Math/Test/AngleTest.cpp
+++ b/src/Magnum/Math/Test/AngleTest.cpp
@@ -59,14 +59,20 @@ AngleTest::AngleTest() {
 
 void AngleTest::construct() {
     /* Default constructor */
-    constexpr Deg m;
-    CORRADE_COMPARE(Float(m), 0.0f);
+    constexpr Deg m1;
+    constexpr Deg m2{ZeroInit};
+    CORRADE_COMPARE(Float(m1), 0.0f);
+    CORRADE_COMPARE(Float(m2), 0.0f);
     #ifndef MAGNUM_TARGET_GLES
-    constexpr Degd a;
-    CORRADE_COMPARE(Double(a), 0.0);
+    constexpr Radd a1;
+    constexpr Radd a2{ZeroInit};
+    CORRADE_COMPARE(Double(a1), 0.0);
+    CORRADE_COMPARE(Double(a2), 0.0);
     #else
-    constexpr Deg a;
-    CORRADE_COMPARE(Float(a), 0.0f);
+    constexpr Rad a1;
+    constexpr Rad a2{ZeroInit};
+    CORRADE_COMPARE(Float(a1), 0.0f);
+    CORRADE_COMPARE(Float(a2), 0.0f);
     #endif
 
     /* Value constructor */
diff --git a/src/Magnum/Math/Test/BoolVectorTest.cpp b/src/Magnum/Math/Test/BoolVectorTest.cpp
index e835968d4..03933ff43 100644
--- a/src/Magnum/Math/Test/BoolVectorTest.cpp
+++ b/src/Magnum/Math/Test/BoolVectorTest.cpp
@@ -85,7 +85,9 @@ void BoolVectorTest::construct() {
 
 void BoolVectorTest::constructDefault() {
     constexpr BoolVector19 a;
+    constexpr BoolVector19 b{ZeroInit};
     CORRADE_COMPARE(a, BoolVector19(0x00, 0x00, 0x00));
+    CORRADE_COMPARE(b, BoolVector19(0x00, 0x00, 0x00));
 }
 
 void BoolVectorTest::constructOneValue() {
diff --git a/src/Magnum/Math/Test/ComplexTest.cpp b/src/Magnum/Math/Test/ComplexTest.cpp
index 7009a725b..995e7ecbe 100644
--- a/src/Magnum/Math/Test/ComplexTest.cpp
+++ b/src/Magnum/Math/Test/ComplexTest.cpp
@@ -58,7 +58,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
     explicit ComplexTest();
 
     void construct();
-    void constructDefault();
+    void constructIdentity();
     void constructFromVector();
     void constructCopy();
     void convert();
@@ -90,7 +90,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
 
 ComplexTest::ComplexTest() {
     addTests({&ComplexTest::construct,
-              &ComplexTest::constructDefault,
+              &ComplexTest::constructIdentity,
               &ComplexTest::constructFromVector,
               &ComplexTest::constructCopy,
               &ComplexTest::convert,
@@ -137,10 +137,13 @@ void ComplexTest::construct() {
     CORRADE_COMPARE(c, -3.7f);
 }
 
-void ComplexTest::constructDefault() {
+void ComplexTest::constructIdentity() {
     constexpr Complex a;
+    constexpr Complex b{IdentityInit};
     CORRADE_COMPARE(a, Complex(1.0f, 0.0f));
+    CORRADE_COMPARE(b, Complex(1.0f, 0.0f));
     CORRADE_COMPARE(a.length(), 1.0f);
+    CORRADE_COMPARE(b.length(), 1.0f);
 }
 
 void ComplexTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/DualComplexTest.cpp b/src/Magnum/Math/Test/DualComplexTest.cpp
index b2a9917e5..8ecb51464 100644
--- a/src/Magnum/Math/Test/DualComplexTest.cpp
+++ b/src/Magnum/Math/Test/DualComplexTest.cpp
@@ -58,7 +58,7 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
     explicit DualComplexTest();
 
     void construct();
-    void constructDefault();
+    void constructIdentity();
     void constructFromVector();
     void constructCopy();
     void convert();
@@ -96,7 +96,7 @@ typedef Math::Vector2<Float> Vector2;
 
 DualComplexTest::DualComplexTest() {
     addTests({&DualComplexTest::construct,
-              &DualComplexTest::constructDefault,
+              &DualComplexTest::constructIdentity,
               &DualComplexTest::constructFromVector,
               &DualComplexTest::constructCopy,
               &DualComplexTest::convert,
@@ -137,10 +137,13 @@ void DualComplexTest::construct() {
     CORRADE_COMPARE(d, DualComplex({-1.0f, 2.5f}, {0.0f, 0.0f}));
 }
 
-void DualComplexTest::constructDefault() {
+void DualComplexTest::constructIdentity() {
     constexpr DualComplex a;
+    constexpr DualComplex b{IdentityInit};
     CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
+    CORRADE_COMPARE(b, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
     CORRADE_COMPARE(a.length(), 1.0f);
+    CORRADE_COMPARE(b.length(), 1.0f);
 }
 
 void DualComplexTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/DualQuaternionTest.cpp b/src/Magnum/Math/Test/DualQuaternionTest.cpp
index 4f4c2892b..556a82e19 100644
--- a/src/Magnum/Math/Test/DualQuaternionTest.cpp
+++ b/src/Magnum/Math/Test/DualQuaternionTest.cpp
@@ -60,7 +60,7 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     explicit DualQuaternionTest();
 
     void construct();
-    void constructDefault();
+    void constructIdentity();
     void constructFromVector();
     void constructCopy();
     void convert();
@@ -97,7 +97,7 @@ typedef Math::Vector3<Float> Vector3;
 
 DualQuaternionTest::DualQuaternionTest() {
     addTests({&DualQuaternionTest::construct,
-              &DualQuaternionTest::constructDefault,
+              &DualQuaternionTest::constructIdentity,
               &DualQuaternionTest::constructFromVector,
               &DualQuaternionTest::constructCopy,
               &DualQuaternionTest::convert,
@@ -138,10 +138,13 @@ void DualQuaternionTest::construct() {
     CORRADE_COMPARE(d, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
 }
 
-void DualQuaternionTest::constructDefault() {
+void DualQuaternionTest::constructIdentity() {
     constexpr DualQuaternion a;
+    constexpr DualQuaternion b{IdentityInit};
     CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
+    CORRADE_COMPARE(b, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
     CORRADE_COMPARE(a.length(), 1.0f);
+    CORRADE_COMPARE(b.length(), 1.0f);
 }
 
 void DualQuaternionTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/Matrix3Test.cpp b/src/Magnum/Math/Test/Matrix3Test.cpp
index a6233b476..f12313f45 100644
--- a/src/Magnum/Math/Test/Matrix3Test.cpp
+++ b/src/Magnum/Math/Test/Matrix3Test.cpp
@@ -138,8 +138,8 @@ void Matrix3Test::construct() {
 
 void Matrix3Test::constructIdentity() {
     constexpr Matrix3 identity;
-    constexpr Matrix3 identity2(Matrix3::Identity);
-    constexpr Matrix3 identity3(Matrix3::Identity, 4.0f);
+    constexpr Matrix3 identity2{IdentityInit};
+    constexpr Matrix3 identity3{IdentityInit, 4.0f};
 
     Matrix3 identityExpected({1.0f, 0.0f, 0.0f},
                              {0.0f, 1.0f, 0.0f},
@@ -155,7 +155,7 @@ void Matrix3Test::constructIdentity() {
 }
 
 void Matrix3Test::constructZero() {
-    constexpr Matrix3 a(Matrix3::Zero);
+    constexpr Matrix3 a{ZeroInit};
     CORRADE_COMPARE(a, Matrix3({0.0f, 0.0f, 0.0f},
                                {0.0f, 0.0f, 0.0f},
                                {0.0f, 0.0f, 0.0f}));
diff --git a/src/Magnum/Math/Test/Matrix4Test.cpp b/src/Magnum/Math/Test/Matrix4Test.cpp
index 3d855e6d5..66a300d84 100644
--- a/src/Magnum/Math/Test/Matrix4Test.cpp
+++ b/src/Magnum/Math/Test/Matrix4Test.cpp
@@ -159,8 +159,8 @@ void Matrix4Test::construct() {
 
 void Matrix4Test::constructIdentity() {
     constexpr Matrix4 identity;
-    constexpr Matrix4 identity2(Matrix4::Identity);
-    constexpr Matrix4 identity3(Matrix4::Identity, 4.0f);
+    constexpr Matrix4 identity2{IdentityInit};
+    constexpr Matrix4 identity3{IdentityInit, 4.0f};
 
     Matrix4 identityExpected({1.0f, 0.0f, 0.0f, 0.0f},
                              {0.0f, 1.0f, 0.0f, 0.0f},
@@ -179,7 +179,7 @@ void Matrix4Test::constructIdentity() {
 
 void Matrix4Test::constructZero() {
     /* Zero constructor */
-    constexpr Matrix4 a(Matrix4::Zero);
+    constexpr Matrix4 a{ZeroInit};
     CORRADE_COMPARE(a, Matrix4({0.0f, 0.0f, 0.0f, 0.0f},
                                {0.0f, 0.0f, 0.0f, 0.0f},
                                {0.0f, 0.0f, 0.0f, 0.0f},
diff --git a/src/Magnum/Math/Test/MatrixTest.cpp b/src/Magnum/Math/Test/MatrixTest.cpp
index 5553b6d6f..1f2946e40 100644
--- a/src/Magnum/Math/Test/MatrixTest.cpp
+++ b/src/Magnum/Math/Test/MatrixTest.cpp
@@ -125,8 +125,8 @@ void MatrixTest::construct() {
 
 void MatrixTest::constructIdentity() {
     constexpr Matrix4x4 identity;
-    constexpr Matrix4x4 identity2(Matrix4x4::Identity);
-    constexpr Matrix4x4 identity3(Matrix4x4::Identity, 4.0f);
+    constexpr Matrix4x4 identity2{IdentityInit};
+    constexpr Matrix4x4 identity3{IdentityInit, 4.0f};
 
     Matrix4x4 identityExpected(Vector4(1.0f, 0.0f, 0.0f, 0.0f),
                                Vector4(0.0f, 1.0f, 0.0f, 0.0f),
@@ -144,7 +144,7 @@ void MatrixTest::constructIdentity() {
 }
 
 void MatrixTest::constructZero() {
-    constexpr Matrix4x4 a(Matrix4x4::Zero);
+    constexpr Matrix4x4 a{ZeroInit};
     CORRADE_COMPARE(a, Matrix4x4(Vector4(0.0f, 0.0f, 0.0f, 0.0f),
                                  Vector4(0.0f, 0.0f, 0.0f, 0.0f),
                                  Vector4(0.0f, 0.0f, 0.0f, 0.0f),
diff --git a/src/Magnum/Math/Test/QuaternionTest.cpp b/src/Magnum/Math/Test/QuaternionTest.cpp
index 45ac12d17..e25d4f02c 100644
--- a/src/Magnum/Math/Test/QuaternionTest.cpp
+++ b/src/Magnum/Math/Test/QuaternionTest.cpp
@@ -58,7 +58,7 @@ struct QuaternionTest: Corrade::TestSuite::Tester {
     explicit QuaternionTest();
 
     void construct();
-    void constructDefault();
+    void constructIdentity();
     void constructFromVector();
     void constructCopy();
     void convert();
@@ -101,7 +101,7 @@ typedef Math::Vector4<Float> Vector4;
 
 QuaternionTest::QuaternionTest() {
     addTests({&QuaternionTest::construct,
-              &QuaternionTest::constructDefault,
+              &QuaternionTest::constructIdentity,
               &QuaternionTest::constructFromVector,
               &QuaternionTest::constructCopy,
               &QuaternionTest::convert,
@@ -144,10 +144,13 @@ void QuaternionTest::construct() {
     CORRADE_COMPARE(c, -4.0f);
 }
 
-void QuaternionTest::constructDefault() {
+void QuaternionTest::constructIdentity() {
     constexpr Quaternion a;
+    constexpr Quaternion b{IdentityInit};
     CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f));
+    CORRADE_COMPARE(b, Quaternion({0.0f, 0.0f, 0.0f}, 1.0f));
     CORRADE_COMPARE(a.length(), 1.0f);
+    CORRADE_COMPARE(b.length(), 1.0f);
 }
 
 void QuaternionTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/RangeTest.cpp b/src/Magnum/Math/Test/RangeTest.cpp
index 537247799..b2863dfe5 100644
--- a/src/Magnum/Math/Test/RangeTest.cpp
+++ b/src/Magnum/Math/Test/RangeTest.cpp
@@ -173,13 +173,19 @@ void RangeTest::construct() {
 }
 
 void RangeTest::constructDefault() {
-    constexpr Range1Di a;
-    constexpr Range2Di b;
-    constexpr Range3Di c;
-
-    CORRADE_COMPARE(a, Range1Di(0, 0));
-    CORRADE_COMPARE(b, Range2Di({0, 0}, {0, 0}));
-    CORRADE_COMPARE(c, Range3Di({0, 0, 0}, {0, 0, 0}));
+    constexpr Range1Di a1;
+    constexpr Range2Di b1;
+    constexpr Range3Di c1;
+    constexpr Range1Di a2{ZeroInit};
+    constexpr Range2Di b2{ZeroInit};
+    constexpr Range3Di c2{ZeroInit};
+
+    CORRADE_COMPARE(a1, Range1Di(0, 0));
+    CORRADE_COMPARE(a2, Range1Di(0, 0));
+    CORRADE_COMPARE(b1, Range2Di({0, 0}, {0, 0}));
+    CORRADE_COMPARE(b2, Range2Di({0, 0}, {0, 0}));
+    CORRADE_COMPARE(c1, Range3Di({0, 0, 0}, {0, 0, 0}));
+    CORRADE_COMPARE(c2, Range3Di({0, 0, 0}, {0, 0, 0}));
 }
 
 void RangeTest::constructFromSize() {
diff --git a/src/Magnum/Math/Test/RectangularMatrixTest.cpp b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
index 75f84b404..faa0e141c 100644
--- a/src/Magnum/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
@@ -148,10 +148,15 @@ void RectangularMatrixTest::construct() {
 
 void RectangularMatrixTest::constructDefault() {
     constexpr Matrix4x3 a;
+    constexpr Matrix4x3 b{ZeroInit};
     CORRADE_COMPARE(a, Matrix4x3(Vector3(0.0f, 0.0f, 0.0f),
                                  Vector3(0.0f, 0.0f, 0.0f),
                                  Vector3(0.0f, 0.0f, 0.0f),
                                  Vector3(0.0f, 0.0f, 0.0f)));
+    CORRADE_COMPARE(b, Matrix4x3(Vector3(0.0f, 0.0f, 0.0f),
+                                 Vector3(0.0f, 0.0f, 0.0f),
+                                 Vector3(0.0f, 0.0f, 0.0f),
+                                 Vector3(0.0f, 0.0f, 0.0f)));
 }
 
 void RectangularMatrixTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/Vector2Test.cpp b/src/Magnum/Math/Test/Vector2Test.cpp
index 5fbf11cff..4ba013675 100644
--- a/src/Magnum/Math/Test/Vector2Test.cpp
+++ b/src/Magnum/Math/Test/Vector2Test.cpp
@@ -106,7 +106,9 @@ void Vector2Test::construct() {
 
 void Vector2Test::constructDefault() {
     constexpr Vector2 a;
+    constexpr Vector2 b{ZeroInit};
     CORRADE_COMPARE(a, Vector2(0.0f, 0.0f));
+    CORRADE_COMPARE(b, Vector2(0.0f, 0.0f));
 }
 
 void Vector2Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/Vector3Test.cpp b/src/Magnum/Math/Test/Vector3Test.cpp
index f3af3b62a..37fd2c972 100644
--- a/src/Magnum/Math/Test/Vector3Test.cpp
+++ b/src/Magnum/Math/Test/Vector3Test.cpp
@@ -104,7 +104,9 @@ void Vector3Test::construct() {
 
 void Vector3Test::constructDefault() {
     constexpr Vector3 a;
+    constexpr Vector3 b{ZeroInit};
     CORRADE_COMPARE(a, Vector3(0.0f, 0.0f, 0.0f));
+    CORRADE_COMPARE(b, Vector3(0.0f, 0.0f, 0.0f));
 }
 
 void Vector3Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/Vector4Test.cpp b/src/Magnum/Math/Test/Vector4Test.cpp
index 1f56703f8..ecee35c5a 100644
--- a/src/Magnum/Math/Test/Vector4Test.cpp
+++ b/src/Magnum/Math/Test/Vector4Test.cpp
@@ -113,7 +113,9 @@ void Vector4Test::constructPad() {
 
 void Vector4Test::constructDefault() {
     constexpr Vector4 a;
+    constexpr Vector4 b{ZeroInit};
     CORRADE_COMPARE(a, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+    CORRADE_COMPARE(b, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 void Vector4Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/VectorTest.cpp b/src/Magnum/Math/Test/VectorTest.cpp
index bdd1cf5f6..1f6266dae 100644
--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@@ -187,7 +187,9 @@ void VectorTest::constructPad() {
 
 void VectorTest::constructDefault() {
     constexpr Vector4 a;
+    constexpr Vector4 b{ZeroInit};
     CORRADE_COMPARE(a, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+    CORRADE_COMPARE(b, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 void VectorTest::constructOneValue() {
diff --git a/src/Magnum/Math/Unit.h b/src/Magnum/Math/Unit.h
index fbfe3a43b..5e679eade 100644
--- a/src/Magnum/Math/Unit.h
+++ b/src/Magnum/Math/Unit.h
@@ -30,6 +30,7 @@
  */
 
 #include "Magnum/Math/TypeTraits.h"
+#include "Magnum/Math/Tags.h"
 
 namespace Magnum { namespace Math {
 
@@ -45,8 +46,8 @@ template<template<class> class Derived, class T> class Unit {
     public:
         typedef T Type;             /**< @brief Underlying data type */
 
-        /** @brief Default constructor */
-        constexpr /*implicit*/ Unit(): _value(T(0)) {}
+        /** @brief Construct zero value */
+        constexpr /*implicit*/ Unit(ZeroInitT = ZeroInit): _value(T(0)) {}
 
         /** @brief Explicit conversion from unitless type */
         constexpr explicit Unit(T value): _value(value) {}
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 2a4c9f695..18e75e256 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -146,7 +146,7 @@ template<std::size_t size, class T> class Vector {
          *      \boldsymbol v = \boldsymbol 0
          * @f]
          */
-        constexpr /*implicit*/ Vector(): _data() {}
+        constexpr /*implicit*/ Vector(ZeroInitT = ZeroInit): _data{} {}
 
         /** @todo Creating Vector from combination of vector and scalar types */
 
diff --git a/src/Magnum/Math/Vector2.h b/src/Magnum/Math/Vector2.h
index d73ccf29e..04c1c4673 100644
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@@ -111,8 +111,8 @@ template<class T> class Vector2: public Vector<2, T> {
         }
         #endif
 
-        /** @copydoc Vector::Vector() */
-        constexpr /*implicit*/ Vector2() {}
+        /** @copydoc Vector::Vector(ZeroInitT) */
+        constexpr /*implicit*/ Vector2(ZeroInitT = ZeroInit): Vector<2, T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(T) */
         constexpr explicit Vector2(T value): Vector<2, T>(value) {}
diff --git a/src/Magnum/Math/Vector3.h b/src/Magnum/Math/Vector3.h
index 93277ac0d..2200498bb 100644
--- a/src/Magnum/Math/Vector3.h
+++ b/src/Magnum/Math/Vector3.h
@@ -133,8 +133,8 @@ template<class T> class Vector3: public Vector<3, T> {
         }
         #endif
 
-        /** @copydoc Vector::Vector() */
-        constexpr /*implicit*/ Vector3() {}
+        /** @copydoc Vector::Vector(ZeroInitT) */
+        constexpr /*implicit*/ Vector3(ZeroInitT = ZeroInit): Vector<3, T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(T) */
         constexpr explicit Vector3(T value): Vector<3, T>(value) {}
diff --git a/src/Magnum/Math/Vector4.h b/src/Magnum/Math/Vector4.h
index cb958154b..1db87832a 100644
--- a/src/Magnum/Math/Vector4.h
+++ b/src/Magnum/Math/Vector4.h
@@ -59,8 +59,8 @@ template<class T> class Vector4: public Vector<4, T> {
                     3 < otherSize ? a[3] : w};
         }
 
-        /** @copydoc Vector::Vector() */
-        constexpr /*implicit*/ Vector4() {}
+        /** @copydoc Vector::Vector(ZeroInitT) */
+        constexpr /*implicit*/ Vector4(ZeroInitT = ZeroInit): Vector<4, T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(T) */
         constexpr explicit Vector4(T value): Vector<4, T>(value) {}
diff --git a/src/Magnum/SceneGraph/Test/ObjectTest.cpp b/src/Magnum/SceneGraph/Test/ObjectTest.cpp
index ef8935fca..d084482e9 100644
--- a/src/Magnum/SceneGraph/Test/ObjectTest.cpp
+++ b/src/Magnum/SceneGraph/Test/ObjectTest.cpp
@@ -371,16 +371,16 @@ void ObjectTest::setClean() {
     CORRADE_VERIFY(childThree->isDirty());
 
     /* If the object itself is already clean, it shouldn't clean it again */
-    childOne->cleanedAbsoluteTransformation = Matrix4(Matrix4::Zero);
+    childOne->cleanedAbsoluteTransformation = Matrix4{Math::ZeroInit};
     CORRADE_VERIFY(!childOne->isDirty());
     childOne->setClean();
-    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4{Math::ZeroInit});
 
     /* If any object in the hierarchy is already clean, it shouldn't clean it again */
     CORRADE_VERIFY(!childOne->isDirty());
     CORRADE_VERIFY(childTwo->isDirty());
     childTwo->setClean();
-    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4{Math::ZeroInit});
 
     /* Remove object from tree => make it and its children dirty */
     childThree->setClean();
@@ -441,16 +441,16 @@ void ObjectTest::setCleanListHierarchy() {
     CORRADE_COMPARE(childTwoFeature->cleanedAbsoluteTransformation, childTwo->absoluteTransformationMatrix());
 
     /* If the object itself is already clean, it shouldn't clean it again */
-    childOne->cleanedAbsoluteTransformation = Matrix4(Matrix4::Zero);
+    childOne->cleanedAbsoluteTransformation = Matrix4{Math::ZeroInit};
     CORRADE_VERIFY(!childOne->isDirty());
     Scene3D::setClean({*childOne});
-    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4{Math::ZeroInit});
 
     /* If any object in the hierarchy is already clean, it shouldn't clean it again */
     CORRADE_VERIFY(!childOne->isDirty());
     childTwo->setDirty();
     Scene3D::setClean({*childTwo});
-    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4(Matrix4::Zero));
+    CORRADE_COMPARE(childOne->cleanedAbsoluteTransformation, Matrix4{Math::ZeroInit});
 }
 
 void ObjectTest::setCleanListBulk() {
diff --git a/src/Magnum/Shapes/Box.h b/src/Magnum/Shapes/Box.h
index d4e004bda..6cf57169c 100644
--- a/src/Magnum/Shapes/Box.h
+++ b/src/Magnum/Shapes/Box.h
@@ -56,7 +56,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHAPES_EXPORT Box {
          *
          * Creates zero-sized box positioned at origin.
          */
-        constexpr /*implicit*/ Box(): _transformation(MatrixTypeFor<dimensions, Float>::Zero) {}
+        constexpr /*implicit*/ Box(): _transformation{Math::ZeroInit} {}
 
         /** @brief Constructor */
         constexpr /*implicit*/ Box(const MatrixTypeFor<dimensions, Float>& transformation): _transformation(transformation) {}
diff --git a/src/Magnum/Test/ColorTest.cpp b/src/Magnum/Test/ColorTest.cpp
index 9a1bf9347..c9e30f681 100644
--- a/src/Magnum/Test/ColorTest.cpp
+++ b/src/Magnum/Test/ColorTest.cpp
@@ -104,8 +104,10 @@ void ColorTest::construct() {
 }
 
 void ColorTest::constructDefault() {
-    constexpr Vector3 a;
-    CORRADE_COMPARE(a, Color3(0.0f, 0.0f, 0.0f));
+    constexpr Color3 a1;
+    constexpr Color3 a2{Math::ZeroInit};
+    CORRADE_COMPARE(a1, Color3(0.0f, 0.0f, 0.0f));
+    CORRADE_COMPARE(a2, Color3(0.0f, 0.0f, 0.0f));
 
     constexpr Color4 b;
     constexpr Color4ub c;