Async GL shader compilation

src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp

@@ -27,6 +27,7 @@
 #include <Corrade/Containers/Reference.h>
 #include <Corrade/Containers/StringStl.h> /** @todo remove when Shader is <string>-free */
 #include <Corrade/TestSuite/Compare/Container.h>
+#include <Corrade/TestSuite/Compare/String.h>
 #include <Corrade/Utility/DebugStl.h>
 #include <Corrade/Utility/Resource.h>
 
@@ -68,8 +69,11 @@ struct AbstractShaderProgramGLTest: OpenGLTester {
     #ifndef MAGNUM_TARGET_GLES
     void createMultipleOutputsIndexed();
     #endif
+    void createAsync();
 
     void linkFailure();
+    void linkFailureAsync();
+
     void uniformNotFound();
 
     void uniform();
@@ -103,12 +107,14 @@ AbstractShaderProgramGLTest::AbstractShaderProgramGLTest() {
               #endif
 
               &AbstractShaderProgramGLTest::create,
+              &AbstractShaderProgramGLTest::createAsync,
               &AbstractShaderProgramGLTest::createMultipleOutputs,
               #ifndef MAGNUM_TARGET_GLES
               &AbstractShaderProgramGLTest::createMultipleOutputsIndexed,
               #endif
 
               &AbstractShaderProgramGLTest::linkFailure,
+              &AbstractShaderProgramGLTest::linkFailureAsync,
               &AbstractShaderProgramGLTest::uniformNotFound,
 
               &AbstractShaderProgramGLTest::uniform,
@@ -205,6 +211,8 @@ struct MyPublicShader: AbstractShaderProgram {
     using AbstractShaderProgram::bindFragmentDataLocation;
     #endif
     using AbstractShaderProgram::link;
+    using AbstractShaderProgram::submitLink;
+    using AbstractShaderProgram::checkLink;
     using AbstractShaderProgram::uniformLocation;
     #ifndef MAGNUM_TARGET_GLES2
     using AbstractShaderProgram::uniformBlockIndex;
@@ -257,6 +265,74 @@ void AbstractShaderProgramGLTest::create() {
 
     MAGNUM_VERIFY_NO_GL_ERROR();
     CORRADE_VERIFY(linked);
+    // TODO: decide on this.
+    //CORRADE_VERIFY(program.isLinkFinished());
+    {
+        #if defined(CORRADE_TARGET_APPLE) && !defined(MAGNUM_TARGET_GLES)
+        CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
+        #endif
+        CORRADE_VERIFY(valid);
+    }
+
+    const Int matrixUniform = program.uniformLocation("matrix");
+    const Int multiplierUniform = program.uniformLocation("multiplier");
+    const Int colorUniform = program.uniformLocation("color");
+    const Int additionsUniform = program.uniformLocation("additions");
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+    CORRADE_VERIFY(matrixUniform >= 0);
+    CORRADE_VERIFY(multiplierUniform >= 0);
+    CORRADE_VERIFY(colorUniform >= 0);
+    CORRADE_VERIFY(additionsUniform >= 0);
+}
+
+void AbstractShaderProgramGLTest::createAsync() {
+    Utility::Resource rs("AbstractShaderProgramGLTest");
+
+    Shader vert(
+        #ifndef MAGNUM_TARGET_GLES
+        #ifndef CORRADE_TARGET_APPLE
+        Version::GL210
+        #else
+        Version::GL310
+        #endif
+        #else
+        Version::GLES200
+        #endif
+        , Shader::Type::Vertex);
+    vert.addSource(rs.getString("MyShader.vert"));
+    const bool vertCompiled = vert.compile();
+
+    Shader frag(
+        #ifndef MAGNUM_TARGET_GLES
+        #ifndef CORRADE_TARGET_APPLE
+        Version::GL210
+        #else
+        Version::GL310
+        #endif
+        #else
+        Version::GLES200
+        #endif
+        , Shader::Type::Fragment);
+    frag.addSource(rs.getString("MyShader.frag"));
+    const bool fragCompiled = frag.compile();
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+    CORRADE_VERIFY(vertCompiled);
+    CORRADE_VERIFY(fragCompiled);
+
+    MyPublicShader program;
+    program.attachShaders({vert, frag});
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
+
+    program.bindAttributeLocation(0, "position");
+    program.submitLink();
+
+    CORRADE_VERIFY(program.checkLink());
+    const bool valid = program.validate().first;
+
+    MAGNUM_VERIFY_NO_GL_ERROR();
     {
         #if defined(CORRADE_TARGET_APPLE) && !defined(MAGNUM_TARGET_GLES)
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -412,6 +488,39 @@ void AbstractShaderProgramGLTest::linkFailure() {
     CORRADE_VERIFY(!program.link());
 }
 
+void AbstractShaderProgramGLTest::linkFailureAsync() {
+    Shader shader(
+        #ifndef MAGNUM_TARGET_GLES
+        #ifndef CORRADE_TARGET_APPLE
+        Version::GL210
+        #else
+        Version::GL310
+        #endif
+        #else
+        Version::GLES200
+        #endif
+        , Shader::Type::Fragment);
+    shader.addSource("[fu] bleh error #:! stuff\n");
+
+    {
+        Error redirectError{nullptr};
+        CORRADE_VERIFY(!shader.compile());
+    }
+
+    MyPublicShader program;
+    program.attachShaders({shader});
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    program.submitLink();
+    CORRADE_VERIFY(out.str().empty());
+
+    CORRADE_VERIFY(!program.checkLink());
+    CORRADE_COMPARE_AS(out.str(), "GL::AbstractShaderProgram::link(): linking failed with the following message:",
+        TestSuite::Compare::StringHasPrefix);
+}
+
 void AbstractShaderProgramGLTest::uniformNotFound() {
     MyPublicShader program;
 

src/Magnum/GL/Test/ShaderGLTest.cpp

@@ -23,7 +23,9 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#include <sstream>
 #include <Corrade/Containers/StringStl.h> /** @todo remove once Shader is <string>-free */
+#include <Corrade/TestSuite/Compare/String.h>
 #include <Corrade/Utility/DebugStl.h>
 #include <Corrade/Utility/Path.h>
 
@@ -40,6 +42,18 @@
 
 namespace Magnum { namespace GL { namespace Test { namespace {
 
+constexpr GL::Version shaderCompileGLVersion =
+#ifndef MAGNUM_TARGET_GLES
+    #ifndef CORRADE_TARGET_APPLE
+    Version::GL210
+    #else
+    Version::GL310
+    #endif
+    ;
+#else
+Version::GLES200;
+#endif
+
 struct ShaderGLTest: OpenGLTester {
     explicit ShaderGLTest();
 
@@ -55,6 +69,9 @@ struct ShaderGLTest: OpenGLTester {
     void addSourceNoVersion();
     void addFile();
     void compile();
+    void compileFailure();
+    void compileAsync();
+    void compileAsyncFailure();
     void compileUtf8();
     void compileNoVersion();
 };
@@ -72,6 +89,9 @@ ShaderGLTest::ShaderGLTest() {
               &ShaderGLTest::addSourceNoVersion,
               &ShaderGLTest::addFile,
               &ShaderGLTest::compile,
+              &ShaderGLTest::compileFailure,
+              &ShaderGLTest::compileAsync,
+              &ShaderGLTest::compileAsyncFailure,
               &ShaderGLTest::compileUtf8,
               &ShaderGLTest::compileNoVersion});
 }
@@ -262,25 +282,41 @@ void ShaderGLTest::addFile() {
 }
 
 void ShaderGLTest::compile() {
-    #ifndef MAGNUM_TARGET_GLES
-    constexpr Version v =
-        #ifndef CORRADE_TARGET_APPLE
-        Version::GL210
-        #else
-        Version::GL310
-        #endif
-        ;
-    #else
-    constexpr Version v = Version::GLES200;
-    #endif
-
-    Shader shader(v, Shader::Type::Fragment);
+    Shader shader(shaderCompileGLVersion, Shader::Type::Fragment);
     shader.addSource("void main() {}\n");
+
     CORRADE_VERIFY(shader.compile());
+    CORRADE_VERIFY(shader.isCompileFinished());
+}
+
+void ShaderGLTest::compileFailure() {
+    Shader shader(shaderCompileGLVersion, Shader::Type::Fragment);
+    shader.addSource("[fu] bleh error #:! stuff\n");
+
+    CORRADE_VERIFY(!shader.compile());
+    CORRADE_VERIFY(shader.isCompileFinished());
+}
+
+void ShaderGLTest::compileAsync() {
+    Shader shader(shaderCompileGLVersion, Shader::Type::Fragment);
+    shader.addSource("void main() {}\n");
+    shader.submitCompile();
+
+    CORRADE_VERIFY(shader.checkCompile());
+}
+
+void ShaderGLTest::compileAsyncFailure() {
+    Shader shader(shaderCompileGLVersion, Shader::Type::Fragment);
+    shader.addSource("[fu] bleh error #:! stuff\n");
+    shader.submitCompile();
+
+    std::ostringstream out;
+    Error redirectError{&out};
+    CORRADE_VERIFY(out.str().empty());
 
-    Shader shader2(v, Shader::Type::Fragment);
-    shader2.addSource("[fu] bleh error #:! stuff\n");
-    CORRADE_VERIFY(!shader2.compile());
+    CORRADE_VERIFY(!shader.checkCompile());
+    CORRADE_COMPARE_AS(out.str(), "GL::Shader::compile(): compilation of fragment shader failed with the following message:",
+        TestSuite::Compare::StringHasPrefix);
 }
 
 void ShaderGLTest::compileUtf8() {

src/Magnum/Shaders/FlatGL.cpp

@@ -241,9 +241,9 @@ template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs)
 : FlatGL{static_cast<FlatGL&&>(std::move(cs))} {
     if (id() == 0) return;
 
+    CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
     CORRADE_INTERNAL_ASSERT_OUTPUT(cs._vert.checkCompile());
     CORRADE_INTERNAL_ASSERT_OUTPUT(cs._frag.checkCompile());
-    CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
 
     const GL::Context& context = GL::Context::current();
     const GL::Version version = cs._version;