Merge branch 'master' into cnn

src/AbstractFramebuffer.h

@@ -52,10 +52,10 @@ switching framebuffers.
 class MAGNUM_EXPORT AbstractFramebuffer {
     friend class Context;
 
-    AbstractFramebuffer(const AbstractFramebuffer& other) = delete;
-    AbstractFramebuffer(AbstractFramebuffer&& other) = delete;
-    AbstractFramebuffer& operator=(const AbstractFramebuffer& other) = delete;
-    AbstractFramebuffer& operator=(AbstractFramebuffer&& other) = delete;
+    AbstractFramebuffer(const AbstractFramebuffer&) = delete;
+    AbstractFramebuffer(AbstractFramebuffer&&) = delete;
+    AbstractFramebuffer& operator=(const AbstractFramebuffer&) = delete;
+    AbstractFramebuffer& operator=(AbstractFramebuffer&&) = delete;
 
     public:
         /**

src/AbstractImage.h

@@ -47,10 +47,10 @@ functions operating with images). It also possibly needs to be "stackable" to
 easily revert the state back.
 */
 class MAGNUM_EXPORT AbstractImage {
-    AbstractImage(const AbstractImage& other) = delete;
-    AbstractImage(AbstractImage&& other) = delete;
-    AbstractImage& operator=(const AbstractImage& other) = delete;
-    AbstractImage& operator=(AbstractImage&& other) = delete;
+    AbstractImage(const AbstractImage&) = delete;
+    AbstractImage(AbstractImage&&) = delete;
+    AbstractImage& operator=(const AbstractImage&) = delete;
+    AbstractImage& operator=(AbstractImage&&) = delete;
 
     public:
         /**

src/AbstractShaderProgram.h

@@ -285,10 +285,10 @@ comes in handy.
 class MAGNUM_EXPORT AbstractShaderProgram {
     friend class Context;
 
-    AbstractShaderProgram(const AbstractShaderProgram& other) = delete;
-    AbstractShaderProgram(AbstractShaderProgram&& other) = delete;
-    AbstractShaderProgram& operator=(const AbstractShaderProgram& other) = delete;
-    AbstractShaderProgram& operator=(AbstractShaderProgram&& other) = delete;
+    AbstractShaderProgram(const AbstractShaderProgram&) = delete;
+    AbstractShaderProgram(AbstractShaderProgram&&) = delete;
+    AbstractShaderProgram& operator=(const AbstractShaderProgram&) = delete;
+    AbstractShaderProgram& operator=(AbstractShaderProgram&&) = delete;
 
     public:
         /**

src/AbstractTexture.h

@@ -82,8 +82,8 @@ do nothing.
 class MAGNUM_EXPORT AbstractTexture {
     friend class Context;
 
-    AbstractTexture(const AbstractTexture& other) = delete;
-    AbstractTexture& operator=(const AbstractTexture& other) = delete;
+    AbstractTexture(const AbstractTexture&) = delete;
+    AbstractTexture& operator=(const AbstractTexture&) = delete;
 
     public:
         /**

src/Buffer.h

@@ -123,10 +123,10 @@ nothing.
 class MAGNUM_EXPORT Buffer {
     friend class Context;
 
-    Buffer(const Buffer& other) = delete;
-    Buffer(Buffer&& other) = delete;
-    Buffer& operator=(const Buffer& other) = delete;
-    Buffer& operator=(Buffer&& other) = delete;
+    Buffer(const Buffer&) = delete;
+    Buffer(Buffer&&) = delete;
+    Buffer& operator=(const Buffer&) = delete;
+    Buffer& operator=(Buffer&&) = delete;
 
     public:
         /**

src/BufferTexture.h

@@ -82,10 +82,10 @@ documentation for more information.
 class MAGNUM_EXPORT BufferTexture: private AbstractTexture {
     friend class Context;
 
-    BufferTexture(const BufferTexture& other) = delete;
-    BufferTexture(BufferTexture&& other) = delete;
-    BufferTexture& operator=(const BufferTexture& other) = delete;
-    BufferTexture& operator=(BufferTexture&& other) = delete;
+    BufferTexture(const BufferTexture&) = delete;
+    BufferTexture(BufferTexture&&) = delete;
+    BufferTexture& operator=(const BufferTexture&) = delete;
+    BufferTexture& operator=(BufferTexture&&) = delete;
 
     public:
         /**

src/DebugTools/ForceRenderer.cpp

@@ -40,14 +40,23 @@ template<UnsignedInt dimensions> ResourceKey shaderKey();
 template<> inline ResourceKey shaderKey<2>() { return ResourceKey("FlatShader2D"); }
 template<> inline ResourceKey shaderKey<3>() { return ResourceKey("FlatShader3D"); }
 
+/** @bug Why this is not constexpr under GCC 4.6? */
+#ifndef CORRADE_GCC46_COMPATIBILITY
 constexpr std::array<Vector2, 4> positions{{
+#else
+const std::array<Vector2, 4> positions{{
+#endif
     {0.0f,  0.0f},
     {1.0f,  0.0f},
     {0.9f,  0.1f},
     {0.9f, -0.1f}
 }};
 
+#ifndef CORRADE_GCC46_COMPATIBILITY
 constexpr std::array<UnsignedByte, 6> indices{{
+#else
+const std::array<UnsignedByte, 6> indices{{
+#endif
     0, 1,
     1, 2,
     1, 3

src/DebugTools/Profiler.h

@@ -64,7 +64,7 @@ p.enable();
 void MyApplication::drawEvent() {
     p.start();
 
-    // ... misc stuff belogning to "Other" section
+    // ... misc stuff belonging to "Other" section
 
     p.start(sections.ai);
 

src/Math/RectangularMatrix.h

@@ -106,7 +106,12 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
          *
          * @todo Creating matrix from arbitrary combination of matrices with n rows
          */
+        #ifndef CORRADE_GCC46_COMPATIBILITY
         template<class ...U> inline constexpr /*implicit*/ RectangularMatrix(const Vector<rows, T>& first, const U&... next): _data{first, next...} {
+        #else
+        template<class ...U> inline /*implicit*/ RectangularMatrix(const Vector<rows, T>& first, const U&... next): _data() {
+            constructInternal({first, next...});
+        #endif
             static_assert(sizeof...(next)+1 == cols, "Improper number of arguments passed to RectangularMatrix constructor");
         }
 
@@ -443,7 +448,21 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
 
     private:
         /* Implementation for RectangularMatrix<cols, rows, T>::RectangularMatrix(const RectangularMatrix<cols, rows, U>&) */
+        #ifndef CORRADE_GCC46_COMPATIBILITY
         template<class U, std::size_t ...sequence> inline constexpr explicit RectangularMatrix(Implementation::Sequence<sequence...>, const RectangularMatrix<cols, rows, U>& matrix): _data{Vector<rows, T>(matrix[sequence])...} {}
+        #else
+        template<class U, std::size_t ...sequence> inline constexpr explicit RectangularMatrix(Implementation::Sequence<sequence...>, const RectangularMatrix<cols, rows, U>& matrix): _data() {
+            constructInternal({Vector<rows, T>(matrix[sequence])...});
+        }
+        #endif
+
+        #ifdef CORRADE_GCC46_COMPATIBILITY
+        /* GCC < 4.7 workaround for a ton of warnings / "error: bad array initializer" */
+        inline void constructInternal(std::initializer_list<Vector<rows, T>> data) {
+            for(std::size_t i = 0; i != data.size(); ++i)
+                _data[i] = *(data.begin() + i);
+        }
+        #endif
 
         Vector<rows, T> _data[cols];
 };

src/Math/Test/SwizzleTest.cpp

@@ -35,7 +35,6 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
         void components();
         void constants();
         void sizes();
-        void constExpressions();
 };
 
 typedef Vector<4, Int> Vector4i;
@@ -43,33 +42,28 @@ typedef Vector<4, Int> Vector4i;
 SwizzleTest::SwizzleTest() {
     addTests({&SwizzleTest::components,
               &SwizzleTest::constants,
-              &SwizzleTest::sizes,
-              &SwizzleTest::constExpressions});
+              &SwizzleTest::sizes});
 }
 
 void SwizzleTest::components() {
-    CORRADE_COMPARE((swizzle<'z', 'x', 'w', 'y'>(Vector4i(2, 4, 5, 7))), Vector4i(5, 2, 7, 4));
+    constexpr auto a = swizzle<'z', 'x', 'w', 'y'>(Vector4i(2, 4, 5, 7));
+    CORRADE_COMPARE(a, Vector4i(5, 2, 7, 4));
 }
 
 void SwizzleTest::constants() {
-    CORRADE_COMPARE((swizzle<'1', 'w', '0', 'y'>(Vector4i(2, 4, 5, 7))), Vector4i(1, 7, 0, 4));
+    constexpr auto a = swizzle<'1', 'w', '0', 'y'>(Vector4i(2, 4, 5, 7));
+    CORRADE_COMPARE(a, Vector4i(1, 7, 0, 4));
 }
 
 void SwizzleTest::sizes() {
-    CORRADE_COMPARE((swizzle<'y', 'x', 'x'>(Math::Vector<2, Int>(1, 2))),
-        (Math::Vector<3, Int>(2, 1, 1)));
-    CORRADE_COMPARE(swizzle<'z'>(Vector4i(1, 2, 3, 4)),
-        (Math::Vector<1, Int>(3)));
-    CORRADE_COMPARE((swizzle<'z', 'x', 'w', 'y', 'z', 'y', 'x'>(Vector4i(1, 2, 3, 4))),
-        (Math::Vector<7, Int>(3, 1, 4, 2, 3, 2, 1)));
-}
+    constexpr auto a = swizzle<'y', 'x', 'x'>(Math::Vector<2, Int>(1, 2));
+    CORRADE_COMPARE(a, (Math::Vector<3, Int>(2, 1, 1)));
 
-void SwizzleTest::constExpressions() {
-    constexpr auto a = swizzle<'z', 'x', 'w', 'y'>(Vector4i(2, 4, 5, 7));
-    CORRADE_COMPARE(a, Vector4i(5, 2, 7, 4));
+    constexpr auto b = swizzle<'z'>(Vector4i(1, 2, 3, 4));
+    CORRADE_COMPARE(b, (Math::Vector<1, Int>(3)));
 
-    constexpr auto b = swizzle<'1', 'w', '0', 'y'>(Vector4i(2, 4, 5, 7));
-    CORRADE_COMPARE(b, Vector4i(1, 7, 0, 4));
+    constexpr auto c = swizzle<'z', 'x', 'w', 'y', 'z', 'y', 'x'>(Vector4i(1, 2, 3, 4));
+    CORRADE_COMPARE(c, (Math::Vector<7, Int>(3, 1, 4, 2, 3, 2, 1)));
 }
 
 }}}

src/Math/Test/VectorTest.cpp

@@ -37,11 +37,11 @@ namespace Magnum { namespace Math {
 namespace Implementation {
 
 template<> struct VectorConverter<3, float, Vec3> {
-    inline static Vector<3, Float> from(const Vec3& other) {
+    inline constexpr static Vector<3, Float> from(const Vec3& other) {
         return {other.x, other.y, other.z};
     }
 
-    inline static Vec3 to(const Vector<3, Float>& other) {
+    inline constexpr static Vec3 to(const Vector<3, Float>& other) {
         return {other[0], other[1], other[2]};
     }
 };
@@ -198,12 +198,24 @@ void VectorTest::isNormalized() {
 }
 
 void VectorTest::convert() {
-    Vec3 a{1.5f, 2.0f, -3.5f};
-    Vector3 b(1.5f, 2.0f, -3.5f);
-    CORRADE_COMPARE(Vector3(a), b);
-    CORRADE_COMPARE(Vec3(b).x, a.x);
-    CORRADE_COMPARE(Vec3(b).y, a.y);
-    CORRADE_COMPARE(Vec3(b).z, a.z);
+    constexpr Vec3 a{1.5f, 2.0f, -3.5f};
+    constexpr Vector3 b(1.5f, 2.0f, -3.5f);
+
+    #ifndef CORRADE_GCC46_COMPATIBILITY
+    constexpr Vector3 c(a);
+    #else
+    Vector3 c(a); /* Not constexpr under GCC < 4.7 */
+    #endif
+    CORRADE_COMPARE(c, b);
+
+    #ifndef CORRADE_GCC46_COMPATIBILITY
+    constexpr Vec3 d(b);
+    #else
+    Vec3 d(b); /* Not constexpr under GCC < 4.7 */
+    #endif
+    CORRADE_COMPARE(d.x, a.x);
+    CORRADE_COMPARE(d.y, a.y);
+    CORRADE_COMPARE(d.z, a.z);
 }
 
 void VectorTest::data() {

src/Math/Vector.h

@@ -162,7 +162,13 @@ template<std::size_t size, class T> class Vector {
         #endif
 
         /** @brief Construct vector from external representation */
+        #ifndef CORRADE_GCC46_COMPATIBILITY
         template<class U, class V = decltype(Implementation::VectorConverter<size, T, U>::from(std::declval<U>()))> inline constexpr explicit Vector(const U& other): Vector(Implementation::VectorConverter<size, T, U>::from(other)) {}
+        #else
+        template<class U, class V = decltype(Implementation::VectorConverter<size, T, U>::from(std::declval<U>()))> inline explicit Vector(const U& other) {
+            *this = Implementation::VectorConverter<size, T, U>::from(other);
+        }
+        #endif
 
         /** @brief Copy constructor */
         inline constexpr Vector(const Vector<size, T>&) = default;
@@ -172,6 +178,7 @@ template<std::size_t size, class T> class Vector {
 
         /** @brief Convert vector to external representation */
         template<class U, class V = decltype(Implementation::VectorConverter<size, T, U>::to(std::declval<Vector<size, T>>()))> inline constexpr explicit operator U() const {
+            /** @bug Why this is not constexpr under GCC 4.6? */
             return Implementation::VectorConverter<size, T, U>::to(*this);
         }
 

src/Mesh.h

@@ -240,8 +240,8 @@ for more information.
 class MAGNUM_EXPORT Mesh {
     friend class Context;
 
-    Mesh(const Mesh& other) = delete;
-    Mesh& operator=(const Mesh& other) = delete;
+    Mesh(const Mesh&) = delete;
+    Mesh& operator=(const Mesh&) = delete;
 
     public:
         /** @name Polygon drawing settings */

src/Physics/ShapeGroup.h

@@ -95,8 +95,8 @@ template<UnsignedInt dimensions> class MAGNUM_PHYSICS_EXPORT ShapeGroup: public
     #undef friendOp
     #endif
 
-    ShapeGroup(const ShapeGroup& other) = delete;
-    ShapeGroup& operator=(const ShapeGroup& other) = delete;
+    ShapeGroup(const ShapeGroup&) = delete;
+    ShapeGroup& operator=(const ShapeGroup&) = delete;
 
     public:
         /** @brief Default constructor */

src/Platform/AbstractXApplication.h

@@ -161,10 +161,10 @@ CORRADE_ENUMSET_OPERATORS(AbstractXApplication::Flags)
     mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent()
 */
 class AbstractXApplication::InputEvent {
-    InputEvent(const InputEvent& other) = delete;
-    InputEvent(InputEvent&& other) = delete;
-    InputEvent& operator=(const InputEvent& other) = delete;
-    InputEvent& operator=(InputEvent&& other) = delete;
+    InputEvent(const InputEvent&) = delete;
+    InputEvent(InputEvent&&) = delete;
+    InputEvent& operator=(const InputEvent&) = delete;
+    InputEvent& operator=(InputEvent&&) = delete;
 
     public:
     public:

src/Platform/GlutApplication.h

@@ -231,10 +231,10 @@ class GlutApplication {
     mouseReleaseEvent(), mouseMoveEvent()
 */
 class GlutApplication::InputEvent {
-    InputEvent(const InputEvent& other) = delete;
-    InputEvent(InputEvent&& other) = delete;
-    InputEvent& operator=(const InputEvent& other) = delete;
-    InputEvent& operator=(InputEvent&& other) = delete;
+    InputEvent(const InputEvent&) = delete;
+    InputEvent(InputEvent&&) = delete;
+    InputEvent& operator=(const InputEvent&) = delete;
+    InputEvent& operator=(InputEvent&&) = delete;
 
     public:
         inline virtual ~InputEvent() {}

src/Platform/NaClApplication.h

@@ -228,10 +228,10 @@ propagated to the browser.
     mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent()
 */
 class NaClApplication::InputEvent {
-    InputEvent(const InputEvent& other) = delete;
-    InputEvent(InputEvent&& other) = delete;
-    InputEvent& operator=(const InputEvent& other) = delete;
-    InputEvent& operator=(InputEvent&& other) = delete;
+    InputEvent(const InputEvent&) = delete;
+    InputEvent(InputEvent&&) = delete;
+    InputEvent& operator=(const InputEvent&) = delete;
+    InputEvent& operator=(InputEvent&&) = delete;
 
     public:
         /**

src/Platform/Sdl2Application.h

@@ -186,10 +186,10 @@ CORRADE_ENUMSET_OPERATORS(Sdl2Application::Flags)
     mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent()
 */
 class Sdl2Application::InputEvent {
-    InputEvent(const InputEvent& other) = delete;
-    InputEvent(InputEvent&& other) = delete;
-    InputEvent& operator=(const InputEvent& other) = delete;
-    InputEvent& operator=(InputEvent&& other) = delete;
+    InputEvent(const InputEvent&) = delete;
+    InputEvent(InputEvent&&) = delete;
+    InputEvent& operator=(const InputEvent&) = delete;
+    InputEvent& operator=(InputEvent&&) = delete;
 
     public:
         /**

src/Primitives/Capsule.cpp

@@ -34,7 +34,7 @@ Capsule::Capsule(UnsignedInt hemisphereRings, UnsignedInt cylinderRings, Unsigne
 
     Float height = 2.0f+length;
     Float hemisphereTextureCoordsVIncrement = 1.0f/(hemisphereRings*height);
-    Rad hemisphereRingAngleIncrement = Rad(Constants::pi())/(2*hemisphereRings);
+    Rad hemisphereRingAngleIncrement(Constants::pi()/(2*hemisphereRings));
 
     /* Bottom cap vertex */
     capVertex(-height/2, -1.0f, 0.0f);
@@ -68,7 +68,7 @@ void Capsule::capVertex(Float y, Float normalY, Float textureCoordsV) {
 }
 
 void Capsule::hemisphereVertexRings(UnsignedInt count, Float centerY, Rad startRingAngle, Rad ringAngleIncrement, Float startTextureCoordsV, Float textureCoordsVIncrement) {
-    Rad segmentAngleIncrement = 2*Rad(Constants::pi())/segments;
+    Rad segmentAngleIncrement(2*Constants::pi()/segments);
     Float x, y, z;
     for(UnsignedInt i = 0; i != count; ++i) {
         Rad ringAngle = startRingAngle + i*ringAngleIncrement;
@@ -94,7 +94,7 @@ void Capsule::hemisphereVertexRings(UnsignedInt count, Float centerY, Rad startR
 }
 
 void Capsule::cylinderVertexRings(UnsignedInt count, Float startY, Float yIncrement, Float startTextureCoordsV, Float textureCoordsVIncrement) {
-    Rad segmentAngleIncrement = 2*Rad(Constants::pi())/segments;
+    Rad segmentAngleIncrement(2*Constants::pi()/segments);
     for(UnsignedInt i = 0; i != count; ++i) {
         for(UnsignedInt j = 0; j != segments; ++j) {
             Rad segmentAngle = j*segmentAngleIncrement;

src/Primitives/Cylinder.cpp

@@ -57,7 +57,7 @@ Cylinder::Cylinder(UnsignedInt rings, UnsignedInt segments, Float length, Flags
 }
 
 void Cylinder::capVertexRing(Float y, Float textureCoordsV, const Vector3& normal) {
-    Rad segmentAngleIncrement = 2*Rad(Constants::pi())/segments;
+    Rad segmentAngleIncrement(2*Constants::pi()/segments);
 
     for(UnsignedInt i = 0; i != segments; ++i) {
         Rad segmentAngle = i*segmentAngleIncrement;

src/Primitives/UVSphere.cpp

@@ -32,7 +32,7 @@ UVSphere::UVSphere(UnsignedInt rings, UnsignedInt segments, TextureCoords textur
     CORRADE_ASSERT(rings >= 2 && segments >= 3, "UVSphere must have at least two rings and three segments", );
 
     Float textureCoordsVIncrement = 1.0f/rings;
-    Rad ringAngleIncrement = Rad(Constants::pi())/rings;
+    Rad ringAngleIncrement(Constants::pi()/rings);
 
     /* Bottom cap vertex */
     capVertex(-1.0f, -1.0f, 0.0f);

src/Query.cpp

@@ -26,6 +26,20 @@
 
 namespace Magnum {
 
+AbstractQuery::AbstractQuery() {
+    /** @todo Get some extension wrangler instead to avoid undeclared glGenQueries() on ES2 */
+    #ifndef MAGNUM_TARGET_GLES2
+    glGenQueries(1, &_id);
+    #endif
+}
+
+AbstractQuery::~AbstractQuery() {
+    /** @todo Get some extension wrangler instead to avoid undeclared glGenQueries() on ES2 */
+    #ifndef MAGNUM_TARGET_GLES2
+    glDeleteQueries(1, &_id);
+    #endif
+}
+
 bool AbstractQuery::resultAvailable() {
     /** @todo Re-enable when extension wrangler is available for ES */
     #ifndef MAGNUM_TARGET_GLES2
@@ -79,6 +93,10 @@ template<> Long AbstractQuery::result<Long>() {
 }
 #endif
 
+Query::Query(): target(nullptr) {}
+
+Query::~Query() { delete target; }
+
 #ifndef MAGNUM_TARGET_GLES2
 void Query::begin(Query::Target target) {
     glBeginQuery(static_cast<GLenum>(target), id());
@@ -94,6 +112,10 @@ void Query::end() {
 }
 #endif
 
+SampleQuery::SampleQuery(): target(nullptr) {}
+
+SampleQuery::~SampleQuery() { delete target; }
+
 void SampleQuery::begin(SampleQuery::Target target) {
     /** @todo Re-enable when extension wrangler is available for ES */
     #ifndef MAGNUM_TARGET_GLES2
@@ -113,4 +135,6 @@ void SampleQuery::end() {
     target = nullptr;
 }
 
+TimeQuery::TimeQuery() = default;
+
 }

src/Query.h

@@ -49,12 +49,7 @@ class MAGNUM_EXPORT AbstractQuery {
          * Generates one OpenGL query.
          * @see @fn_gl{GenQueries}
          */
-        inline explicit AbstractQuery() {
-            /** @todo Get some extension wrangler instead to avoid undeclared glGenQueries() on ES2 */
-            #ifndef MAGNUM_TARGET_GLES2
-            glGenQueries(1, &_id);
-            #endif
-        }
+        explicit AbstractQuery();
 
         /**
          * @brief Destructor
@@ -62,12 +57,7 @@ class MAGNUM_EXPORT AbstractQuery {
          * Deletes assigned OpenGL query.
          * @see @fn_gl{DeleteQueries}
          */
-        virtual inline ~AbstractQuery() {
-            /** @todo Get some extension wrangler instead to avoid undeclared glGenQueries() on ES2 */
-            #ifndef MAGNUM_TARGET_GLES2
-            glDeleteQueries(1, &_id);
-            #endif
-        }
+        virtual ~AbstractQuery() = 0;
 
         /** @brief OpenGL query ID */
         inline GLuint id() const { return _id; }
@@ -163,9 +153,9 @@ class MAGNUM_EXPORT Query: public AbstractQuery {
             #endif
         };
 
-        inline explicit Query(): target(nullptr) {}
+        explicit Query();
 
-        inline ~Query() { delete target; }
+        ~Query();
 
         /**
          * @brief Begin query
@@ -294,9 +284,9 @@ class MAGNUM_EXPORT SampleQuery: public AbstractQuery {
         };
         #endif
 
-        inline explicit SampleQuery(): target(nullptr) {}
+        explicit SampleQuery();
 
-        inline ~SampleQuery() { delete target; }
+        ~SampleQuery();
 
         /** @copydoc Query::begin() */
         void begin(Target target);
@@ -369,7 +359,7 @@ Using this query results in fewer OpenGL calls when doing more measures.
 */
 class TimeQuery: public AbstractQuery {
     public:
-        explicit TimeQuery() = default;
+        explicit TimeQuery();
 
         /**
          * @brief Query timestamp

src/Renderbuffer.h

@@ -54,10 +54,10 @@ See its documentation for more information.
 class MAGNUM_EXPORT Renderbuffer {
     friend class Context;
 
-    Renderbuffer(const Renderbuffer& other) = delete;
-    Renderbuffer(Renderbuffer&& other) = delete;
-    Renderbuffer& operator=(const Renderbuffer& other) = delete;
-    Renderbuffer& operator=(Renderbuffer&& other) = delete;
+    Renderbuffer(const Renderbuffer&) = delete;
+    Renderbuffer(Renderbuffer&&) = delete;
+    Renderbuffer& operator=(const Renderbuffer&) = delete;
+    Renderbuffer& operator=(Renderbuffer&&) = delete;
 
     public:
         /**

src/SceneGraph/FeatureGroup.h

@@ -56,7 +56,7 @@ class FeatureGroup {
         /**
          * @brief Destructor
          *
-         * Removes all features belogning to this group, but not deletes them.
+         * Removes all features belonging to this group, but not deletes them.
          */
         inline virtual ~FeatureGroup() {
             for(auto it = features.begin(); it != features.end(); ++it)

src/SceneGraph/Object.h

@@ -99,10 +99,10 @@ template<class Transformation> class MAGNUM_SCENEGRAPH_EXPORT Object: public Abs
     friend class Corrade::Containers::LinkedListItem<Object<Transformation>, Object<Transformation>>;
 
     #ifndef DOXYGEN_GENERATING_OUTPUT
-    Object(const Object<Transformation>& other) = delete;
-    Object(Object<Transformation>&& other) = delete;
-    Object<Transformation>& operator=(const Object<Transformation>& other) = delete;
-    Object<Transformation>& operator=(Object<Transformation>&& other) = delete;
+    Object(const Object<Transformation>&) = delete;
+    Object(Object<Transformation>&&) = delete;
+    Object<Transformation>& operator=(const Object<Transformation>&) = delete;
+    Object<Transformation>& operator=(Object<Transformation>&&) = delete;
     #endif
 
     public:

src/Shader.h

@@ -45,8 +45,8 @@ Allows loading and compiling the shader from file or directly from source
 string. See AbstractShaderProgram for more information.
  */
 class MAGNUM_EXPORT Shader {
-    Shader(const Shader& other) = delete;
-    Shader& operator=(const Shader& other) = delete;
+    Shader(const Shader&) = delete;
+    Shader& operator=(const Shader&) = delete;
 
     public:
         /** @brief %Shader type */

src/Test/ResourceManagerTest.cpp

@@ -59,7 +59,7 @@ typedef Magnum::ResourceManager<Int, Data> ResourceManager;
 class IntResourceLoader: public AbstractResourceLoader<Int> {
     public:
         void load(ResourceKey key) override {
-            AbstractResourceLoader::load(key);
+            AbstractResourceLoader<Int>::load(key);
         }
 
         void load() {

src/Test/SwizzleTest.cpp

@@ -44,27 +44,45 @@ SwizzleTest::SwizzleTest() {
 }
 
 void SwizzleTest::rgba() {
-    CORRADE_COMPARE((swizzle<'b', 'r', 'a', 'g'>(Vector4i(2, 4, 5, 7))), Vector4i(5, 2, 7, 4));
+    constexpr auto a = swizzle<'b', 'r', 'a', 'g'>(Vector4i(2, 4, 5, 7));
+    CORRADE_COMPARE(a, Vector4i(5, 2, 7, 4));
 }
 
 void SwizzleTest::type() {
-    Vector4i orig;
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'a'>(orig)), Vector2i>::value));
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'z', 'a'>(orig)), Vector3i>::value));
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'a', 'y', 'x'>(orig)), Vector4i>::value));
-
-    Color3<Float> origColor3;
-    Color4<Double> origColor4;
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'z', 'r'>(origColor3)), Color3<Float>>::value));
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'z', 'a'>(origColor4)), Color3<Double>>::value));
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'z', 'y', 'x'>(origColor3)), Color4<Float>>::value));
-    CORRADE_VERIFY((std::is_same<decltype(swizzle<'y', 'a', 'y', 'x'>(origColor4)), Color4<Double>>::value));
+    constexpr Vector4i orig;
+    constexpr Color3<Float> origColor3;
+    constexpr Color4<Double> origColor4;
+
+    constexpr auto a = swizzle<'y', 'a'>(orig);
+    CORRADE_VERIFY((std::is_same<decltype(a), const Vector2i>::value));
+
+    constexpr auto b = swizzle<'y', 'z', 'a'>(orig);
+    CORRADE_VERIFY((std::is_same<decltype(b), const Vector3i>::value));
+
+    constexpr auto c = swizzle<'y', 'a', 'y', 'x'>(orig);
+    CORRADE_VERIFY((std::is_same<decltype(c), const Vector4i>::value));
+
+    constexpr auto d = swizzle<'y', 'z', 'r'>(origColor3);
+    CORRADE_VERIFY((std::is_same<decltype(d), const Color3<Float>>::value));
+
+    constexpr auto e = swizzle<'y', 'z', 'a'>(origColor4);
+    CORRADE_VERIFY((std::is_same<decltype(e), const Color3<Double>>::value));
+
+    constexpr auto f = swizzle<'y', 'z', 'y', 'x'>(origColor3);
+    CORRADE_VERIFY((std::is_same<decltype(f), const Color4<Float>>::value));
+
+    constexpr auto g = swizzle<'y', 'a', 'y', 'x'>(origColor4);
+    CORRADE_VERIFY((std::is_same<decltype(g), const Color4<Double>>::value));
 }
 
 void SwizzleTest::defaultType() {
-    Vector4i orig(1, 2, 3, 4);
-    CORRADE_COMPARE(swizzle<'b'>(orig), (Math::Vector<1, Int>(3)));
-    CORRADE_COMPARE((swizzle<'b', 'r', 'a', 'g', 'z', 'y', 'x'>(orig)), (Math::Vector<7, Int>(3, 1, 4, 2, 3, 2, 1)));
+    constexpr Vector4i orig(1, 2, 3, 4);
+
+    constexpr auto a = swizzle<'b'>(orig);
+    CORRADE_COMPARE(a, (Math::Vector<1, Int>(3)));
+
+    constexpr auto b = swizzle<'b', 'r', 'a', 'g', 'z', 'y', 'x'>(orig);
+    CORRADE_COMPARE(b, (Math::Vector<7, Int>(3, 1, 4, 2, 3, 2, 1)));
 }
 
 }}

src/Trade/AbstractImporter.cpp

@@ -30,6 +30,10 @@
 
 namespace Magnum { namespace Trade {
 
+AbstractImporter::AbstractImporter() = default;
+
+AbstractImporter::AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager, std::string plugin): AbstractPlugin(manager, std::move(plugin)) {}
+
 bool AbstractImporter::open(const std::string&) {
     Error() << plugin() << "doesn't support opening files";
     return false;

src/Trade/AbstractImporter.h

@@ -71,10 +71,10 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::AbstractPlu
         typedef Corrade::Containers::EnumSet<Feature, int> Features;
 
         /** @brief Default constructor */
-        inline explicit AbstractImporter() = default;
+        explicit AbstractImporter();
 
         /** @brief Plugin manager constructor */
-        inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager, std::string plugin): AbstractPlugin(manager, std::move(plugin)) {}
+        explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager, std::string plugin);
 
         /** @brief Features supported by this importer */
         virtual Features features() const = 0;

src/Trade/AbstractMaterialData.h

@@ -38,10 +38,10 @@ namespace Magnum { namespace Trade {
 Subclasses provide access to parameters for given material type.
 */
 class AbstractMaterialData {
-    AbstractMaterialData(const AbstractMaterialData& other) = delete;
-    AbstractMaterialData(AbstractMaterialData&& other) = delete;
-    AbstractMaterialData& operator=(const AbstractMaterialData& other) = delete;
-    AbstractMaterialData& operator=(AbstractMaterialData&& other) = delete;
+    AbstractMaterialData(const AbstractMaterialData&) = delete;
+    AbstractMaterialData(AbstractMaterialData&&) = delete;
+    AbstractMaterialData& operator=(const AbstractMaterialData&) = delete;
+    AbstractMaterialData& operator=(AbstractMaterialData&&) = delete;
 
     public:
         /** @brief Material type */

src/Trade/CameraData.h

@@ -36,10 +36,10 @@ namespace Magnum { namespace Trade {
 @brief %Camera data
 */
 class MAGNUM_EXPORT CameraData {
-    CameraData(const CameraData& other) = delete;
-    CameraData(CameraData&& other) = delete;
-    CameraData& operator=(const CameraData& other) = delete;
-    CameraData& operator=(CameraData&& other) = delete;
+    CameraData(const CameraData&) = delete;
+    CameraData(CameraData&&) = delete;
+    CameraData& operator=(const CameraData&) = delete;
+    CameraData& operator=(CameraData&&) = delete;
 };
 
 }}

src/Trade/LightData.h

@@ -36,10 +36,10 @@ namespace Magnum { namespace Trade {
 @brief %Light data
 */
 class MAGNUM_EXPORT LightData {
-    LightData(const LightData& other) = delete;
-    LightData(LightData&& other) = delete;
-    LightData& operator=(const LightData& other) = delete;
-    LightData& operator=(LightData&& other) = delete;
+    LightData(const LightData&) = delete;
+    LightData(LightData&&) = delete;
+    LightData& operator=(const LightData&) = delete;
+    LightData& operator=(LightData&&) = delete;
 };
 
 }}

src/Trade/MeshData2D.cpp

@@ -28,6 +28,12 @@
 
 namespace Magnum { namespace Trade {
 
+MeshData2D::MeshData2D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector2>*> positions, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(std::move(positions)), _textureCoords2D(std::move(textureCoords2D)) {}
+
+MeshData2D::MeshData2D(MeshData2D&&) = default;
+
+MeshData2D& MeshData2D::operator=(MeshData2D&&) = default;
+
 MeshData2D::~MeshData2D() {
     delete _indices;
     for(auto it = _positions.begin(); it != _positions.end(); ++it) delete *it;

src/Trade/MeshData2D.h

@@ -42,8 +42,8 @@ type.
 @see MeshData3D
 */
 class MAGNUM_EXPORT MeshData2D {
-    MeshData2D(const MeshData2D& other) = delete;
-    MeshData2D& operator=(const MeshData2D& other) = delete;
+    MeshData2D(const MeshData2D&) = delete;
+    MeshData2D& operator=(const MeshData2D&) = delete;
 
     public:
         /**
@@ -56,16 +56,16 @@ class MAGNUM_EXPORT MeshData2D {
          * @param textureCoords2D   Array with two-dimensional texture
          *      coordinate arrays or empty array
          */
-        inline MeshData2D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector2>*> positions, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(positions), _textureCoords2D(textureCoords2D) {}
+        MeshData2D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector2>*> positions, std::vector<std::vector<Vector2>*> textureCoords2D);
 
         /** @brief Move constructor */
-        MeshData2D(MeshData2D&&) = default;
+        MeshData2D(MeshData2D&&);
 
         /** @brief Destructor */
         ~MeshData2D();
 
         /** @brief Move assignment */
-        MeshData2D& operator=(MeshData2D&&) = default;
+        MeshData2D& operator=(MeshData2D&&);
 
         /** @brief Primitive */
         inline Mesh::Primitive primitive() const { return _primitive; }

src/Trade/MeshData3D.cpp

@@ -28,6 +28,12 @@
 
 namespace Magnum { namespace Trade {
 
+MeshData3D::MeshData3D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector3>*> positions, std::vector<std::vector<Vector3>*> normals, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(std::move(positions)), _normals(std::move(normals)), _textureCoords2D(std::move(textureCoords2D)) {}
+
+MeshData3D::MeshData3D(MeshData3D&&) = default;
+
+MeshData3D& MeshData3D::operator=(MeshData3D&&) = default;
+
 MeshData3D::~MeshData3D() {
     delete _indices;
     for(auto it = _positions.begin(); it != _positions.end(); ++it) delete *it;

src/Trade/MeshData3D.h

@@ -42,8 +42,8 @@ type.
 @see MeshData2D
 */
 class MAGNUM_EXPORT MeshData3D {
-    MeshData3D(const MeshData3D& other) = delete;
-    MeshData3D& operator=(const MeshData3D& other) = delete;
+    MeshData3D(const MeshData3D&) = delete;
+    MeshData3D& operator=(const MeshData3D&) = delete;
 
     public:
         /**
@@ -57,16 +57,16 @@ class MAGNUM_EXPORT MeshData3D {
          * @param textureCoords2D   Array with two-dimensional texture
          *      coordinate arrays or empty array
          */
-        inline MeshData3D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector3>*> positions, std::vector<std::vector<Vector3>*> normals, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(positions), _normals(normals), _textureCoords2D(textureCoords2D) {}
+        MeshData3D(Mesh::Primitive primitive, std::vector<UnsignedInt>* indices, std::vector<std::vector<Vector3>*> positions, std::vector<std::vector<Vector3>*> normals, std::vector<std::vector<Vector2>*> textureCoords2D);
 
         /** @brief Move constructor */
-        MeshData3D(MeshData3D&&) = default;
+        MeshData3D(MeshData3D&&);
 
         /** @brief Destructor */
         ~MeshData3D();
 
         /** @brief Move assignment */
-        MeshData3D& operator=(MeshData3D&&) = default;
+        MeshData3D& operator=(MeshData3D&&);
 
         /** @brief Primitive */
         inline Mesh::Primitive primitive() const { return _primitive; }

src/Trade/MeshObjectData2D.h

@@ -39,10 +39,10 @@ Provides access to material information for given mesh instance.
 @see MeshObjectData3D
 */
 class MeshObjectData2D: public ObjectData2D {
-    MeshObjectData2D(const MeshObjectData2D& other) = delete;
-    MeshObjectData2D(MeshObjectData2D&& other) = delete;
-    MeshObjectData2D& operator=(const MeshObjectData2D& other) = delete;
-    MeshObjectData2D& operator=(MeshObjectData2D&& other) = delete;
+    MeshObjectData2D(const MeshObjectData2D&) = delete;
+    MeshObjectData2D(MeshObjectData2D&&) = delete;
+    MeshObjectData2D& operator=(const MeshObjectData2D&) = delete;
+    MeshObjectData2D& operator=(MeshObjectData2D&&) = delete;
 
     public:
         /**

src/Trade/MeshObjectData3D.h

@@ -39,10 +39,10 @@ Provides access to material information for given mesh instance.
 @see MeshObjectData2D
 */
 class MeshObjectData3D: public ObjectData3D {
-    MeshObjectData3D(const MeshObjectData3D& other) = delete;
-    MeshObjectData3D(MeshObjectData3D&& other) = delete;
-    MeshObjectData3D& operator=(const MeshObjectData3D& other) = delete;
-    MeshObjectData3D& operator=(MeshObjectData3D&& other) = delete;
+    MeshObjectData3D(const MeshObjectData3D&) = delete;
+    MeshObjectData3D(MeshObjectData3D&&) = delete;
+    MeshObjectData3D& operator=(const MeshObjectData3D&) = delete;
+    MeshObjectData3D& operator=(MeshObjectData3D&&) = delete;
 
     public:
         /**

src/Trade/ObjectData2D.h

@@ -43,10 +43,10 @@ MeshObjectData2D, which is specialized for objects with mesh instance type.
 @see ObjectData3D
 */
 class ObjectData2D {
-    ObjectData2D(const ObjectData2D& other) = delete;
-    ObjectData2D(ObjectData2D&& other) = delete;
-    ObjectData2D& operator=(const ObjectData2D& other) = delete;
-    ObjectData2D& operator=(ObjectData2D&& other) = delete;
+    ObjectData2D(const ObjectData2D&) = delete;
+    ObjectData2D(ObjectData2D&&) = delete;
+    ObjectData2D& operator=(const ObjectData2D&) = delete;
+    ObjectData2D& operator=(ObjectData2D&&) = delete;
 
     public:
         /** @brief Instance type */

src/Trade/ObjectData3D.h

@@ -43,10 +43,10 @@ MeshObjectData3D, which is specialized for objects with mesh instance type.
 @see ObjectData2D
 */
 class ObjectData3D {
-    ObjectData3D(const ObjectData3D& other) = delete;
-    ObjectData3D(ObjectData3D&& other) = delete;
-    ObjectData3D& operator=(const ObjectData3D& other) = delete;
-    ObjectData3D& operator=(ObjectData3D&& other) = delete;
+    ObjectData3D(const ObjectData3D&) = delete;
+    ObjectData3D(ObjectData3D&&) = delete;
+    ObjectData3D& operator=(const ObjectData3D&) = delete;
+    ObjectData3D& operator=(ObjectData3D&&) = delete;
 
     public:
         /** @brief Instance type */

src/Trade/SceneData.h

@@ -39,10 +39,10 @@ namespace Magnum { namespace Trade {
 @brief %Scene data
 */
 class MAGNUM_EXPORT SceneData {
-    SceneData(const SceneData& other) = delete;
-    SceneData(SceneData&& other) = delete;
-    SceneData& operator=(const SceneData& other) = delete;
-    SceneData& operator=(SceneData&& other) = delete;
+    SceneData(const SceneData&) = delete;
+    SceneData(SceneData&&) = delete;
+    SceneData& operator=(const SceneData&) = delete;
+    SceneData& operator=(SceneData&&) = delete;
 
     public:
         /**

src/Trade/TextureData.h

@@ -34,10 +34,10 @@ namespace Magnum { namespace Trade {
 @brief %Texture data
 */
 class MAGNUM_EXPORT TextureData {
-    TextureData(const TextureData& other) = delete;
-    TextureData(TextureData&& other) = delete;
-    TextureData& operator=(const TextureData& other) = delete;
-    TextureData& operator=(TextureData&& other) = delete;
+    TextureData(const TextureData&) = delete;
+    TextureData(TextureData&&) = delete;
+    TextureData& operator=(const TextureData&) = delete;
+    TextureData& operator=(TextureData&&) = delete;
 };
 
 }}