Shaders: portable vertex color shader (currently 2D only).

src/Shaders/CMakeLists.txt

@@ -1,14 +1,17 @@
 corrade_add_resource(MagnumShaders_RCS MagnumShaders
     FlatShader2D.vert FlatShader2D.frag
     PhongShader.vert PhongShader.frag
+    VertexColorShader2D.vert VertexColorShader2D.frag
     compatibility.glsl)
 set(MagnumShaders_SRCS
     FlatShader.cpp
     PhongShader.cpp
+    VertexColorShader.cpp
     ${MagnumShaders_RCS})
 set(MagnumShaders_HEADERS
     FlatShader.h
     PhongShader.h
+    VertexColorShader.h
 
     magnumShadersVisibility.h)
 

src/Shaders/VertexColorShader.cpp

@@ -0,0 +1,75 @@
+/*
+    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 "VertexColorShader.h"
+
+#include <Utility/Resource.h>
+
+#include "Extensions.h"
+#include "Shader.h"
+
+namespace Magnum { namespace Shaders {
+
+namespace {
+    template<std::uint8_t dimensions> struct ShaderName {};
+
+    template<> struct ShaderName<2> {
+        constexpr static const char* vertex() { return "VertexColorShader2D.vert"; }
+        constexpr static const char* fragment() { return "VertexColorShader2D.frag"; }
+    };
+
+    template<> struct ShaderName<3> {
+        constexpr static const char* vertex() { return "VertexColorShader3D.vert"; }
+        constexpr static const char* fragment() { return "VertexColorShader3D.frag"; }
+    };
+}
+
+template<std::uint8_t dimensions> VertexColorShader<dimensions>::VertexColorShader() {
+    Corrade::Utility::Resource rs("MagnumShaders");
+
+    #ifndef MAGNUM_TARGET_GLES
+    Version v = Context::current()->supportedVersion({Version::GL320, Version::GL210});
+    #else
+    Version v = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
+    #endif
+
+    Shader vertexShader(v, Shader::Type::Vertex);
+    vertexShader.addSource(rs.get("compatibility.glsl"));
+    vertexShader.addSource(rs.get(ShaderName<dimensions>::vertex()));
+    attachShader(vertexShader);
+
+    Shader fragmentShader(v, Shader::Type::Fragment);
+    fragmentShader.addSource(rs.get("compatibility.glsl"));
+    fragmentShader.addSource(rs.get(ShaderName<dimensions>::fragment()));
+    attachShader(fragmentShader);
+
+    #ifndef MAGNUM_TARGET_GLES
+    if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>()) {
+    #else
+    if(!Context::current()->isVersionSupported(Version::GLES300)) {
+    #endif
+        bindAttributeLocation(Position::Location, "position");
+        bindAttributeLocation(Color::Location, "color");
+    }
+
+    link();
+
+    transformationProjectionUniform = uniformLocation("transformationProjection");
+}
+
+template class VertexColorShader<2>;
+template class VertexColorShader<3>;
+
+}}

src/Shaders/VertexColorShader.h

@@ -0,0 +1,69 @@
+#ifndef Magnum_Shaders_VertexColorShader_h
+#define Magnum_Shaders_VertexColorShader_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::Shaders::VertexColorShader
+ */
+
+#include "Math/Matrix3.h"
+#include "Math/Matrix4.h"
+#include "AbstractShaderProgram.h"
+#include "Color.h"
+#include "DimensionTraits.h"
+
+#include "magnumShadersVisibility.h"
+
+namespace Magnum { namespace Shaders {
+
+/**
+@brief Vertex color shader
+
+Draws vertex-colored mesh.
+@see VertexColorShader2D, VertexColorShader3D
+*/
+template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram {
+    public:
+        /** @brief Vertex position */
+        typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
+
+        /** @brief Vertex color */
+        typedef Attribute<1, Math::Point2D<GLfloat>> Color;
+
+        VertexColorShader();
+
+        /**
+         * @brief Set transformation and projection
+         * @return Pointer to self (for method chaining)
+         */
+        inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
+            setUniform(transformationProjectionUniform, matrix);
+            return this;
+        }
+
+    private:
+        GLint transformationProjectionUniform;
+};
+
+/** @brief 2D vertex color shader */
+typedef VertexColorShader<2> VertexColorShader2D;
+
+/** @brief 3D vertex color shader */
+typedef VertexColorShader<3> VertexColorShader3D;
+
+}}
+
+#endif

src/Shaders/VertexColorShader2D.frag

@@ -0,0 +1,14 @@
+#ifndef NEW_GLSL
+#define in varying
+#define fragmentColor gl_FragColor
+#endif
+
+in lowp vec3 interpolatedColor;
+
+#ifdef NEW_GLSL
+out lowp vec4 fragmentColor;
+#endif
+
+void main() {
+    fragmentColor = vec4(interpolatedColor, 1.0);
+}

src/Shaders/VertexColorShader2D.vert

@@ -0,0 +1,21 @@
+#ifndef NEW_GLSL
+#define in attribute
+#define out varying
+#endif
+
+uniform highp mat3 transformationProjection;
+
+#ifdef EXPLICIT_ATTRIB_LOCATION
+layout(location = 0) in highp vec3 position;
+layout(location = 1) in lowp vec3 color;
+#else
+in highp vec3 position;
+in lowp vec3 color;
+#endif
+
+out lowp vec3 interpolatedColor;
+
+void main() {
+    gl_Position.xywz = vec4(transformationProjection*position, 0.0);
+    interpolatedColor = color;
+}