GL: test setting at least some double uniforms.

Needs to be improved to cover all types, but at least something.

src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp

@@ -68,6 +68,12 @@ struct AbstractShaderProgramGLTest: OpenGLTester {
     void uniformVector();
     void uniformMatrix();
     void uniformArray();
+    #ifndef MAGNUM_TARGET_GLES
+    void uniformDouble();
+    void uniformDoubleVector();
+    void uniformDoubleMatrix();
+    void uniformDoubleArray();
+    #endif
 
     #ifndef MAGNUM_TARGET_GLES2
     void createUniformBlocks();
@@ -99,6 +105,12 @@ AbstractShaderProgramGLTest::AbstractShaderProgramGLTest() {
               &AbstractShaderProgramGLTest::uniformVector,
               &AbstractShaderProgramGLTest::uniformMatrix,
               &AbstractShaderProgramGLTest::uniformArray,
+              #ifndef MAGNUM_TARGET_GLES
+              &AbstractShaderProgramGLTest::uniformDouble,
+              &AbstractShaderProgramGLTest::uniformDoubleVector,
+              &AbstractShaderProgramGLTest::uniformDoubleMatrix,
+              &AbstractShaderProgramGLTest::uniformDoubleArray,
+              #endif
 
               #ifndef MAGNUM_TARGET_GLES2
               &AbstractShaderProgramGLTest::createUniformBlocks,
@@ -354,11 +366,15 @@ void AbstractShaderProgramGLTest::createMultipleOutputsIndexed() {
 
 void AbstractShaderProgramGLTest::linkFailure() {
     Shader shader(
+        #ifndef MAGNUM_TARGET_GLES
         #ifndef CORRADE_TARGET_APPLE
-        Version::GL300
+        Version::GL210
         #else
         Version::GL310
         #endif
+        #else
+        Version::GLES200
+        #endif
         , Shader::Type::Fragment);
     shader.addSource("[fu] bleh error #:! stuff\n");
 
@@ -525,6 +541,94 @@ void AbstractShaderProgramGLTest::uniformArray() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
+#ifndef MAGNUM_TARGET_GLES
+
+namespace {
+    struct MyDoubleShader: AbstractShaderProgram {
+        explicit MyDoubleShader();
+
+        using AbstractShaderProgram::setUniform;
+
+        Int matrixUniform,
+            multiplierUniform,
+            colorUniform,
+            additionsUniform;
+    };
+}
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+MyDoubleShader::MyDoubleShader() {
+    Utility::Resource rs("AbstractShaderProgramGLTest");
+
+    Shader vert(Version::GL400, Shader::Type::Vertex);
+    Shader frag(Version::GL400, Shader::Type::Fragment);
+    vert.addSource(rs.get("MyDoubleShader.vert"));
+    frag.addSource(rs.get("MyDoubleShader.frag"));
+
+    Shader::compile({vert, frag});
+
+    attachShaders({vert, frag});
+
+    bindAttributeLocation(0, "position");
+    link();
+
+    matrixUniform = uniformLocation("matrix");
+    multiplierUniform = uniformLocation("multiplier");
+    colorUniform = uniformLocation("color");
+    additionsUniform = uniformLocation("additions");
+}
+#endif
+
+void AbstractShaderProgramGLTest::uniformDouble() {
+    MyDoubleShader shader;
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+
+    shader.setUniform(shader.multiplierUniform, 0.35);
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+}
+
+void AbstractShaderProgramGLTest::uniformDoubleVector() {
+    MyDoubleShader shader;
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+
+    shader.setUniform(shader.colorUniform, Vector4d{0.3, 0.7, 1.0, 0.25});
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+}
+
+void AbstractShaderProgramGLTest::uniformDoubleMatrix() {
+    MyDoubleShader shader;
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+
+    shader.setUniform(shader.matrixUniform, Matrix4x4d::fromDiagonal({0.3, 0.7, 1.0f, 0.25}));
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+}
+
+void AbstractShaderProgramGLTest::uniformDoubleArray() {
+    MyDoubleShader shader;
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+
+    /* Testing also implicit conversion to base type (Vector4d[] -> Math::Vector<4, Double>[]) */
+    #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Causes ICE */
+    constexpr
+    #endif
+    const Vector4d values[] = {
+        {0.5, 1.0, 0.4, 0.0},
+        {0.0, 0.1, 0.7, 0.3},
+        {0.9, 0.8, 0.3, 0.1}
+    };
+    shader.setUniform(shader.additionsUniform, values);
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+}
+#endif
+
 #ifndef MAGNUM_TARGET_GLES2
 void AbstractShaderProgramGLTest::createUniformBlocks() {
     Utility::Resource rs("AbstractShaderProgramGLTest");

src/Magnum/GL/Test/AbstractShaderProgramGLTestFiles/MyDoubleShader.frag

@@ -0,0 +1,9 @@
+uniform double multiplier;
+uniform dvec4 color;
+uniform dvec4 additions[3];
+
+out vec4 fragColor;
+
+void main() {
+    fragColor = vec4(color*multiplier + additions[0] + additions[1] + additions[2]);
+}

src/Magnum/GL/Test/AbstractShaderProgramGLTestFiles/MyDoubleShader.vert

@@ -0,0 +1,7 @@
+in vec4 position;
+
+uniform dmat4 matrix;
+
+void main() {
+    gl_Position = mat4(matrix)*position;
+}

src/Magnum/GL/Test/AbstractShaderProgramGLTestFiles/resources.conf

@@ -9,6 +9,12 @@ filename=MyShader.vert
 [file]
 filename=MyShaderFragmentOutputs.frag
 
+[file]
+filename=MyDoubleShader.frag
+
+[file]
+filename=MyDoubleShader.vert
+
 [file]
 filename=UniformBlockShader.frag