namespaced opengl, added unicode support, (fixes #80)

CMakeLists.txt

 
 include_directories("${PROJECT_BINARY_DIR}")
 
-add_definitions(-DSLOP_VERSION="v6.3.44")
+add_definitions(-DSLOP_VERSION="v6.3.45")
 
 # The names have to be unique unfortunately.
 set(EXECUTABLE_NAME "slop")
 set(LIBRARY_NAME "slopy")
 
 add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
+                                    src/gl_core_3_0.cpp
                                     src/keyboard.cpp
                                     src/x.cpp
                                     src/slopstates.cpp
                                     src/framebuffer.cpp
                                     src/resource.cpp
-                                    src/gl_core_3_0.c
                                     src/shader.cpp
                                     src/window.cpp
                                     src/slop.cpp
                                       ${XRENDER_LIBRARY}
                                       ${XEXT_LIBRARIES})
 
-target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME})
+target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME} )
+
+set( SLOP_UNICODE TRUE CACHE BOOL "To enable or disable unicode support, really should be left to TRUE since old nvidia drivers crash with it off." )
+if ( SLOP_UNICODE )
+    # ICU is required for old nvidia drivers to work for whatever reason.
+    find_package(ICU REQUIRED COMPONENTS uc)
+    add_definitions(-DCXXOPTS_USE_UNICODE)
+    include_directories( ${ICU_INCLUDE_DIR} )
+    target_link_libraries(${EXECUTABLE_NAME} ${ICU_UC_LIBRARIES} )
+endif()
 
 install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
 install( TARGETS ${LIBRARY_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" )

src/framebuffer.cpp

 #include "framebuffer.hpp"
 
 slop::Framebuffer::Framebuffer( int w, int h ) {
-    glGenFramebuffers( 1, &fbuffer );
-    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
-    glGenTextures(1, &image);
-    glBindTexture(GL_TEXTURE_2D, image);
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    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_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    gl::GenFramebuffers( 1, &fbuffer );
+    gl::BindFramebuffer( gl::FRAMEBUFFER, fbuffer );
+    gl::GenTextures( 1, &image );
+    gl::BindTexture( gl::TEXTURE_2D, image );
+    gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA, w, h, 0, gl::RGBA, gl::UNSIGNED_BYTE, NULL );
+    gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST );
+    gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST );
+    gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE );
+    gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE );
+    gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, image, 0 );
+    gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );
     // generate our vertex and uv buffers
     std::vector<glm::vec2> verts;
     std::vector<glm::vec2> uvs;
     verts.push_back( glm::vec2(1,-1) );
     uvs.push_back( glm::vec2( 1, 0 ) );
 
-    glGenBuffers( 2, buffers );
-    glBindBuffer( GL_ARRAY_BUFFER, buffers[0] );
-    glBufferData( GL_ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffers[1] );
-    glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW );
+    gl::GenBuffers( 2, buffers );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffers[0] );
+    gl::BufferData( gl::ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], gl::STATIC_DRAW );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffers[1] );
+    gl::BufferData( gl::ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], gl::STATIC_DRAW );
     vertCount = verts.size();
     generatedDesktopImage = false;
 }
         XGrabServer(x11->display);
         XImage* image = XGetImage( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0xffffffff, ZPixmap );
         XUngrabServer(x11->display);
