Now using glbinding

include/global.h

 } KeyboardButton;
 
 // Globally include OpenGL header
-#ifdef __APPLE__
-#include <OpenGL/gl3.h>
-#else // __APPLE__
-#endif // __APPLE__
+#include <glbinding/gl/gl.h>
+#include <glbinding/Binding.h>
+using namespace gl;
 
 /*! \fixme Is there a better way to handle this?
  * We wan't to use our own assert(). Unfortunately, glm includes

include/system/Shader.h

     static void set2DState(bool on, bool depth = true);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
-                       TextureStorage store = TextureStorage::SYSTEM, unsigned int mode = GL_TRIANGLES,
+                       TextureStorage store = TextureStorage::SYSTEM, GLenum = GL_TRIANGLES,
                        ShaderTexture* target = nullptr, Shader& shader = textShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
                        Shader& shader = textureShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                       unsigned int mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
+                       GLenum mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = colorShader);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
+                       glm::mat4 MVP, GLenum mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = colorShader);
 
   private:

src/CMakeLists.txt

 include_directories (SYSTEM ${OPENGL_INCLUDE_DIRS})
 set (LIBS ${LIBS} ${OPENGL_LIBRARIES})
 
-# Add Z Library
-find_package (ZLIB REQUIRED)
-include_directories (SYSTEM ${ZLIB_INCLUDE_DIRS})
-set (LIBS ${LIBS} ${ZLIB_LIBRARIES})
+# Add GLM Library
+find_package (GLM REQUIRED)
+include_directories (SYSTEM  ${GLM_INCLUDE_DIRS})
+
+# Add glbinding Library
+find_package (glbinding REQUIRED)
+include_directories (SYSTEM ${GLBINDING_INCLUDES})
+set (LIBS ${LIBS} ${GLBINDING_LIBRARIES})
 
 # Add SDL2 Library
 find_package (SDL2)
     endif (ALUT_FOUND)
 endif (OPENAL_FOUND)
 
-# Add GLM Library
-find_package (GLM REQUIRED)
-if (GLM_FOUND)
-    include_directories (SYSTEM  ${GLM_INCLUDE_DIRS})
-endif (GLM_FOUND)
-
-if (WIN32)
-    find_package (GLEW REQUIRED)
-    if (GLEW_FOUND)
-        include_directories (SYSTEM ${GLEW_INCLUDE_DIRS})
-        set (LIBS ${LIBS} ${GLEW_LIBRARIES})
-    endif (GLEW_FOUND)
-endif (WIN32)
-
 #################################################################
 
 # Set Source files

src/TextureManager.cpp

         getIds(s).push_back(id);
     }
 
-    unsigned int glcMode;
+    GLenum glcMode;
     switch (mode) {
         case ColorMode::BGR:
             glcMode = GL_BGR;
 
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     bindTexture(slot, s);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
+    glTexImage2D(GL_TEXTURE_2D, 0, GLint(GL_RGBA), width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
 
     if (filter) {
         // Trilinear filtering
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GLint(GL_REPEAT));
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GLint(GL_REPEAT));
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GLint(GL_LINEAR));
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GLint(GL_LINEAR_MIPMAP_LINEAR));
         glGenerateMipmap(GL_TEXTURE_2D);
     } else {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GLint(GL_NEAREST));
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GLint(GL_NEAREST));
     }
 
     return slot;

src/main.cpp

     command_parse(&cmd, argc, argv);
     command_free(&cmd);
 
-    // RunTime is required by other constructors
+    glbinding::Binding::initialize();
     Log::initialize();
-    RunTime::initialize();
+    RunTime::initialize(); // RunTime is required by other constructors
 
     gWorld.reset(new World());
 

src/system/Shader.cpp

     GLuint vertexID = glCreateShader(GL_VERTEX_SHADER);
     GLuint fragmentID = glCreateShader(GL_FRAGMENT_SHADER);
 
-    GLint result = GL_FALSE;
+    GLint result = GLint(GL_FALSE);
     GLint logLength = 0;
 
     // Compile vertex shader
     // Check vertex shader
     glGetShaderiv(vertexID, GL_COMPILE_STATUS, &result);
     glGetShaderiv(vertexID, GL_INFO_LOG_LENGTH, &logLength);
-    if ((logLength > 0) && (result != GL_TRUE)) {
+    if ((logLength > 0) && (result != GLint(GL_TRUE))) {
         std::vector<char> message(logLength + 1);
         glGetShaderInfoLog(vertexID, logLength, nullptr, &message[0]);
         Log::get(LOG_ERROR) << "Vertex Shader compilation error:" << Log::endl;
     // Check fragment shader
     glGetShaderiv(fragmentID, GL_COMPILE_STATUS, &result);
     glGetShaderiv(fragmentID, GL_INFO_LOG_LENGTH, &logLength);
-    if ((logLength > 0) && (result != GL_TRUE)) {
+    if ((logLength > 0) && (result != GLint(GL_TRUE))) {
         std::vector<char> message(logLength + 1);
         glGetShaderInfoLog(fragmentID, logLength, nullptr, &message[0]);
         Log::get(LOG_ERROR) << "Fragment Shader compilation error:" << Log::endl;
     // Check resulting program
     glGetProgramiv(programID, GL_LINK_STATUS, &result);
     glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLength);
-    if ((logLength > 0) && (result != GL_TRUE)) {
+    if ((logLength > 0) && (result != GLint(GL_TRUE))) {
         std::vector<char> message(logLength + 1);
         glGetProgramInfoLog(programID, logLength, nullptr, &message[0]);
         Log::get(LOG_ERROR) << "Shader link error:" << Log::endl;
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
-                    unsigned int texture, TextureStorage store, unsigned int mode,
+                    unsigned int texture, TextureStorage store, GLenum mode,
                     ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     if (mode == GL_TRIANGLES) {
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                    unsigned int mode, ShaderTexture* target, Shader& shader) {
+                    GLenum mode, ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
     if (mode == GL_TRIANGLES) {
         assert((vertices.getSize() % 3) == 0);
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                    glm::mat4 MVP, unsigned int mode, ShaderTexture* target, Shader& shader) {
+                    glm::mat4 MVP, GLenum mode, ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
     if (mode == GL_TRIANGLES) {
         assert((indices.getSize() % 3) == 0);