Merge branch 'master' into compatibility

Conflicts:
	src/Physics/Implementation/DebugRenderer.h

src/AbstractTexture.h

@@ -677,7 +677,7 @@ class MAGNUM_EXPORT AbstractTexture {
          *      with @def_gl{TEXTURE_BORDER_COLOR}
          * @requires_gl Texture border is not available in OpenGL ES.
          */
-        inline AbstractTexture* setBorderColor(const Color4<GLfloat>& color) {
+        inline AbstractTexture* setBorderColor(const Color4<>& color) {
             (this->*parameterfvImplementation)(GL_TEXTURE_BORDER_COLOR, color.data());
             return this;
         }

src/CMakeLists.txt

@@ -24,6 +24,7 @@ set(Magnum_SRCS
     AbstractShaderProgram.cpp
     Buffer.cpp
     Context.cpp
+    DebugMarker.cpp
     Framebuffer.cpp
     Image.cpp
     IndexedMesh.cpp
@@ -63,6 +64,7 @@ set(Magnum_HEADERS
     Color.h
     Context.h
     CubeMapTexture.h
+    DebugMarker.h
     DimensionTraits.h
     Extensions.h
     Framebuffer.h

src/Color.h

@@ -145,7 +145,12 @@ range @f$ [0.0, 1.0] @f$.
 */
 /* Not using template specialization because some internal functions are
    impossible to explicitly instantiate */
-template<class T> class Color3: public Math::Vector3<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class Color3: public Math::Vector3<T> {
     public:
         /** @brief Corresponding floating-point type for HSV computation */
         typedef typename Math::MathTypeTraits<T>::FloatingPointType FloatingPointType;
@@ -291,7 +296,12 @@ See Color3 for more information.
 */
 /* Not using template specialization because some internal functions are
    impossible to explicitly instantiate */
-template<class T> class Color4: public Math::Vector4<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class Color4: public Math::Vector4<T> {
     public:
         /** @copydoc Color3::FloatingPointType */
         typedef typename Color3<T>::FloatingPointType FloatingPointType;

src/Context.cpp

@@ -27,18 +27,47 @@
 #include "IndexedMesh.h"
 #include "Mesh.h"
 #include "Implementation/State.h"
+#include "DebugMarker.h"
 
 using namespace std;
 
 namespace Magnum {
 
+Debug operator<<(Debug debug, Version value) {
+    switch(value) {
+        #define _c(value, string) case Version::value: return debug << string;
+        _c(None, "None")
+        #ifndef MAGNUM_TARGET_GLES
+        _c(GL210, "OpenGL 2.1")
+        _c(GL300, "OpenGL 3.0")
+        _c(GL310, "OpenGL 3.1")
+        _c(GL320, "OpenGL 3.2")
+        _c(GL330, "OpenGL 3.3")
+        _c(GL400, "OpenGL 4.0")
+        _c(GL410, "OpenGL 4.1")
+        _c(GL420, "OpenGL 4.2")
+        _c(GL430, "OpenGL 4.3")
+        #else
+        _c(GLES200, "OpenGL ES 2.0")
+        _c(GLES300, "OpenGL ES 3.0")
+        #endif
+        #undef _c
+    }
+
+    return debug << "Invalid";
+}
+
 const std::vector<Extension>& Extension::extensions(Version version) {
     #define _extension(prefix, vendor, extension)                           \
         {Extensions::prefix::vendor::extension::Index, Extensions::prefix::vendor::extension::requiredVersion(), Extensions::prefix::vendor::extension::coreVersion(), Extensions::prefix::vendor::extension::string()}
     static const std::vector<Extension> empty;
     #ifndef MAGNUM_TARGET_GLES
     static const std::vector<Extension> extensions{
-        _extension(GL,EXT,texture_filter_anisotropic)};
+        _extension(GL,AMD,vertex_shader_layer),
+        _extension(GL,AMD,shader_trinary_minmax),
+        _extension(GL,EXT,texture_filter_anisotropic),
+        _extension(GL,EXT,direct_state_access),
+        _extension(GL,GREMEDY,string_marker)};
     static const std::vector<Extension> extensions300{
         _extension(GL,APPLE,flush_buffer_range),
         _extension(GL,APPLE,vertex_array_object),
@@ -248,6 +277,7 @@ Context::Context() {
     #ifndef MAGNUM_TARGET_GLES
     BufferedTexture::initializeContextBasedFunctionality(this);
     #endif
+    DebugMarker::initializeContextBasedFunctionality(this);
     IndexedMesh::initializeContextBasedFunctionality(this);
     Mesh::initializeContextBasedFunctionality(this);
 }

src/Context.h

@@ -16,7 +16,7 @@
 */
 
 /** @file
- * @brief Enum Version, class Magnum::Context, Magnum::Extension
+ * @brief Enum Version, class Magnum::Context, Magnum::Extension, macro MAGNUM_ASSERT_VERSION_SUPPORTED(), MAGNUM_ASSERT_EXTENSION_SUPPORTED()
  */
 
 #include <bitset>
@@ -34,9 +34,13 @@ namespace Implementation {
 }
 #endif
 
-/** @brief OpenGL version */
+/**
+@brief OpenGL version
+
+@see Context, MAGNUM_ASSERT_VERSION_SUPPORTED()
+*/
 enum class Version: GLint {
-    None = 0,                       /**< @brief Unspecified */
+    None = 0xFFFF,                  /**< @brief Unspecified */
     #ifndef MAGNUM_TARGET_GLES
     GL210 = 210,                    /**< @brief OpenGL 2.1 / GLSL 1.20 */
     GL300 = 300,                    /**< @brief OpenGL 3.0 / GLSL 1.30 */
@@ -76,6 +80,9 @@ enum class Version: GLint {
     #endif
 };
 
+/** @debugoperator{Magnum::Context} */
+Debug MAGNUM_EXPORT operator<<(Debug debug, Version value);
+
 /**
 @brief Run-time information about OpenGL extension
 
@@ -197,7 +204,7 @@ class MAGNUM_EXPORT Context {
         /**
          * @brief Whether given OpenGL version is supported
          *
-         * @see supportedVersion()
+         * @see supportedVersion(), MAGNUM_ASSERT_VERSION_SUPPORTED()
          */
         inline bool isVersionSupported(Version version) const {
             #ifndef CORRADE_GCC44_COMPATIBILITY
@@ -236,7 +243,8 @@ class MAGNUM_EXPORT Context {
          * }
          * @endcode
          *
-         * @see isExtensionSupported(const Extension&) const
+         * @see isExtensionSupported(const Extension&) const,
+         *      MAGNUM_ASSERT_EXTENSION_SUPPORTED()
          */
         template<class T> inline bool isExtensionSupported() const {
             return isVersionSupported(T::coreVersion()) || (isVersionSupported(T::requiredVersion()) && extensionStatus[T::Index]);
@@ -249,7 +257,8 @@ class MAGNUM_EXPORT Context {
          * hardware, but for general usage prefer isExtensionSupported() const,
          * as it does most operations in compile time.
          *
-         * @see supportedExtensions(), Extension::extensions()
+         * @see supportedExtensions(), Extension::extensions(),
+         *      MAGNUM_ASSERT_EXTENSION_SUPPORTED()
          */
         inline bool isExtensionSupported(const Extension& extension) const {
             return isVersionSupported(extension._coreVersion) || (isVersionSupported(extension._requiredVersion) && extensionStatus[extension._index]);
@@ -272,6 +281,65 @@ class MAGNUM_EXPORT Context {
         Implementation::State* _state;
 };
 
+/** @hideinitializer
+@brief Assert that given OpenGL version is supported
+@param version      Version
+
+Useful for initial checks on availability of required features.
+
+By default, if assertion fails, an message is printed to error output and the
+application exits with value `-3`. If `CORRADE_NO_ASSERT` is defined, this
+macro does nothing. Example usage:
+@code
+MAGNUM_ASSERT_VERSION_SUPPORTED(Version::GL330);
+@endcode
+
+@see @ref Magnum::Context::isVersionSupported() "Context::isVersionSupported()",
+    MAGNUM_ASSERT_EXTENSION_SUPPORTED(), CORRADE_ASSERT(),
+    CORRADE_INTERNAL_ASSERT()
+*/
+#ifdef CORRADE_NO_ASSERT
+#define MAGNUM_ASSERT_VERSION_SUPPORTED(version) do {} while(0)
+#else
+#define MAGNUM_ASSERT_VERSION_SUPPORTED(version)                            \
+    do {                                                                    \
+        if(!Context::current()->isVersionSupported(version)) {    \
+            Corrade::Utility::Error() << "Magnum: required version" << version << "is not supported"; \
+            exit(-3);                                                       \
+        }                                                                   \
+    } while(0)
+#endif
+
+/** @hideinitializer
+@brief Assert that given OpenGL extension is supported
+@param extension    Extension name (from @ref Magnum::Extensions "Extensions"
+    namespace)
+
+Useful for initial checks on availability of required features.
+
+By default, if assertion fails, an message is printed to error output and the
+application exits with value `-3`. If `CORRADE_NO_ASSERT` is defined, this
+macro does nothing. Example usage:
+@code
+MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::geometry_shader4);
+@endcode
+
+@see @ref Magnum::Context::isExtensionSupported() "Context::isExtensionSupported()",
+    MAGNUM_ASSERT_VERSION_SUPPORTED(), CORRADE_ASSERT(),
+    CORRADE_INTERNAL_ASSERT()
+*/
+#ifdef CORRADE_NO_ASSERT
+#define MAGNUM_ASSERT_EXTENSION_SUPPORTED(extension) do {} while(0)
+#else
+#define MAGNUM_ASSERT_EXTENSION_SUPPORTED(extension)                        \
+    do {                                                                    \
+        if(!Context::current()->isExtensionSupported<extension>()) { \
+            Corrade::Utility::Error() << "Magnum: required extension" << extension::string() << "is not supported"; \
+            exit(-3);                                                       \
+        }                                                                   \
+    } while(0)
+#endif
+
 }
 
 #endif

src/CubeMapTexture.h

@@ -121,7 +121,7 @@ class CubeMapTexture: public AbstractTexture {
             return this;
         }
         #ifndef MAGNUM_TARGET_GLES
-        inline CubeMapTexture* setBorderColor(const Color4<GLfloat>& color) {
+        inline CubeMapTexture* setBorderColor(const Color4<>& color) {
             AbstractTexture::setBorderColor(color);
             return this;
         }

src/CubeMapTextureArray.h

@@ -133,7 +133,7 @@ class CubeMapTextureArray: public AbstractTexture {
             AbstractTexture::setMagnificationFilter(filter);
             return this;
         }
-        inline CubeMapTextureArray* setBorderColor(const Color4<GLfloat>& color) {
+        inline CubeMapTextureArray* setBorderColor(const Color4<>& color) {
             AbstractTexture::setBorderColor(color);
             return this;
         }

src/DebugMarker.cpp

@@ -0,0 +1,48 @@
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+#include "DebugMarker.h"
+
+#include <Utility/Debug.h>
+
+#include "Context.h"
+#include "Extensions.h"
+
+namespace Magnum {
+
+DebugMarker::MarkImplementation DebugMarker::markImplementation = &DebugMarker::markImplementationDefault;
+
+void DebugMarker::initializeContextBasedFunctionality(Context* context) {
+    if(context->isExtensionSupported<Extensions::GL::GREMEDY::string_marker>()) {
+        Debug() << "DebugMarker: using" << Extensions::GL::GREMEDY::string_marker::string() << "features";
+
+        markImplementation = &DebugMarker::markImplementationDebugger;
+    }
+}
+
+void DebugMarker::markImplementationDefault(const std::string&) {}
+
+void DebugMarker::markImplementationDebugger(const std::string& string) {
+    /** @todo Re-enable when extension wrangler is available for ES */
+    #ifndef MAGNUM_TARGET_GLES
+    glStringMarkerGREMEDY(string.length(), string.c_str());
+    #else
+    #if 0
+    glInsertEventMarkerEXT(string.length(), string.c_str());
+    #endif
+    #endif
+}
+
+}

src/DebugMarker.h

@@ -0,0 +1,60 @@
+#ifndef Magnum_DebugMarker_h
+#define Magnum_DebugMarker_h
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+/** @file
+ * @brief Class Magnum::DebugMarker
+ */
+
+#include <string>
+
+#include "Magnum.h"
+
+#include "magnumVisibility.h"
+
+namespace Magnum {
+
+/**
+@brief Debug marker
+
+Allows putting debug marker into OpenGL command stream for use with various
+debuggers, such as ApiTrace or gDEBugger.
+@requires_extension %Extension @extension{GREMEDY,string_marker}. If not
+    available, this class does nothing.
+@requires_es_extension %Extension @es_extension{EXT,debug_marker}. If not
+    available, this class does nothing.
+*/
+class MAGNUM_EXPORT DebugMarker {
+    friend class Context;
+
+    public:
+        /** @brief Put string mark into OpenGL command stream */
+        inline static void mark(const std::string& string) {
+            markImplementation(string);
+        }
+
+    private:
+        static void MAGNUM_LOCAL initializeContextBasedFunctionality(Context* context);
+
+        typedef void(*MarkImplementation)(const std::string&);
+        static MAGNUM_LOCAL void markImplementationDefault(const std::string& string);
+        static MAGNUM_LOCAL void markImplementationDebugger(const std::string& string);
+        static MarkImplementation markImplementation;
+};
+
+}
+
+#endif

src/Extensions.h

@@ -33,6 +33,8 @@ and string(), but these structs are better suited for compile-time decisions
 rather than Extension instances. See Context::isExtensionSupported() for
 example usage.
 
+@see MAGNUM_ASSERT_EXTENSION_SUPPORTED()
+
 @todo Manual indices for extensions, this has gaps
 @todo Unhide ES2_compatibility, ES3_compatibility on ES
 @todo Add ES and GL 4.3 extensions
@@ -48,6 +50,9 @@ namespace Extensions {
         constexpr static Version coreVersion() { return Version::_coreVersion; } \
         constexpr static const char* string() { return #prefix "_" #vendor "_" #extension; } \
     };
+
+/* IMPORTANT: don't forget to add new extensions also in Context.cpp */
+
 namespace GL {
     #line 1
     namespace AMD {
@@ -133,6 +138,8 @@ namespace GL {
         _extension(GL,EXT,transform_feedback,           GL210, GL300) // #352
         _extension(GL,EXT,direct_state_access,          GL210,  None) // #353
         _extension(GL,EXT,texture_snorm,                GL300, GL310) // #365
+    } namespace GREMEDY {
+        _extension(GL,GREMEDY,string_marker,            GL210,  None) // #311
     } namespace INTEL {
         /* INTEL_map_texture not supported */                         // #429
     } namespace NV {

src/Framebuffer.h

@@ -165,7 +165,7 @@ class MAGNUM_EXPORT Framebuffer {
          * Initial value is `{0.0f, 0.0f, 0.0f, 1.0f}`.
          * @see @fn_gl{ClearColor}
          */
-        inline static void setClearColor(const Color4<GLfloat>& color) {
+        inline static void setClearColor(const Color4<>& color) {
             glClearColor(color.r(), color.g(), color.b(), color.a());
         }
 
@@ -631,7 +631,7 @@ class MAGNUM_EXPORT Framebuffer {
          * @attention You have to enable blending with setFeature() first.
          * @see @fn_gl{BlendColor}
          */
-        inline static void setBlendColor(const Color4<GLfloat>& color) {
+        inline static void setBlendColor(const Color4<>& color) {
             glBlendColor(color.r(), color.g(), color.b(), color.a());
         }
 

src/Magnum.h

@@ -114,8 +114,8 @@ typedef BufferedImage<3> BufferedImage3D;
 class BufferedTexture;
 #endif
 
-template<class> class Color3;
+template<class = GLfloat> class Color3;
-template<class> class Color4;
+template<class = GLfloat> class Color4;
 
 #ifndef CORRADE_GCC45_COMPATIBILITY
 enum class Version: GLint;

src/Mesh.h

@@ -83,7 +83,7 @@ component ordering (e.g. directly from @ref Trade::TgaImporter "TGA file"):
 @code
 class MyShader: public AbstractShaderProgram {
     public:
-        typedef Attribute<1, Color4<GLfloat>> Color;
+        typedef Attribute<1, Color4<>> Color;
 
     // ...
 };

src/Physics/AbstractShape.h

@@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT AbstractShape {
          * Applies transformation to user-defined shape properties and caches
          * them for later usage in collision detection.
          */
-        virtual void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) = 0;
+        virtual void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) = 0;
 
         /**
          * @brief Detect collision with other shape

src/Physics/AxisAlignedBox.cpp

@@ -20,8 +20,8 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
     _transformedSize = transformation.rotationScaling()*_size;
 }
 

src/Physics/AxisAlignedBox.h

@@ -34,44 +34,44 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT AxisAlignedBox: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline AxisAlignedBox(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, const typename DimensionTraits<dimensions, GLfloat>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
+        inline AxisAlignedBox(const typename DimensionTraits<dimensions>::VectorType& position, const typename DimensionTraits<dimensions>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::AxisAlignedBox;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
         /** @brief Size */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType size() const { return _size; }
+        inline typename DimensionTraits<dimensions>::VectorType size() const { return _size; }
 
         /** @brief Set size */
-        inline void setSize(const typename DimensionTraits<dimensions, GLfloat>::VectorType& size) {
+        inline void setSize(const typename DimensionTraits<dimensions>::VectorType& size) {
             _size = size;
         }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
         /** @brief Transformed size */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedSize() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedSize() const {
             return _transformedSize;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _position, _transformedPosition,
+        typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition,
             _size, _transformedSize;
 };
 

src/Physics/Box.cpp

@@ -20,7 +20,7 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
     _transformedTransformation = (transformation*_transformation);
 }
 

src/Physics/Box.h

@@ -36,31 +36,31 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Box: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Box(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
+        inline Box(const typename DimensionTraits<dimensions>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Box;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Transformation */
-        inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformation() const {
+        inline typename DimensionTraits<dimensions>::MatrixType transformation() const {
             return _transformation;
         }
 
         /** @brief Set transformation */
-        inline void setTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+        inline void setTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
             _transformation = transformation;
         }
 
         /** @brief Transformed transformation */
-        inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformedTransformation() const {
+        inline typename DimensionTraits<dimensions>::MatrixType transformedTransformation() const {
             return _transformedTransformation;
         }
 
     private:
-        Math::Matrix<dimensions+1, GLfloat> _transformation,
+        typename DimensionTraits<dimensions>::MatrixType _transformation,
             _transformedTransformation;
 };
 

src/Physics/Capsule.cpp

@@ -27,10 +27,10 @@ using namespace Magnum::Math::Geometry;
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
+    _transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
-    _transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
+    _transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
-    float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions, GLfloat>::VectorType(1/Math::Constants<float>::sqrt3())).length();
+    float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions>::VectorType(1/Math::Constants<float>::sqrt3())).length();
     _transformedRadius = scaling*_radius;
 }
 

src/Physics/Capsule.h

@@ -37,33 +37,33 @@ applying transformation, the scale factor is averaged from all axes.
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Capsule(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
+        inline Capsule(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Capsule;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 
         /** @brief Start point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
+        inline typename DimensionTraits<dimensions>::VectorType a() const {
             return _a;
         }
 
         /** @brief End point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
+        inline typename DimensionTraits<dimensions>::VectorType b() const {
             return _a;
         }
 
         /** @brief Set start point */
-        inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
+        inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
             _a = a;
         }
 
         /** @brief Set end point */
-        inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
+        inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
             _b = b;
         }
 
@@ -74,12 +74,12 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
         inline void setRadius(float radius) { _radius = radius; }
 
         /** @brief Transformed first point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
             return _transformedA;
         }
 
         /** @brief Transformed second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
             return _transformedB;
         }
 
@@ -95,7 +95,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
         bool operator%(const Sphere<dimensions>& other) const;
 
     private:
-        Math::Vector<dimensions, GLfloat> _a, _transformedA,
+        typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
             _b, _transformedB;
         float _radius, _transformedRadius;
 };

src/Physics/DebugDrawResourceManager.h

@@ -37,7 +37,7 @@ namespace Magnum {
 #ifndef DOXYGEN_GENERATING_OUTPUT
 namespace Physics { namespace Implementation {
     struct Options {
-        Color3<GLfloat> color;
+        Color3<> color;
     };
     template<std::uint8_t> class DebugRenderer;
 }}
@@ -86,7 +86,7 @@ class PHYSICS_EXPORT DebugDrawResourceManager: public ResourceManager<AbstractSh
         #ifdef DOXYGEN_GENERATING_OUTPUT
         /** @brief %Options */
         struct Options {
-            Color3<GLfloat> color; /**< @brief Color */
+            Color3<> color; /**< @brief Color */
         };
         #else
         typedef Implementation::Options Options;

src/Physics/Implementation/AbstractDebugRenderer.h

@@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractDebugRenderer {
 
         virtual ~AbstractDebugRenderer();
 
-        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
+        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
 
     protected:
         Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;

src/Physics/Implementation/AbstractShapeRenderer.h

@@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractShapeRenderer {
 
         virtual ~AbstractShapeRenderer();
 
-        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
+        virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
 
     protected:
         Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;

src/Physics/Implementation/AxisAlignedBoxRenderer.cpp

@@ -22,7 +22,7 @@
 
 namespace Magnum { namespace Physics { namespace Implementation {
 
-template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
+template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     typename DimensionTraits<dimensions>::MatrixType transformation =
         DimensionTraits<dimensions>::MatrixType::translation(axisAlignedBox.transformedPosition())*
         DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedSize());

src/Physics/Implementation/BoxRenderer.cpp

@@ -22,7 +22,7 @@
 
 namespace Magnum { namespace Physics { namespace Implementation {
 
-template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
+template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     this->shader->setTransformationProjection(camera->projectionMatrix()*camera->cameraMatrix()*box.transformedTransformation())
         ->setColor(options->color)
         ->use();

src/Physics/Implementation/BoxRenderer.h

@@ -27,7 +27,7 @@ template<std::uint8_t dimensions> class BoxRenderer: public AbstractBoxRenderer<
     public:
         inline BoxRenderer(Box<dimensions>& box): box(box) {}
 
-        void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override;
+        void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions>* camera) override;
 
     private:
         Box<dimensions>& box;

src/Physics/Implementation/DebugRenderer.h

@@ -45,7 +45,7 @@ template<std::uint8_t dimensions> class DebugRenderer: public SceneGraph::Drawab
             renderers.push_back(renderer);
         }
 
-        inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override {
+        inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) override {
             for(auto it = renderers.begin(); it != renderers.end(); ++it)
                 (*it)->draw(options, transformationMatrix, camera);
         }

src/Physics/Line.cpp

@@ -20,9 +20,9 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
+    _transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
-    _transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
+    _transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
 }
 
 /* Explicitly instantiate the templates */

src/Physics/Line.h

@@ -35,46 +35,46 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Line: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Line(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
+        inline Line(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Line;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief First point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
+        inline typename DimensionTraits<dimensions>::VectorType a() const {
             return _a;
         }
 
         /** @brief Second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
+        inline typename DimensionTraits<dimensions>::VectorType b() const {
             return _a;
         }
 
         /** @brief Set first point */
-        inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
+        inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
             _a = a;
         }
 
         /** @brief Set second point */
-        inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
+        inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
             _b = b;
         }
 
         /** @brief Transformed first point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
             return _transformedA;
         }
 
         /** @brief Transformed second point */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
             return _transformedB;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _a, _transformedA,
+        typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
             _b, _transformedB;
 };
 

src/Physics/LineSegment.h

@@ -31,7 +31,7 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class LineSegment: public Line<dimensions> {
     public:
         /** @brief Constructor */
-        inline LineSegment(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): Line<dimensions>(a, b) {}
+        inline LineSegment(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): Line<dimensions>(a, b) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::LineSegment;

src/Physics/ObjectShape.cpp

@@ -36,7 +36,7 @@ template<uint8_t dimensions> void ObjectShape<dimensions>::markDirty() {
     group()->setDirty();
 }
 
-template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& absoluteTransformation) {
+template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformation) {
     if(_shape) _shape->applyTransformation(absoluteTransformation);
 }
 

src/Physics/Plane.h

@@ -39,7 +39,7 @@ class PHYSICS_EXPORT Plane: public AbstractShape<3> {
         void applyTransformation(const Matrix4& transformation) override;
         bool collides(const AbstractShape<3>* other) const override;
         #else
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
         bool collides(const AbstractShape* other) const override;
         #endif
 

src/Physics/Point.cpp

@@ -20,8 +20,8 @@
 
 namespace Magnum { namespace Physics {
 
-template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
 }
 
 template class Point<2>;

src/Physics/Point.h

@@ -34,31 +34,31 @@ namespace Magnum { namespace Physics {
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Point: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Point(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position): _position(position), _transformedPosition(position) {}
+        inline Point(const typename DimensionTraits<dimensions>::VectorType& position): _position(position), _transformedPosition(position) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Point;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
     private:
-        Math::Vector<dimensions, GLfloat> _position, _transformedPosition;
+        typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition;
 };
 
 /** @brief Two-dimensional point */

src/Physics/ShapeGroup.cpp

@@ -43,7 +43,7 @@ template<std::uint8_t dimensions> ShapeGroup<dimensions>& ShapeGroup<dimensions>
     return *this;
 }
 
-template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
     if(a) a->applyTransformation(transformation);
     if(b) b->applyTransformation(transformation);
 }

src/Physics/ShapeGroup.h

@@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT ShapeGroup: public Abstra
             return AbstractShape<dimensions>::Type::ShapeGroup;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 

src/Physics/Sphere.cpp

@@ -28,7 +28,7 @@ using namespace Magnum::Math::Geometry;
 namespace Magnum { namespace Physics {
 
 namespace {
-    template<std::uint8_t dimensions> static typename DimensionTraits<dimensions, GLfloat>::VectorType unitVector();
+    template<std::uint8_t dimensions> static typename DimensionTraits<dimensions>::VectorType unitVector();
 
     template<> inline Vector2 unitVector<2>() {
         return Vector2(1/Math::Constants<float>::sqrt2());
@@ -39,8 +39,8 @@ namespace {
     }
 }
 
-template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
+template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
-    _transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
+    _transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
     float scaling = (transformation.rotationScaling()*unitVector<dimensions>()).length();
     _transformedRadius = scaling*_radius;
 }

src/Physics/Sphere.h

@@ -37,23 +37,23 @@ applying transformation, the scale factor is averaged from all axes.
 template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractShape<dimensions> {
     public:
         /** @brief Constructor */
-        inline Sphere(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
+        inline Sphere(const typename DimensionTraits<dimensions>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
 
         inline typename AbstractShape<dimensions>::Type type() const override {
             return AbstractShape<dimensions>::Type::Sphere;
         }
 
-        void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
+        void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
 
         bool collides(const AbstractShape<dimensions>* other) const override;
 
         /** @brief Position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
+        inline typename DimensionTraits<dimensions>::VectorType position() const {
             return _position;
         }
 
         /** @brief Set position */
-        inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
+        inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
             _position = position;
         }
 
@@ -64,7 +64,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
         inline void setRadius(float radius) { _radius = radius; }
 
         /** @brief Transformed position */
-        inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
+        inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
             return _transformedPosition;
         }
 
@@ -86,7 +86,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
         bool operator%(const Sphere<dimensions>& other) const;
 
     private:
-        Math::Vector<dimensions, GLfloat> _position,
+        typename DimensionTraits<dimensions>::VectorType _position,
             _transformedPosition;
         float _radius, _transformedRadius;
 };

src/Platform/Sdl2Application.cpp

@@ -20,16 +20,30 @@
 
 namespace Magnum { namespace Platform {
 
+namespace {
+
+/*
+ * Fix up the modifiers -- we want >= operator to work properly on Shift,
+ * Ctrl, Alt, but SDL generates different event for left / right keys, thus
+ * (modifiers >= Shift) would pass only if both left and right were pressed,
+ * which is usually not what the developers wants.
+ */
+Sdl2Application::InputEvent::Modifiers fixedModifiers(Uint16 mod) {
+    Sdl2Application::InputEvent::Modifiers modifiers(static_cast<Sdl2Application::InputEvent::Modifier>(mod));
+    if(modifiers & Sdl2Application::InputEvent::Modifier::Shift) modifiers |= Sdl2Application::InputEvent::Modifier::Shift;
+    if(modifiers & Sdl2Application::InputEvent::Modifier::Ctrl) modifiers |= Sdl2Application::InputEvent::Modifier::Ctrl;
+    if(modifiers & Sdl2Application::InputEvent::Modifier::Alt) modifiers |= Sdl2Application::InputEvent::Modifier::Alt;
+    return modifiers;
+}
+
+}
+
 Sdl2Application::Sdl2Application(int, char**, const std::string& name, const Math::Vector2<GLsizei>& size): _redraw(true) {
     if(SDL_Init(SDL_INIT_VIDEO) < 0) {
         Error() << "Cannot initialize SDL.";
         exit(1);
     }
 
-    /* Request OpenGL 3.2 */
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
-
     /* Enable double buffering and 24bt depth buffer */
     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
     SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
@@ -85,20 +99,7 @@ int Sdl2Application::exec() {
 
                 case SDL_KEYDOWN:
                 case SDL_KEYUP: {
-                    /*
+                    KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), fixedModifiers(event.key.keysym.mod));
-                     * Fix up the modifiers -- we want >= operator to work
-                     * properly on Shift, Ctrl, Alt, but SDL generates
-                     * different event for left / right keys, thus
-                     * (modifiers >= Shift) would pass only if both left and
-                     * right were pressed, which is usually not what the
-                     * developers wants.
-                     */
-                    InputEvent::Modifiers modifiers(static_cast<InputEvent::Modifier>(event.key.keysym.mod));
-                    if(modifiers & InputEvent::Modifier::Shift) modifiers |= InputEvent::Modifier::Shift;
-                    if(modifiers & InputEvent::Modifier::Ctrl) modifiers |= InputEvent::Modifier::Ctrl;
-                    if(modifiers & InputEvent::Modifier::Alt) modifiers |= InputEvent::Modifier::Alt;
-
-                    KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), modifiers);
                     event.type == SDL_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
                     break;
                 }
@@ -143,13 +144,13 @@ void Sdl2Application::setMouseLocked(bool enabled) {
 Sdl2Application::InputEvent::Modifiers Sdl2Application::MouseEvent::modifiers() {
     if(modifiersLoaded) return _modifiers;
     modifiersLoaded = true;
-    return _modifiers = static_cast<Modifier>(SDL_GetModState());
+    return _modifiers = fixedModifiers(SDL_GetModState());
 }
 
 Sdl2Application::InputEvent::Modifiers Sdl2Application::MouseMoveEvent::modifiers() {
     if(modifiersLoaded) return _modifiers;
     modifiersLoaded = true;
-    return _modifiers = static_cast<Modifier>(SDL_GetModState());
+    return _modifiers = fixedModifiers(SDL_GetModState());
 }
 
 }}

src/Platform/Sdl2Application.h

@@ -37,8 +37,9 @@ namespace Platform {
 /** @nosubgrouping
 @brief SDL2 application
 
-Application using [Simple DirectMedia Layer](www.libsdl.org/). Supports
+Application using [Simple DirectMedia Layer](www.libsdl.org/). Centered
-keyboard and mouse handling.
+non-resizable window with double-buffered OpenGL context and 24bit depth
+buffer. Supports keyboard and mouse handling.
 
 @section Sdl2Application-usage Usage
 
@@ -65,9 +66,6 @@ class Sdl2Application {
          * @param argv      Arguments of `main()` function
          * @param title     Window title
          * @param size      Window size
-         *
-         * Creates centered non-resizable window with double-buffered
-         * OpenGL 3.2 context with 24bit depth buffer.
          */
         Sdl2Application(int argc, char** argv, const std::string& title = "Magnum SDL2 application", const Math::Vector2<GLsizei>& size = Math::Vector2<GLsizei>(800, 600));
 

src/Primitives/Cube.cpp

@@ -21,30 +21,91 @@ using namespace std;
 
 namespace Magnum { namespace Primitives {
 
-Cube::Cube(): MeshData3D("", Mesh::Primitive::Triangles, new vector<uint32_t>{
+Cube::Cube(): MeshData3D("", Mesh::Primitive::Triangles, nullptr, {new vector<Point3D>{
-    0, 2, 1,
+    {-1.0f, -1.0f,  1.0f},
-    2, 3, 1,
+    { 1.0f, -1.0f,  1.0f},
-    1, 3, 5,
+    { 1.0f,  1.0f,  1.0f}, /* +Z */
-    3, 7, 5,
+    {-1.0f, -1.0f,  1.0f},
-    5, 7, 4,
+    { 1.0f,  1.0f,  1.0f},
-    7, 6, 4,
+    {-1.0f,  1.0f,  1.0f},
-    4, 6, 0,
+
-    6, 2, 0,
+    { 1.0f, -1.0f,  1.0f},
-    2, 7, 3,
+    { 1.0f, -1.0f, -1.0f},
-    2, 6, 7,
+    { 1.0f,  1.0f, -1.0f}, /* +X */
-    4, 1, 5,
+    { 1.0f, -1.0f,  1.0f},
-    4, 0, 1
+    { 1.0f,  1.0f, -1.0f},
-}, {new vector<Point3D>}, {new vector<Vector3>{
+    { 1.0f,  1.0f,  1.0f},
+
+    {-1.0f,  1.0f,  1.0f},
+    { 1.0f,  1.0f,  1.0f},
+    { 1.0f,  1.0f, -1.0f}, /* +Y */
+    {-1.0f,  1.0f,  1.0f},
+    { 1.0f,  1.0f, -1.0f},
+    {-1.0f,  1.0f, -1.0f},
+
+    { 1.0f, -1.0f, -1.0f},
     {-1.0f, -1.0f, -1.0f},
+    {-1.0f,  1.0f, -1.0f}, /* -Z */
     { 1.0f, -1.0f, -1.0f},
     {-1.0f,  1.0f, -1.0f},
     { 1.0f,  1.0f, -1.0f},
-    {-1.0f, -1.0f,  1.0f},
+
+    {-1.0f, -1.0f, -1.0f},
+    { 1.0f, -1.0f, -1.0f},
+    { 1.0f, -1.0f,  1.0f}, /* -Y */
+    {-1.0f, -1.0f, -1.0f},
     { 1.0f, -1.0f,  1.0f},
+    {-1.0f, -1.0f,  1.0f},
+
+    {-1.0f, -1.0f, -1.0f},
+    {-1.0f, -1.0f,  1.0f},
+    {-1.0f,  1.0f,  1.0f}, /* -X */
+    {-1.0f, -1.0f, -1.0f},
     {-1.0f,  1.0f,  1.0f},
-    { 1.0f,  1.0f,  1.0f}
+    {-1.0f,  1.0f, -1.0f}
+}}, {new vector<Vector3>{
+    { 0.0f,  0.0f,  1.0f},
+    { 0.0f,  0.0f,  1.0f},
+    { 0.0f,  0.0f,  1.0f}, /* +Z */
+    { 0.0f,  0.0f,  1.0f},
+    { 0.0f,  0.0f,  1.0f},
+    { 0.0f,  0.0f,  1.0f},
+
+    { 1.0f,  0.0f,  0.0f},
+    { 1.0f,  0.0f,  0.0f},
+    { 1.0f,  0.0f,  0.0f}, /* +X */
+    { 1.0f,  0.0f,  0.0f},
+    { 1.0f,  0.0f,  0.0f},
+    { 1.0f,  0.0f,  0.0f},
+
+    { 0.0f,  1.0f,  0.0f},
+    { 0.0f,  1.0f,  0.0f},
+    { 0.0f,  1.0f,  0.0f}, /* +Y */
+    { 0.0f,  1.0f,  0.0f},
+    { 0.0f,  1.0f,  0.0f},
+    { 0.0f,  1.0f,  0.0f},
+
+    { 0.0f,  0.0f, -1.0f},
+    { 0.0f,  0.0f, -1.0f},
+    { 0.0f,  0.0f, -1.0f}, /* -Z */
+    { 0.0f,  0.0f, -1.0f},
+    { 0.0f,  0.0f, -1.0f},
+    { 0.0f,  0.0f, -1.0f},
+
+    { 0.0f, -1.0f,  0.0f},
+    { 0.0f, -1.0f,  0.0f},
+    { 0.0f, -1.0f,  0.0f}, /* -Y */
+    { 0.0f, -1.0f,  0.0f},
+    { 0.0f, -1.0f,  0.0f},
+    { 0.0f, -1.0f,  0.0f},
+
+    {-1.0f,  0.0f,  0.0f},
+    {-1.0f,  0.0f,  0.0f},
+    {-1.0f,  0.0f,  0.0f}, /* -X */
+    {-1.0f,  0.0f,  0.0f},
+    {-1.0f,  0.0f,  0.0f},
+    {-1.0f,  0.0f,  0.0f}
 }}, {}) {
-    positions(0)->assign(normals(0)->begin(), normals(0)->end());
 }
 
 }}

src/Primitives/Cube.h

@@ -26,8 +26,7 @@ namespace Magnum { namespace Primitives {
 /**
 @brief 3D cube primitive
 
-Indexed triangle mesh with smooth normals.
+2x2x2 cube. Non-indexed triangle mesh with flat normals.
-@todo Does anyone EVER want smooth normals on a cube?!
 */
 class Cube: public Trade::MeshData3D {
     public:

src/SceneGraph/Test/ObjectTest.cpp

@@ -27,12 +27,12 @@ CORRADE_TEST_MAIN(Magnum::SceneGraph::Test::ObjectTest)
 
 namespace Magnum { namespace SceneGraph { namespace Test {
 
-typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<GLfloat>> Object3D;
+typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;
-typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<GLfloat>> Scene3D;
+typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D;
 
-class CachingObject: public Object3D, AbstractFeature<3, GLfloat> {
+class CachingObject: public Object3D, AbstractFeature<3> {
     public:
-        inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3, GLfloat>(this) {
+        inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3>(this) {
             setCachedTransformations(CachedTransformation::Absolute);
         }
 
@@ -189,9 +189,9 @@ void ObjectTest::transformations() {
 void ObjectTest::setClean() {
     Scene3D scene;
 
-    class CachingFeature: public AbstractFeature<3, GLfloat> {
+    class CachingFeature: public AbstractFeature<3> {
         public:
-            CachingFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
+            CachingFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
                 setCachedTransformations(CachedTransformation::Absolute);
             }
 
@@ -202,9 +202,9 @@ void ObjectTest::setClean() {
             }
     };
 
-    class CachingInvertedFeature: public AbstractFeature<3, GLfloat> {
+    class CachingInvertedFeature: public AbstractFeature<3> {
         public:
-            CachingInvertedFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
+            CachingInvertedFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
                 setCachedTransformations(CachedTransformation::InvertedAbsolute);
             }
 

src/Shaders/FlatShader.h

@@ -38,7 +38,7 @@ Draws whole mesh with one color.
 template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
 
         FlatShader();
 
@@ -46,7 +46,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public Abstra
          * @brief Set transformation and projection matrix
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
+        FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionUniform, matrix);
             return this;
         }
@@ -55,7 +55,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public Abstra
          * @brief Set color
          * @return Pointer to self (for method chaining)
          */
-        FlatShader<dimensions>* setColor(const Color3<GLfloat>& color) {
+        FlatShader<dimensions>* setColor(const Color3<>& color) {
             setUniform(colorUniform, color);
             return this;
         }

src/Shaders/PhongShader.h

@@ -46,7 +46,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(0.0f, 0.0f, 0.0f)`.
          */
-        inline PhongShader* setAmbientColor(const Color3<GLfloat>& color) {
+        inline PhongShader* setAmbientColor(const Color3<>& color) {
             setUniform(ambientColorUniform, color);
             return this;
         }
@@ -55,7 +55,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          * @brief Set diffuse color
          * @return Pointer to self (for method chaining)
          */
-        inline PhongShader* setDiffuseColor(const Color3<GLfloat>& color) {
+        inline PhongShader* setDiffuseColor(const Color3<>& color) {
             setUniform(diffuseColorUniform, color);
             return this;
         }
@@ -66,7 +66,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(1.0f, 1.0f, 1.0f)`.
          */
-        inline PhongShader* setSpecularColor(const Color3<GLfloat>& color) {
+        inline PhongShader* setSpecularColor(const Color3<>& color) {
             setUniform(specularColorUniform, color);
             return this;
         }
@@ -117,7 +117,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
          *
          * If not set, default value is `(1.0f, 1.0f, 1.0f)`.
          */
-        inline PhongShader* setLightColor(const Color3<GLfloat>& color) {
+        inline PhongShader* setLightColor(const Color3<>& color) {
             setUniform(lightColorUniform, color);
             return this;
         }

src/Shaders/VertexColorShader.h

@@ -38,10 +38,10 @@ Draws vertex-colored mesh.
 template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram {
     public:
         /** @brief Vertex position */
-        typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
+        typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
 
         /** @brief Vertex color */
-        typedef Attribute<1, Math::Point2D<GLfloat>> Color;
+        typedef Attribute<1, Color3<>> Color;
 
         VertexColorShader();
 
@@ -49,7 +49,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public
          * @brief Set transformation and projection
          * @return Pointer to self (for method chaining)
          */
-        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
+        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
             setUniform(transformationProjectionUniform, matrix);
             return this;
         }

src/Texture.h

@@ -203,7 +203,7 @@ template<std::uint8_t dimensions> class Texture: public AbstractTexture {
             return this;
         }
         #ifndef MAGNUM_TARGET_GLES
-        inline Texture<Dimensions>* setBorderColor(const Color4<GLfloat>& color) {
+        inline Texture<Dimensions>* setBorderColor(const Color4<>& color) {
             AbstractTexture::setBorderColor(color);
             return this;
         }