-        glEnable(GL_TEXTURE_2D);
-        glGenTextures(1, &desktopImage);
-        glBindTexture(GL_TEXTURE_2D, desktopImage);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(image->data[0])));
+        gl::Enable(gl::TEXTURE_2D);
+        gl::GenTextures(1, &desktopImage);
+        gl::BindTexture(gl::TEXTURE_2D, desktopImage);
+        gl::TexParameterf(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST);
+        gl::TexParameterf(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST);
+        //gl::TexEnvf(gl::TEXTURE_ENV, gl::TEXTURE_ENV_MODE, gl::MODULATE);
+        gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGB, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0, gl::BGRA, gl::UNSIGNED_BYTE, (void*)(&(image->data[0])));
         XDestroyImage( image );
         generatedDesktopImage = true;
     }
 }
 
 slop::Framebuffer::~Framebuffer() {
-    glDeleteTextures(1, &image);
-    glDeleteFramebuffers(1,&fbuffer);
-    glDeleteBuffers(2,buffers);
+    gl::DeleteTextures(1, &image);
+    gl::DeleteFramebuffers(1,&fbuffer);
+    gl::DeleteBuffers(2,buffers);
 }
 
 void slop::Framebuffer::resize( int w, int h ) {
     // Regenerate the image
-    glDeleteTextures(1, &image);
-    glBindTexture(GL_TEXTURE_2D, image);
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    gl::DeleteTextures(1, &image);
+    gl::BindTexture(gl::TEXTURE_2D, image);
+    gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA, w, h, 0, gl::RGBA, gl::UNSIGNED_BYTE, NULL);
+    gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR);
+    gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR);
 
     // Re-bind it to the framebuffer
-    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
-    glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    gl::BindFramebuffer( gl::FRAMEBUFFER, fbuffer );
+    gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, image, 0);
+    gl::BindFramebuffer(gl::FRAMEBUFFER, 0);
 }
 
 void slop::Framebuffer::bind() {
-    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+    gl::BindFramebuffer( gl::FRAMEBUFFER, fbuffer );
 }
 
 void slop::Framebuffer::unbind() {
-    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+    gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );
 }
 
 void slop::Framebuffer::draw(glm::vec2 mouse, float time, glm::vec4 color){
     if ( shader->hasParameter( "time" ) ) {
         shader->setParameter( "time", time );
     }
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture( GL_TEXTURE_2D, image );
+    gl::ActiveTexture(gl::TEXTURE0);
+    gl::BindTexture( gl::TEXTURE_2D, image );
     if ( shader->hasParameter( "desktop" ) ) {
 		shader->setParameter( "desktop", 1 );
-        glActiveTexture(GL_TEXTURE0 + 1);
-        glBindTexture( GL_TEXTURE_2D, desktopImage );
+        gl::ActiveTexture(gl::TEXTURE0 + 1);
+        gl::BindTexture( gl::TEXTURE_2D, desktopImage );
     }
-    glEnable( GL_TEXTURE_2D );
-    glDrawArrays( GL_TRIANGLES, 0, vertCount );
-    glDisable( GL_TEXTURE_2D );
+    gl::Enable( gl::TEXTURE_2D );
+    gl::DrawArrays( gl::TRIANGLES, 0, vertCount );
+    gl::Disable( gl::TEXTURE_2D );
     shader->unbind();
 }

src/framebuffer.hpp

 #ifndef N_FRAMEBUFFER_H_
 #define N_FRAMEBUFFER_H_
 
-#include "gl_core_3_0.h"
+#include "gl_core_3_0.hpp"
 #include <glm/glm.hpp>
 #include <GL/gl.h>
 #include <vector>

src/glrectangle.cpp

     center_verts.push_back( br );
     center_uvs.push_back( glm::vec2(1, 0) );
 
