Browse Source

Math: ability to zero-initialize all classes.

Previously only matrices allowed to be created either as an identity or
zero-initialized. Now all Math classes support that, including (dual)
complex numbers and quaternions.
pull/107/head
Vladimír Vondruš 11 years ago
parent
commit
702c9db6b4
  1. 3
      src/Magnum/Color.h
  2. 3
      src/Magnum/Math/Complex.h
  3. 3
      src/Magnum/Math/DualComplex.h
  4. 3
      src/Magnum/Math/DualQuaternion.h
  5. 3
      src/Magnum/Math/Quaternion.h
  6. 7
      src/Magnum/Math/Test/ComplexTest.cpp
  7. 7
      src/Magnum/Math/Test/DualComplexTest.cpp
  8. 7
      src/Magnum/Math/Test/DualQuaternionTest.cpp
  9. 7
      src/Magnum/Math/Test/QuaternionTest.cpp
  10. 9
      src/Magnum/Test/ColorTest.cpp

3
src/Magnum/Color.h

@ -442,6 +442,9 @@ class BasicColor4: public Math::Vector4<T> {
*/
constexpr /*implicit*/ BasicColor4(): Math::Vector4<T>(T(0), T(0), T(0), Implementation::fullChannel<T>()) {}
/** @copydoc Vector4::Vector4(ZeroInitT) */
constexpr explicit BasicColor4(Math::ZeroInitT): Math::Vector4<T>{Math::ZeroInit} {}
/**
* @copydoc BasicColor3::BasicColor3(T)
* @param alpha Alpha value, defaults to `1.0` for floating-point types

3
src/Magnum/Math/Complex.h

@ -142,6 +142,9 @@ template<class T> class Complex {
*/
constexpr /*implicit*/ Complex(IdentityInitT = IdentityInit): _real(T(1)), _imaginary(T(0)) {}
/** @brief Construct zero-initialized complex number */
constexpr explicit Complex(ZeroInitT): _real{}, _imaginary{} {}
/**
* @brief Construct complex number from real and imaginary part
*

3
src/Magnum/Math/DualComplex.h

@ -109,6 +109,9 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
constexpr /*implicit*/ DualComplex(IdentityInitT = IdentityInit): Dual<Complex<T>>({}, {T(0), T(0)}) {}
#endif
/** @brief Construct zero-initialized dual complex number */
constexpr explicit DualComplex(ZeroInitT): Dual<Complex<T>>{Complex<T>{ZeroInit}, Complex<T>{ZeroInit}} {}
/**
* @brief Construct dual complex number from real and dual part
*

3
src/Magnum/Math/DualQuaternion.h

@ -115,6 +115,9 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
constexpr /*implicit*/ DualQuaternion(IdentityInitT = IdentityInit): Dual<Quaternion<T>>({}, {{}, T(0)}) {}
#endif
/** @brief Construct zero-initialized dual quaternion */
constexpr explicit DualQuaternion(ZeroInitT): Dual<Quaternion<T>>{Quaternion<T>{ZeroInit}, Quaternion<T>{ZeroInit}} {}
/**
* @brief Construct dual quaternion from real and dual part
*

3
src/Magnum/Math/Quaternion.h

@ -199,6 +199,9 @@ template<class T> class Quaternion {
*/
constexpr /*implicit*/ Quaternion(IdentityInitT = IdentityInit): _vector{T(0)}, _scalar{T(1)} {}
/** @brief Construct zero-initialized quaternion */
constexpr explicit Quaternion(ZeroInitT): _vector{ZeroInit}, _scalar{T{0}} {}
/**
* @brief Construct quaternion from vector and scalar
*

7
src/Magnum/Math/Test/ComplexTest.cpp

@ -59,6 +59,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
void construct();
void constructIdentity();
void constructZero();
void constructFromVector();
void constructCopy();
void convert();
@ -91,6 +92,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
ComplexTest::ComplexTest() {
addTests({&ComplexTest::construct,
&ComplexTest::constructIdentity,
&ComplexTest::constructZero,
&ComplexTest::constructFromVector,
&ComplexTest::constructCopy,
&ComplexTest::convert,
@ -146,6 +148,11 @@ void ComplexTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
}
void ComplexTest::constructZero() {
constexpr Complex a{ZeroInit};
CORRADE_COMPARE(a, Complex(0.0f, 0.0f));
}
void ComplexTest::constructFromVector() {
constexpr Vector2 vec(1.5f, -3.0f);

7
src/Magnum/Math/Test/DualComplexTest.cpp

@ -59,6 +59,7 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
void construct();
void constructIdentity();
void constructZero();
void constructFromVector();
void constructCopy();
void convert();
@ -97,6 +98,7 @@ typedef Math::Vector2<Float> Vector2;
DualComplexTest::DualComplexTest() {
addTests({&DualComplexTest::construct,
&DualComplexTest::constructIdentity,
&DualComplexTest::constructZero,
&DualComplexTest::constructFromVector,
&DualComplexTest::constructCopy,
&DualComplexTest::convert,
@ -146,6 +148,11 @@ void DualComplexTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
}
void DualComplexTest::constructZero() {
constexpr DualComplex a{ZeroInit};
CORRADE_COMPARE(a, DualComplex({0.0f, 0.0f}, {0.0f, 0.0f}));
}
void DualComplexTest::constructFromVector() {
constexpr DualComplex a(Vector2(1.5f, -3.0f));
CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {1.5f, -3.0f}));

7
src/Magnum/Math/Test/DualQuaternionTest.cpp

@ -61,6 +61,7 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
void construct();
void constructIdentity();
void constructZero();
void constructFromVector();
void constructCopy();
void convert();
@ -98,6 +99,7 @@ typedef Math::Vector3<Float> Vector3;
DualQuaternionTest::DualQuaternionTest() {
addTests({&DualQuaternionTest::construct,
&DualQuaternionTest::constructIdentity,
&DualQuaternionTest::constructZero,
&DualQuaternionTest::constructFromVector,
&DualQuaternionTest::constructCopy,
&DualQuaternionTest::convert,
@ -147,6 +149,11 @@ void DualQuaternionTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
}
void DualQuaternionTest::constructZero() {
constexpr DualQuaternion a{ZeroInit};
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 0.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
}
void DualQuaternionTest::constructFromVector() {
constexpr DualQuaternion a(Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(a, DualQuaternion({{0.0f, 0.0f, 0.0f}, 1.0f}, {{1.0f, 2.0f, 3.0f}, 0.0f}));

7
src/Magnum/Math/Test/QuaternionTest.cpp

@ -59,6 +59,7 @@ struct QuaternionTest: Corrade::TestSuite::Tester {
void construct();
void constructIdentity();
void constructZero();
void constructFromVector();
void constructCopy();
void convert();
@ -102,6 +103,7 @@ typedef Math::Vector4<Float> Vector4;
QuaternionTest::QuaternionTest() {
addTests({&QuaternionTest::construct,
&QuaternionTest::constructIdentity,
&QuaternionTest::constructZero,
&QuaternionTest::constructFromVector,
&QuaternionTest::constructCopy,
&QuaternionTest::convert,
@ -153,6 +155,11 @@ void QuaternionTest::constructIdentity() {
CORRADE_COMPARE(b.length(), 1.0f);
}
void QuaternionTest::constructZero() {
constexpr Quaternion a{ZeroInit};
CORRADE_COMPARE(a, Quaternion({0.0f, 0.0f, 0.0f}, 0.0f));
}
void QuaternionTest::constructFromVector() {
constexpr Quaternion a(Vector3(1.0f, 2.0f, 3.0f));
CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, 0.0f));

9
src/Magnum/Test/ColorTest.cpp

@ -36,6 +36,7 @@ struct ColorTest: TestSuite::Tester {
void construct();
void constructDefault();
void constructZero();
void constructOneValue();
void constructParts();
void constructConversion();
@ -64,6 +65,7 @@ struct ColorTest: TestSuite::Tester {
ColorTest::ColorTest() {
addTests({&ColorTest::construct,
&ColorTest::constructDefault,
&ColorTest::constructZero,
&ColorTest::constructOneValue,
&ColorTest::constructParts,
&ColorTest::constructConversion,
@ -115,6 +117,13 @@ void ColorTest::constructDefault() {
CORRADE_COMPARE(c, Color4ub(0, 0, 0, 255));
}
void ColorTest::constructZero() {
constexpr Color3 a{Math::ZeroInit};
constexpr Color4 b{Math::ZeroInit};
CORRADE_COMPARE(a, Color3(0.0f, 0.0f, 0.0f));
CORRADE_COMPARE(b, Color4(0.0f, 0.0f, 0.0f, 0.0f));
}
void ColorTest::constructOneValue() {
constexpr Color3 a(0.25f);
CORRADE_COMPARE(a, Color3(0.25f, 0.25f, 0.25f));

Loading…
Cancel
Save