Moved swizzle() functions to root namespace.

They aren't much useful in Math namespace and here it allows to handle
also Color3/Color4 types. Moreover all RGBA component names were removed
from Math namespace, so it would be inconsistent to have them there only
in swizzle() functions.

src/CMakeLists.txt

@@ -56,6 +56,7 @@ set(Magnum_HEADERS
     Scene.h
     Shader.h
     SizeTraits.h
+    Swizzle.h
     Texture.h
     TypeTraits.h
 

src/Math/CMakeLists.txt

@@ -6,7 +6,6 @@ set(MagnumMath_HEADERS
     Matrix.h
     Matrix3.h
     Matrix4.h
-    Swizzle.h
     Vector.h
     Vector2.h
     Vector3.h

src/Math/Test/CMakeLists.txt

@@ -6,8 +6,6 @@ corrade_add_test2(MathVector2Test Vector2Test.cpp)
 corrade_add_test2(MathVector3Test Vector3Test.cpp)
 corrade_add_test2(MathVector4Test Vector4Test.cpp)
 
-corrade_add_test2(MathSwizzleTest SwizzleTest.cpp)
-
 corrade_add_test2(MathMatrixTest MatrixTest.cpp)
 corrade_add_test2(MathMatrix3Test Matrix3Test.cpp)
 corrade_add_test2(MathMatrix4Test Matrix4Test.cpp)

src/Swizzle.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Math_Swizzle_h
-#define Magnum_Math_Swizzle_h
+#ifndef Magnum_Swizzle_h
+#define Magnum_Swizzle_h
 /*
     Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
 
@@ -19,12 +19,15 @@
  * @brief Function Magnum::Math::swizzle()
  */
 
-#include "Vector4.h"
+#include "Color.h"
 
-namespace Magnum { namespace Math {
+namespace Magnum {
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 namespace Implementation {
+    using Math::Implementation::Sequence;
+    using Math::Implementation::GenerateSequence;
+
     template<size_t size, size_t position> struct GetPosition {
         static_assert(size > position, "Swizzle parameter out of range of base vector");
 
@@ -42,12 +45,15 @@ namespace Implementation {
     template<size_t size> struct GetComponent<size, 'a'>: public GetPosition<size, 3> {};
 
     template<size_t size, class T> struct TypeForSize {
-        typedef Vector<size, T> Type;
+        typedef Math::Vector<size, typename T::Type> Type;
     };
-
-    template<class T> struct TypeForSize<2, T> { typedef Vector2<T> Type; };
-    template<class T> struct TypeForSize<3, T> { typedef Vector3<T> Type; };
-    template<class T> struct TypeForSize<4, T> { typedef Vector4<T> Type; };
+    template<class T> struct TypeForSize<2, T> { typedef Math::Vector2<typename T::Type> Type; };
+    template<class T> struct TypeForSize<3, T> { typedef Math::Vector3<typename T::Type> Type; };
+    template<class T> struct TypeForSize<4, T> { typedef Math::Vector4<typename T::Type> Type; };
+    template<class T> struct TypeForSize<3, Color3<T>> { typedef Color3<T> Type; };
+    template<class T> struct TypeForSize<3, Color4<T>> { typedef Color3<T> Type; };
+    template<class T> struct TypeForSize<4, Color3<T>> { typedef Color4<T> Type; };
+    template<class T> struct TypeForSize<4, Color4<T>> { typedef Color4<T> Type; };
 
     inline constexpr size_t getPosition(size_t size, size_t position) {
         return size > position ? position : throw;
@@ -65,7 +71,7 @@ namespace Implementation {
                throw;
     }
 
-    template<size_t size, class T, size_t ...sequence> inline constexpr Vector<sizeof...(sequence), T> swizzleFrom(Sequence<sequence...>, const Vector<size, T>& vector, const char(&components)[sizeof...(sequence)+1]) {
+    template<size_t size, class T, size_t ...sequence> inline constexpr Math::Vector<sizeof...(sequence), T> swizzleFrom(Sequence<sequence...>, const Math::Vector<size, T>& vector, const char(&components)[sizeof...(sequence)+1]) {
         return {vector[getComponent<size>(components[sequence])]...};
     }
 }
@@ -93,8 +99,8 @@ instead of at runtime.
 
 @see Vector4::xyz(), Vector4::rgb(), Vector4::xy(), Vector3::xy()
 */
-template<char ...components, size_t size, class T> inline constexpr typename Implementation::TypeForSize<sizeof...(components), T>::Type swizzle(const Vector<size, T>& vector) {
-    return {vector[Implementation::GetComponent<size, components>::value()]...};
+template<char ...components, class T> inline constexpr typename Implementation::TypeForSize<sizeof...(components), T>::Type swizzle(const T& vector) {
+    return {vector[Implementation::GetComponent<T::Size, components>::value()]...};
 }
 
 /**
@@ -119,10 +125,10 @@ evaluated at compile time, but at runtime.
 
 @see Vector4::xyz(), Vector4::rgb(), Vector4::xy(), Vector3::xy()
 */
-template<size_t size, class T, size_t newSize> inline constexpr typename Implementation::TypeForSize<newSize-1, T>::Type swizzle(const Vector<size, T>& vector, const char(&components)[newSize]) {
+template<class T, size_t newSize> inline constexpr typename Implementation::TypeForSize<newSize-1, T>::Type swizzle(const T& vector, const char(&components)[newSize]) {
     return Implementation::swizzleFrom(typename Implementation::GenerateSequence<newSize-1>::Type(), vector, components);
 }
 
-}}
+}
 
 #endif

src/Test/CMakeLists.txt

@@ -3,3 +3,4 @@ corrade_add_test2(CameraTest CameraTest.cpp LIBRARIES Magnum)
 corrade_add_test2(SceneTest SceneTest.cpp LIBRARIES Magnum)
 
 corrade_add_test2(ColorTest ColorTest.cpp)
+corrade_add_test2(SwizzleTest SwizzleTest.cpp)

src/Test/SwizzleTest.cpp

@@ -19,9 +19,9 @@
 
 using namespace std;
 
-CORRADE_TEST_MAIN(Magnum::Math::Test::SwizzleTest)
+CORRADE_TEST_MAIN(Magnum::Test::SwizzleTest)
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Test {
 
 typedef Math::Vector2<int> Vector2;
 typedef Math::Vector3<int> Vector3;
@@ -66,6 +66,17 @@ void SwizzleTest::type() {
     CORRADE_VERIFY((is_same<decltype(swizzle(orig, "yza")), Vector3>::value));
     CORRADE_VERIFY((is_same<decltype(swizzle<'y', 'a', 'y', 'x'>(orig)), Vector4>::value));
     CORRADE_VERIFY((is_same<decltype(swizzle(orig, "yayx")), Vector4>::value));
+
+    Color3<float> origColor3;
+    Color4<double> origColor4;
+    CORRADE_VERIFY((is_same<decltype(swizzle<'y', 'z', 'r'>(origColor3)), Color3<float>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle<'y', 'z', 'a'>(origColor4)), Color3<double>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle(origColor3, "yzr")), Color3<float>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle(origColor4, "yza")), Color3<double>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle<'y', 'z', 'y', 'x'>(origColor3)), Color4<float>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle<'y', 'a', 'y', 'x'>(origColor4)), Color4<double>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle(origColor3, "yzyx")), Color4<float>>::value));
+    CORRADE_VERIFY((is_same<decltype(swizzle(origColor4, "yayx")), Color4<double>>::value));
 }
 
 void SwizzleTest::defaultType() {
@@ -76,4 +87,4 @@ void SwizzleTest::defaultType() {
     CORRADE_COMPARE(swizzle(orig, "bragzyx"), Vector<7>(3, 1, 4, 2, 3, 2, 1));
 }
 
-}}}
+}}

src/Test/SwizzleTest.h

@@ -1,5 +1,5 @@
-#ifndef Magnum_Math_Test_SwizzleTest_h
-#define Magnum_Math_Test_SwizzleTest_h
+#ifndef Magnum_Test_SwizzleTest_h
+#define Magnum_Test_SwizzleTest_h
 /*
     Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
 
@@ -17,7 +17,7 @@
 
 #include <TestSuite/Tester.h>
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Test {
 
 class SwizzleTest: public Corrade::TestSuite::Tester<SwizzleTest> {
     public:
@@ -30,6 +30,6 @@ class SwizzleTest: public Corrade::TestSuite::Tester<SwizzleTest> {
         void defaultType();
 };
 
-}}}
+}}
 
 #endif