-    glGenBuffers( 6, (GLuint*)&buffer );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_verts );
-    glBufferData( GL_ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_uvs );
-    glBufferData( GL_ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], GL_STATIC_DRAW );
-
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_verts );
-    glBufferData( GL_ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
-    glBufferData( GL_ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], GL_STATIC_DRAW );
-
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.center_verts );
-    glBufferData( GL_ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), &center_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
-    glBufferData( GL_ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), &center_uvs[0], GL_STATIC_DRAW );
+    gl::GenBuffers( 6, (GLuint*)&buffer );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.corner_verts );
+    gl::BufferData( gl::ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], gl::STATIC_DRAW );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.corner_uvs );
+    gl::BufferData( gl::ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], gl::STATIC_DRAW );
+
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.rectangle_verts );
+    gl::BufferData( gl::ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], gl::STATIC_DRAW );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.rectangle_uvs );
+    gl::BufferData( gl::ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], gl::STATIC_DRAW );
+
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.center_verts );
+    gl::BufferData( gl::ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), &center_verts[0], gl::STATIC_DRAW );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer.rectangle_uvs );
+    gl::BufferData( gl::ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), &center_uvs[0], gl::STATIC_DRAW );
     corner_vertCount = corner_verts.size();
     rectangle_vertCount = rectangle_verts.size();
     center_vertCount = center_verts.size();
 
 slop::GLRectangle::~GLRectangle() {
     delete shader;
-    glDeleteBuffers( 6, (GLuint*)&buffer );
+    gl::DeleteBuffers( 6, (GLuint*)&buffer );
 }
 
 void slop::GLRectangle::draw( glm::mat4& matrix ) {
-    glEnable( GL_BLEND );
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    gl::Enable( gl::BLEND );
+    gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
     shader->bind();
     shader->setParameter( "projection", matrix );
     if ( highlight ) {
         // Draw the center of the highlight
         shader->setParameter( "color", color );
         shader->setAttribute( "position", buffer.center_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, center_vertCount );
+        gl::DrawArrays(gl::TRIANGLES, 0, center_vertCount );
         // Set the color to have no alpha, then draw the borders.
         glm::vec4 fullAlpha = glm::vec4(color.r,color.g,color.b,1);
         shader->setParameter( "color", fullAlpha );
         shader->setAttribute( "position", buffer.corner_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        gl::DrawArrays(gl::TRIANGLES, 0, corner_vertCount );
         shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+        gl::DrawArrays(gl::TRIANGLES, 0, rectangle_vertCount );
     } else {
         shader->setParameter( "color", color );
         shader->setAttribute( "position", buffer.corner_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        gl::DrawArrays(gl::TRIANGLES, 0, corner_vertCount );
         shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+        gl::DrawArrays(gl::TRIANGLES, 0, rectangle_vertCount );
     }
     shader->unbind();
-    glDisable( GL_BLEND );
+    gl::Disable( gl::BLEND );
 }
 
 glm::vec4 slop::GLRectangle::getRect() {

src/glrectangle.hpp

 #ifndef N_GLRECTANGLE_H_
 #define N_GLRECTANGLE_H_
 
-#include "gl_core_3_0.h"
+#include "gl_core_3_0.hpp"
 #include <iostream>
 #include <glm/glm.hpp>
 #include <GL/gl.h>

src/main.cpp

 #include <vector>
 #include <glm/glm.hpp>
 
-#include "cxxopts.hpp"
 #include "slop.hpp"
+#include "cxxopts.hpp"
 
 using namespace slop;
 

src/shader.cpp

     const char* fragsrc = frag_contents.c_str();
 
     // Create the program to link to.
-    program = glCreateProgram();
+    program = gl::CreateProgram();
     
     if ( vert_contents.length() <= 0 ) {
         std::string errstring = "Failed to open file (or is empty) `" + vert + "`.\n";
     }
 
     // Compile both shaders.
-    unsigned int vertShader = glCreateShader( GL_VERTEX_SHADER );
-    glShaderSource( vertShader, 1, &vertsrc , NULL );
+    unsigned int vertShader = gl::CreateShader( gl::VERTEX_SHADER );
+    gl::ShaderSource( vertShader, 1, &vertsrc , NULL );
     std::string errortxt;
     int err = compile( vertShader, errortxt );
 
     if ( err ) {
         std::string errstring = "Failed to compile shader `" + vert + "`:\n" + errortxt;
         throw new std::runtime_error(errstring);
-        glDeleteShader( vertShader );
+        gl::DeleteShader( vertShader );
         return;
     }
 
-    unsigned int fragShader = glCreateShader( GL_FRAGMENT_SHADER );
-    glShaderSource( fragShader, 1, &fragsrc, NULL );
+    unsigned int fragShader = gl::CreateShader( gl::FRAGMENT_SHADER );
+    gl::ShaderSource( fragShader, 1, &fragsrc, NULL );
     err = compile( fragShader, errortxt );
     if ( err ) {
         std::string errstring = "Failed to compile shader `" + frag + "`:\n" + errortxt;
         throw new std::runtime_error(errstring);
-        glDeleteShader( vertShader );
-        glDeleteShader( fragShader );
+        gl::DeleteShader( vertShader );
+        gl::DeleteShader( fragShader );
         return;
     }
 
     if ( err ) {
         std::string errstring = "Failed to link shader `" + vert + "` and  `" + frag + "`:\n" + errortxt;
         throw new std::runtime_error(errstring);
-        glDeleteShader( vertShader );
-        glDeleteShader( fragShader );
+        gl::DeleteShader( vertShader );
+        gl::DeleteShader( fragShader );
         return;
     }
 
     // Clean up :)
-    glDeleteShader( vertShader );
-    glDeleteShader( fragShader );
-    glUseProgram( 0 );
+    gl::DeleteShader( vertShader );
+    gl::DeleteShader( fragShader );
+    gl::UseProgram( 0 );
 }
 
 slop::Shader::~Shader() {
-    glDeleteProgram( program );
+    gl::DeleteProgram( program );
 }
 
 unsigned int slop::Shader::getProgram() {
 }
 
 void slop::Shader::bind() {
-    glUseProgram( program );
+    gl::UseProgram( program );
 }
 
 int slop::Shader::compile( unsigned int shader, std::string& error ) {
-    glCompileShader( shader );
+    gl::CompileShader( shader );
 
     // Compiling the shader is the easy part, all this junk down here is for printing the error it might generate.
-    int result = GL_FALSE;
+    int result;
     int logLength;
-    glGetShaderiv( shader, GL_COMPILE_STATUS, &result );
-    glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logLength );
-    if ( result == GL_FALSE ) {
+    gl::GetShaderiv( shader, gl::COMPILE_STATUS, &result );
+    gl::GetShaderiv( shader, gl::INFO_LOG_LENGTH, &logLength );
+    if ( result == false ) {
         char* errormsg = new char[ logLength ];
-        glGetShaderInfoLog( shader, logLength, NULL, errormsg );
+        gl::GetShaderInfoLog( shader, logLength, NULL, errormsg );
         error = errormsg;
         delete[] errormsg;
         return 1;
 }
 
 int slop::Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
-    glAttachShader( program, vertshader );
-    glAttachShader( program, fragshader );
-    glLinkProgram( program );
+    gl::AttachShader( program, vertshader );
+    gl::AttachShader( program, fragshader );
+    gl::LinkProgram( program );
 
     // Linking the shader is the easy part, all this junk down here is for printing the error it might generate.
-    int result = GL_FALSE;
+    int result = false;
     int logLength;
-    glGetProgramiv( program, GL_LINK_STATUS, &result);
-    glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logLength);
-    if ( result == GL_FALSE ) {
+    gl::GetProgramiv( program, gl::LINK_STATUS, &result);
+    gl::GetProgramiv( program, gl::INFO_LOG_LENGTH, &logLength);
+    if ( result == false ) {
         char* errormsg = new char[ logLength ];
-        glGetProgramInfoLog( program, logLength, NULL, errormsg );
+        gl::GetProgramInfoLog( program, logLength, NULL, errormsg );
         error = errormsg;
         delete[] errormsg;
         return 1;
 }
 
 unsigned int slop::Shader::getUniformLocation( std::string name ) {
-    glUseProgram( program );
-    return glGetUniformLocation( program, name.c_str() );
+    gl::UseProgram( program );
+    return gl::GetUniformLocation( program, name.c_str() );
 }
 
 bool slop::Shader::hasParameter( std::string name ) {
-    glUseProgram( program );
-    return glGetUniformLocation( program, name.c_str() ) != -1;
+    gl::UseProgram( program );
+    return gl::GetUniformLocation( program, name.c_str() ) != -1;
 }
 
 void slop::Shader::setParameter( std::string name, int foo ) {
-    glUniform1i( getUniformLocation( name ), foo );
+    gl::Uniform1i( getUniformLocation( name ), foo );
 }
 
 void slop::Shader::setParameter( std::string name, float foo ) {
-    glUniform1f( getUniformLocation( name ), foo );
+    gl::Uniform1f( getUniformLocation( name ), foo );
 }
 
 void slop::Shader::setParameter( std::string name, glm::mat4& foo ) {
-    glUniformMatrix4fv( getUniformLocation( name ), 1, GL_FALSE, glm::value_ptr( foo ) );
+    gl::UniformMatrix4fv( getUniformLocation( name ), 1, false, glm::value_ptr( foo ) );
 }
 
 void slop::Shader::setParameter( std::string name, glm::vec4 foo ) {
-    glUniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w );
+    gl::Uniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w );
 }
 
 void slop::Shader::setParameter( std::string name, glm::vec2 foo ) {
-    glUniform2f( getUniformLocation( name ), foo.x, foo.y );
+    gl::Uniform2f( getUniformLocation( name ), foo.x, foo.y );
 }
 
 void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
-    unsigned int a = glGetAttribLocation( program, name.c_str() );
-    glEnableVertexAttribArray( a );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer );
-    glVertexAttribPointer( a, stepsize, GL_FLOAT, GL_FALSE, 0, NULL );
+    unsigned int a = gl::GetAttribLocation( program, name.c_str() );
+    gl::EnableVertexAttribArray( a );
+    gl::BindBuffer( gl::ARRAY_BUFFER, buffer );
+    gl::VertexAttribPointer( a, stepsize, gl::FLOAT, false, 0, NULL );
     activeAttributes.push_back( a );
 }
 
 void slop::Shader::unbind() {
     for ( unsigned int i=0; i<activeAttributes.size(); i++ ) {
-        glDisableVertexAttribArray( activeAttributes[i] );
+        gl::DisableVertexAttribArray( activeAttributes[i] );
     }
     activeAttributes.clear();
-    glUseProgram( 0 );
+    gl::UseProgram( 0 );
 }

