1 files changed, 27 insertions, 51 deletions

diff --git a/src/mbgl/shader/shader.cpp b/src/mbgl/shader/shader.cpp
index e8deefc8ff..8216de5b4d 100644
--- a/src/mbgl/shader/shader.cpp
+++ b/src/mbgl/shader/shader.cpp
@@ -1,5 +1,5 @@
 #include <mbgl/shader/shader.hpp>
-#include <mbgl/platform/gl.hpp>
+#include <mbgl/gl/gl.hpp>
 #include <mbgl/util/stopwatch.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/platform/log.hpp>
@@ -11,94 +11,74 @@
 #include <fstream>
 #include <cstdio>
 
-using namespace mbgl;
+namespace mbgl {
 
-Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource)
+Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource, gl::GLObjectStore& glObjectStore)
     : name(name_)
-    , program(0)
 {
     util::stopwatch stopwatch("shader compilation", Event::Shader);
 
-    program = MBGL_CHECK_ERROR(glCreateProgram());
-
-    if (!compileShader(&vertShader, GL_VERTEX_SHADER, &vertSource)) {
+    program.create(glObjectStore);
+    vertexShader.create(glObjectStore);
+    if (!compileShader(vertexShader, &vertSource)) {
         Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertSource);
-        MBGL_CHECK_ERROR(glDeleteProgram(program));
-        program = 0;
         throw util::ShaderException(std::string { "Vertex shader " } + name + " failed to compile");
     }
 
-    if (!compileShader(&fragShader, GL_FRAGMENT_SHADER, &fragSource)) {
+    fragmentShader.create(glObjectStore);
+    if (!compileShader(fragmentShader, &fragSource)) {
         Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragSource);
-        MBGL_CHECK_ERROR(glDeleteShader(vertShader));
-        vertShader = 0;
-        MBGL_CHECK_ERROR(glDeleteProgram(program));
-        program = 0;
         throw util::ShaderException(std::string { "Fragment shader " } + name + " failed to compile");
     }
 
     // Attach shaders
-    MBGL_CHECK_ERROR(glAttachShader(program, vertShader));
-    MBGL_CHECK_ERROR(glAttachShader(program, fragShader));
+    MBGL_CHECK_ERROR(glAttachShader(program.getID(), vertexShader.getID()));
+    MBGL_CHECK_ERROR(glAttachShader(program.getID(), fragmentShader.getID()));
 
     {
         // Link program
         GLint status;
-        MBGL_CHECK_ERROR(glLinkProgram(program));
+        MBGL_CHECK_ERROR(glLinkProgram(program.getID()));
 
-        MBGL_CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
+        MBGL_CHECK_ERROR(glGetProgramiv(program.getID(), GL_LINK_STATUS, &status));
         if (status == 0) {
             GLint logLength;
-            MBGL_CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
+            MBGL_CHECK_ERROR(glGetProgramiv(program.getID(), GL_INFO_LOG_LENGTH, &logLength));
             const auto log = std::make_unique<GLchar[]>(logLength);
             if (logLength > 0) {
-                MBGL_CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
+                MBGL_CHECK_ERROR(glGetProgramInfoLog(program.getID(), logLength, &logLength, log.get()));
                 Log::Error(Event::Shader, "Program failed to link: %s", log.get());
             }
-
-            MBGL_CHECK_ERROR(glDeleteShader(vertShader));
-            vertShader = 0;
-            MBGL_CHECK_ERROR(glDeleteShader(fragShader));
-            fragShader = 0;
-            MBGL_CHECK_ERROR(glDeleteProgram(program));
-            program = 0;
             throw util::ShaderException(std::string { "Program " } + name + " failed to link: " + log.get());
         }
     }
 
-    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program.getID(), "a_pos"));
 }
 
+bool Shader::compileShader(gl::ShaderHolder& shader, const GLchar *source[]) {
+    GLint status = 0;
 
-bool Shader::compileShader(GLuint *shader, GLenum type, const GLchar *source[]) {
-    GLint status;
-
-    *shader = MBGL_CHECK_ERROR(glCreateShader(type));
     const GLsizei lengths = static_cast<GLsizei>(std::strlen(*source));
-    MBGL_CHECK_ERROR(glShaderSource(*shader, 1, source, &lengths));
+    MBGL_CHECK_ERROR(glShaderSource(shader.getID(), 1, source, &lengths));
 
-    MBGL_CHECK_ERROR(glCompileShader(*shader));
+    MBGL_CHECK_ERROR(glCompileShader(shader.getID()));
 
-    MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
+    MBGL_CHECK_ERROR(glGetShaderiv(shader.getID(), GL_COMPILE_STATUS, &status));
     if (status == 0) {
         GLint logLength;
-        MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
+        MBGL_CHECK_ERROR(glGetShaderiv(shader.getID(), GL_INFO_LOG_LENGTH, &logLength));
         if (logLength > 0) {
             const auto log = std::make_unique<GLchar[]>(logLength);
-            MBGL_CHECK_ERROR(glGetShaderInfoLog(*shader, logLength, &logLength, log.get()));
+            MBGL_CHECK_ERROR(glGetShaderInfoLog(shader.getID(), logLength, &logLength, log.get()));
             Log::Error(Event::Shader, "Shader failed to compile: %s", log.get());
         }
-
-        MBGL_CHECK_ERROR(glDeleteShader(*shader));
-        *shader = 0;
         return false;
     }
 
-    MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
+    MBGL_CHECK_ERROR(glGetShaderiv(shader.getID(), GL_COMPILE_STATUS, &status));
     if (status == GL_FALSE) {
         Log::Error(Event::Shader, "Shader %s failed to compile.", name);
-        MBGL_CHECK_ERROR(glDeleteShader(*shader));
-        *shader = 0;
         return false;
     }
 
@@ -107,13 +87,9 @@ bool Shader::compileShader(GLuint *shader, GLenum type, const GLchar *source[])
 
 Shader::~Shader() {
     if (program) {
-        MBGL_CHECK_ERROR(glDetachShader(program, vertShader));
-        MBGL_CHECK_ERROR(glDetachShader(program, fragShader));
-        MBGL_CHECK_ERROR(glDeleteProgram(program));
-        program = 0;
-        MBGL_CHECK_ERROR(glDeleteShader(vertShader));
-        vertShader = 0;
-        MBGL_CHECK_ERROR(glDeleteShader(fragShader));
-        fragShader = 0;
+        MBGL_CHECK_ERROR(glDetachShader(program.getID(), vertexShader.getID()));
+        MBGL_CHECK_ERROR(glDetachShader(program.getID(), fragmentShader.getID()));
     }
 }
+
+} // namespace mbgl