src/shader.hpp

 #include <string>
 #include <exception>
 
-#include "gl_core_3_0.h"
+#include "gl_core_3_0.hpp"
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <EGL/egl.h>

src/slop.cpp

         // Then we draw our junk to a framebuffer.
         window->framebuffer->setShader( textured );
         window->framebuffer->bind();
-        glClearColor (0.0, 0.0, 0.0, 0.0);
-        glClear (GL_COLOR_BUFFER_BIT);
+        gl::ClearColor (0.0, 0.0, 0.0, 0.0);
+        gl::Clear (gl::COLOR_BUFFER_BIT);
         memory->draw( window->camera );
         window->framebuffer->unbind();
 
         
         int i;
         // We have our clean buffer, now to slather it with some juicy shader chains.
-        glEnable( GL_BLEND );
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        gl::Enable( gl::BLEND );
+        gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
         for (i=0;i<=(int)shaders.size()-2;i+=2) {
             pingpong->bind();
-            glClearColor (0.0, 0.0, 0.0, 0.0);
-            glClear (GL_COLOR_BUFFER_BIT);
+            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
+            gl::Clear (gl::COLOR_BUFFER_BIT);
             window->framebuffer->setShader( shaders[i] );
             window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
             pingpong->unbind();
 
             window->framebuffer->bind();
-            glClearColor (0.0, 0.0, 0.0, 0.0);
-            glClear (GL_COLOR_BUFFER_BIT);
+            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
+            gl::Clear (gl::COLOR_BUFFER_BIT);
             pingpong->setShader( shaders[i+1] );
             pingpong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
             window->framebuffer->unbind();
         }
         for (;i<shaders.size();i++) {
             pingpong->bind();
-            glClearColor (0.0, 0.0, 0.0, 0.0);
-            glClear (GL_COLOR_BUFFER_BIT);
+            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
+            gl::Clear (gl::COLOR_BUFFER_BIT);
             window->framebuffer->setShader( shaders[i] );
             window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
             pingpong->unbind();
         }
-        glDisable( GL_BLEND );
+        gl::Disable( gl::BLEND );
         if ( i%2 != 0 ) {
             window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
         } else {
         window->display();
         // Here we sleep just to prevent our CPU usage from going to 100%.
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        GLenum err = glGetError();
-        if ( err != GL_NO_ERROR ) {
+        GLenum err = gl::GetError();
+        if ( err != gl::NO_ERROR_ ) {
             std::string error;
             switch(err) {
-                case GL_INVALID_OPERATION: error="INVALID_OPERATION"; break;
-                case GL_INVALID_ENUM: error="INVALID_ENUM"; break;
-                case GL_INVALID_VALUE: error="INVALID_VALUE"; break;
-                case GL_OUT_OF_MEMORY: error="OUT_OF_MEMORY"; break;
-                case GL_INVALID_FRAMEBUFFER_OPERATION: error="INVALID_FRAMEBUFFER_OPERATION"; break;
+		case gl::INVALID_OPERATION: error="INVALID_OPERATION"; break;
+		case gl::INVALID_ENUM: error="INVALID_ENUM"; break;
+		case gl::INVALID_VALUE: error="INVALID_VALUE"; break;
+		case gl::OUT_OF_MEMORY: error="OUT_OF_MEMORY"; break;
+		case gl::INVALID_FRAMEBUFFER_OPERATION: error="INVALID_FRAMEBUFFER_OPERATION"; break;
             }
             throw new std::runtime_error( "OpenGL threw an error: " + error );
         }
 
     // Lets now clear both front and back buffers before closing.
     // hopefully it'll be completely transparent while closing!
-    glClearColor (0.0, 0.0, 0.0, 0.0);
-    glClear (GL_COLOR_BUFFER_BIT);
+    gl::ClearColor (0.0, 0.0, 0.0, 0.0);
+    gl::Clear (gl::COLOR_BUFFER_BIT);
     window->display();
-    glClear (GL_COLOR_BUFFER_BIT);
+    gl::Clear (gl::COLOR_BUFFER_BIT);
     window->display();
     // Then we clean up.
     for( int i=0;i<shaders.size();i++ ) {

src/window.cpp

     }
     setCurrent();
     // Finally we grab some OpenGL 3.3 stuffs.
-    if(ogl_LoadFunctions() == ogl_LOAD_FAILED)
+    gl::exts::LoadTest didLoad = gl::sys::LoadFunctions();
+    if(!didLoad)
     {
         throw new std::runtime_error("Failed to load function pointers for OpenGL.");
     }
     framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
 
-    glViewport( 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
+    gl::Viewport( 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
     camera = glm::ortho( 0.0f, (float)WidthOfScreen( x11->screen ), (float)HeightOfScreen( x11->screen ), 0.0f, -1.0f, 1.0f);
 
     // Last, we actually display the window <:o)
 slop::SlopWindow::~SlopWindow() {
     delete framebuffer;
     // Try to erase the window before destroying it.
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT );
+    gl::ClearColor( 0, 0, 0, 0 );
+    gl::Clear( gl::COLOR_BUFFER_BIT );
     display();
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT );
+    gl::ClearColor( 0, 0, 0, 0 );
+    gl::Clear( gl::COLOR_BUFFER_BIT );
     display();
     glXDestroyContext( x11->display, context );
     XUnmapWindow( x11->display, window );

src/window.hpp

 #include <exception>
 
 #include <iostream>
-#include "gl_core_3_0.h"
+#include "gl_core_3_0.hpp"
 #include <GL/gl.h>
 #define GL_GLEXT_PROTOTYPES
 #define GLX_GLXEXT_PROTOTYPES