Finally fixed the dumb nvidia segfault on preload, also re-added GLEW as a dependency, pthreads is now required. Fixes #83, #81.

CMakeLists.txt

 
 include_directories("${PROJECT_BINARY_DIR}")
 
-add_definitions(-DSLOP_VERSION="v6.3.46")
+add_definitions(-DSLOP_VERSION="v6.3.47")
 
 # 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
 
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
 
+find_package(GLEW REQUIRED)
 find_package(GLM REQUIRED)
 find_package(X11 REQUIRED)
 find_package(XExt REQUIRED)
 find_package(GLX REQUIRED)
 find_package(OpenGL REQUIRED)
 find_package(XRender REQUIRED)
+# Ahhhh, finally this eliminates the segfault on preload.
+find_package(Threads REQUIRED)
 
 include_directories(${X11_INCLUDE_DIR}
+                    ${GLEW_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}
                     ${XEXT_INCLUDE_DIR}
                     ${GLX_INCLUDE_DIR}
                     ${OPENGL_INCLUDE_DIR})
 
 target_link_libraries(${LIBRARY_NAME} ${X11_LIBRARIES}
+				      ${CMAKE_THREAD_LIBS_INIT} 
                                       ${GLM_LIBRARIES}
                                       ${OPENGL_LIBRARIES}
                                       ${GLX_LIBRARY}
                                       ${XRENDER_LIBRARY}
-                                      ${XEXT_LIBRARIES})
+                                      ${XEXT_LIBRARIES}
+                                      ${GLEW_LIBRARIES})
 
 target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME} )
 

README.md

 
 ### Install using CMake (Requires CMake)
 
-*Note: Dependencies should be installed first: libxext, OpenGL, and glm.*
+*Note: Dependencies should be installed first: libxext, glew, and glm.*
 
 ```bash
 git clone https://github.com/naelstrof/slop.git

src/framebuffer.cpp

 #include "framebuffer.hpp"
 
 slop::Framebuffer::Framebuffer( int w, int h ) {
-    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 );
+    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 );
     // 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 ) );
 
-    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 );
+    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 );
     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);
-        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])));
+        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])));
         XDestroyImage( image );
         generatedDesktopImage = true;
     }
 }
 
 slop::Framebuffer::~Framebuffer() {
-    gl::DeleteTextures(1, &image);
-    gl::DeleteFramebuffers(1,&fbuffer);
-    gl::DeleteBuffers(2,buffers);
+    glDeleteTextures(1, &image);
+    glDeleteFramebuffers(1,&fbuffer);
+    glDeleteBuffers(2,buffers);
 }
 
 void slop::Framebuffer::resize( int w, int h ) {
     // Regenerate the image
-    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);
+    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);
 
     // Re-bind it to the framebuffer
-    gl::BindFramebuffer( gl::FRAMEBUFFER, fbuffer );
-    gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, image, 0);
-    gl::BindFramebuffer(gl::FRAMEBUFFER, 0);
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+    glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 void slop::Framebuffer::bind() {
-    gl::BindFramebuffer( gl::FRAMEBUFFER, fbuffer );
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
 }
 
 void slop::Framebuffer::unbind() {
-    gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );
+    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
 void slop::Framebuffer::draw(glm::vec2 mouse, float time, glm::vec4 color){
     if ( shader->hasParameter( "time" ) ) {
         shader->setParameter( "time", time );
     }
-    gl::ActiveTexture(gl::TEXTURE0);
-    gl::BindTexture( gl::TEXTURE_2D, image );
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture( GL_TEXTURE_2D, image );
     if ( shader->hasParameter( "desktop" ) ) {
 		shader->setParameter( "desktop", 1 );
-        gl::ActiveTexture(gl::TEXTURE0 + 1);
-        gl::BindTexture( gl::TEXTURE_2D, desktopImage );
+        glActiveTexture(GL_TEXTURE0 + 1);
+        glBindTexture( GL_TEXTURE_2D, desktopImage );
     }
-    gl::Enable( gl::TEXTURE_2D );
-    gl::DrawArrays( gl::TRIANGLES, 0, vertCount );
-    gl::Disable( gl::TEXTURE_2D );
+    glEnable( GL_TEXTURE_2D );
+    glDrawArrays( GL_TRIANGLES, 0, vertCount );
+    glDisable( GL_TEXTURE_2D );
     shader->unbind();
 }

src/framebuffer.hpp

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

src/glrectangle.cpp

     center_verts.push_back( br );
     center_uvs.push_back( glm::vec2(1, 0) );
 
-    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 );
+    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 );
     corner_vertCount = corner_verts.size();
     rectangle_vertCount = rectangle_verts.size();
     center_vertCount = center_verts.size();
 
 slop::GLRectangle::~GLRectangle() {
     delete shader;
-    gl::DeleteBuffers( 6, (GLuint*)&buffer );
+    glDeleteBuffers( 6, (GLuint*)&buffer );
 }
 
 void slop::GLRectangle::draw( glm::mat4& matrix ) {
-    gl::Enable( gl::BLEND );
-    gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
+    glEnable( GL_BLEND );
+    glBlendFunc(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 );
-        gl::DrawArrays(gl::TRIANGLES, 0, center_vertCount );
+        glDrawArrays(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 );
-        gl::DrawArrays(gl::TRIANGLES, 0, corner_vertCount );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
         shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        gl::DrawArrays(gl::TRIANGLES, 0, rectangle_vertCount );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
     } else {
         shader->setParameter( "color", color );
         shader->setAttribute( "position", buffer.corner_verts, 2 );
-        gl::DrawArrays(gl::TRIANGLES, 0, corner_vertCount );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
         shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        gl::DrawArrays(gl::TRIANGLES, 0, rectangle_vertCount );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
     }
     shader->unbind();
-    gl::Disable( gl::BLEND );
+    glDisable( GL_BLEND );
 }
 
 glm::vec4 slop::GLRectangle::getRect() {

src/glrectangle.hpp

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

src/main.cpp

 }
 
 void printHelp() {
-    std::cout << "slop v5.3.21\n";
+    std::cout << "slop " << SLOP_VERSION << "\n";
     std::cout << "\n";
     std::cout << "Copyright (C) 2017 Dalton Nell, Slop Contributors\n";
     std::cout << "(https://github.com/naelstrof/slop/graphs/contributors)\n";
     std::cout << "Options\n";
     std::cout << "  -x, --xdisplay=hostname:number.screen_number\n";
     std::cout << "                                Sets the x display.\n";
-	std::cout << "  -k, --nokeyboard              Disables the ability to cancel selections with\n";
-	std::cout << "                                  the keyboard.  (default=off)\n";
-	std::cout << "  -b, --bordersize=FLOAT        Set the selection rectangle's thickness.\n";
-	std::cout << "                                  (default=`1')\n";
-	std::cout << "  -p, --padding=FLOAT           Set the padding size of the selection. Can be\n";
-	std::cout << "                                  negative.  (default=`0')\n";
-	std::cout << "  -t, --tolerance=FLOAT         How far in pixels the mouse can move after\n";
-	std::cout << "                                  clicking and still be detected as a normal\n";
-	std::cout << "                                  click instead of a click and drag. Setting\n";
-	std::cout << "                                  this to 0 will disable window selections.\n";
-	std::cout << "                                  Alternatively setting it to 999999 would.\n";
-	std::cout << "                                  only allow for window selections.\n";
-	std::cout << "                                  (default=`2')\n";
-	std::cout << "  -c, --color=FLOAT,FLOAT,FLOAT,FLOAT\n";
-	std::cout << "                                Set the selection rectangle's color. Supports\n";
-	std::cout << "                                  RGB or RGBA values.\n";
-	std::cout << "                                  (default=`0.5,0.5,0.5,1')\n";
-	std::cout << "  -n, --nodecorations=INT       Attempt to select child windows in order to\n";
-	std::cout << "                                  avoid window decorations. Setting this to\n";
+    std::cout << "  -k, --nokeyboard              Disables the ability to cancel selections with\n";
+    std::cout << "                                  the keyboard.  (default=off)\n";
+    std::cout << "  -b, --bordersize=FLOAT        Set the selection rectangle's thickness.\n";
+    std::cout << "                                  (default=`1')\n";
+    std::cout << "  -p, --padding=FLOAT           Set the padding size of the selection. Can be\n";
+    std::cout << "                                  negative.  (default=`0')\n";
+    std::cout << "  -t, --tolerance=FLOAT         How far in pixels the mouse can move after\n";
+    std::cout << "                                  clicking and still be detected as a normal\n";
+    std::cout << "                                  click instead of a click and drag. Setting\n";
+    std::cout << "                                  this to 0 will disable window selections.\n";
+    std::cout << "                                  Alternatively setting it to 999999 would.\n";
+    std::cout << "                                  only allow for window selections.\n";
+    std::cout << "                                  (default=`2')\n";
+    std::cout << "  -c, --color=FLOAT,FLOAT,FLOAT,FLOAT\n";
+    std::cout << "                                Set the selection rectangle's color. Supports\n";
+    std::cout << "                                  RGB or RGBA values.\n";
+    std::cout << "                                  (default=`0.5,0.5,0.5,1')\n";
+    std::cout << "  -n, --nodecorations=INT       Attempt to select child windows in order to\n";
+    std::cout << "                                  avoid window decorations. Setting this to\n";
     std::cout << "                                  1 will enable a light attempt to\n";
     std::cout << "                                  remove decorations. Setting this to 2 will\n";
     std::cout << "                                  enable aggressive decoration removal.\n";
     std::cout << "                                  Supplying slop with just `-n` is\n";
     std::cout << "                                  equivalent to supplying `-n1`.\n";
     std::cout << "                                  (default=`0')\n";
-	std::cout << "  -q, --quiet                   Disable any unnecessary cerr output. Any\n";
-	std::cout << "                                  warnings simply won't print.\n";
-	std::cout << "  -l, --highlight               Instead of outlining selections, slop\n";
-	std::cout << "                                  highlights it. This is only useful when\n";
-	std::cout << "                                  --color is set to a transparent color.\n";
-	std::cout << "                                  (default=off)\n";
-	std::cout << "  -r, --shader=STRING           Sets the shader to load and use from\n";
-	std::cout << "                                  ~/.config/slop/\n";
-	std::cout << "  -f, --format=STRING           Set the output format string. Format specifiers\n";
-	std::cout << "                                  are %x, %y, %w, %h, %i, %g, and %c.\n";
-	std::cout << "                                  (default=`%g\n')\n";
-	std::cout << "  -o, --noopengl                Disable graphics acceleration.\n";
-	std::cout << "Examples\n";
-	std::cout << "    $ # Gray, thick, transparent border for maximum visiblity.\n";
-	std::cout << "    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n";
-	std::cout << "\n";
-	std::cout << "    $ # Remove window decorations.\n";
-	std::cout << "    $ slop --nodecorations\n";
-	std::cout << "\n";
-	std::cout << "    $ # Disable window selections. Useful for selecting individual pixels.\n";
-	std::cout << "    $ slop -t 0\n";
-	std::cout << "\n";
-	std::cout << "    $ # Classic Windows XP selection.\n";
-	std::cout << "    $ slop -l -c 0.3,0.4,0.6,0.4\n";
-	std::cout << "\n";
-	std::cout << "    $ # Read slop output for use in scripts.\n";
-	std::cout << "    $ read -r X Y W H G ID < <(slop -f '%x %y %w %h %g %i')\n";
-	std::cout << "\n";
-	std::cout << "Tips\n";
-	std::cout << "    * If you don't like a selection: you can cancel it by right-clicking\n";
-	std::cout << "regardless of which options are enabled or disabled for slop.\n";
-	std::cout << "    * If slop doesn't seem to select a window accurately, the problem could be\n";
-	std::cout << "because of decorations getting in the way. Try enabling the --nodecorations\n";
-	std::cout << "flag.\n";
+    std::cout << "  -q, --quiet                   Disable any unnecessary cerr output. Any\n";
+    std::cout << "                                  warnings simply won't print.\n";
+    std::cout << "  -l, --highlight               Instead of outlining selections, slop\n";
+    std::cout << "                                  highlights it. This is only useful when\n";
+    std::cout << "                                  --color is set to a transparent color.\n";
+    std::cout << "                                  (default=off)\n";
+    std::cout << "  -r, --shader=STRING           Sets the shader to load and use from\n";
+    std::cout << "                                  ~/.config/slop/\n";
+    std::cout << "  -f, --format=STRING           Set the output format string. Format specifiers\n";
+    std::cout << "                                  are %x, %y, %w, %h, %i, %g, and %c.\n";
+    std::cout << "                                  (default=`%g\n')\n";
+    std::cout << "  -o, --noopengl                Disable graphics acceleration.\n";
+    std::cout << "Examples\n";
+    std::cout << "    $ # Gray, thick, transparent border for maximum visiblity.\n";
+    std::cout << "    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n";
+    std::cout << "\n";
+    std::cout << "    $ # Remove window decorations.\n";
+    std::cout << "    $ slop --nodecorations\n";
+    std::cout << "\n";
+    std::cout << "    $ # Disable window selections. Useful for selecting individual pixels.\n";
+    std::cout << "    $ slop -t 0\n";
+    std::cout << "\n";
+    std::cout << "    $ # Classic Windows XP selection.\n";
+    std::cout << "    $ slop -l -c 0.3,0.4,0.6,0.4\n";
+    std::cout << "\n";
+    std::cout << "    $ # Read slop output for use in scripts.\n";
+    std::cout << "    $ read -r X Y W H G ID < <(slop -f '%x %y %w %h %g %i')\n";
+    std::cout << "\n";
+    std::cout << "Tips\n";
+    std::cout << "    * If you don't like a selection: you can cancel it by right-clicking\n";
+    std::cout << "regardless of which options are enabled or disabled for slop.\n";
+    std::cout << "    * If slop doesn't seem to select a window accurately, the problem could be\n";
+    std::cout << "because of decorations getting in the way. Try enabling the --nodecorations\n";
+    std::cout << "flag.\n";
 }
 
 int app( int argc, char** argv ) {

src/shader.cpp

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

src/shader.hpp

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

src/slop.cpp

-#include "gl_core_3_0.hpp"
+#include <GL/glew.h>
 #include <GL/gl.h>
 
 #include <chrono>
         // If we have a compositor, we try using OpenGL
         try {
             window = new SlopWindow();
-	    if (!gl::sys::IsVersionGEQ(3,0)) {
-		delete window;
+            if (!GLEW_VERSION_3_0) {
+                delete window;
                 throw new std::runtime_error( "OpenGL version is not high enough, slop requires OpenGL 3.0!\nOpenGL accelleration is disabled. Use -o or -q to suppress this message." );
-	    }
+            }
             success = true;
         } catch( std::exception* e ) {
             errorstring += std::string(e->what()) + "\n";
         // Then we draw our junk to a framebuffer.
         window->framebuffer->setShader( textured );
         window->framebuffer->bind();
-        gl::ClearColor (0.0, 0.0, 0.0, 0.0);
-        gl::Clear (gl::COLOR_BUFFER_BIT);
+        glClearColor (0.0, 0.0, 0.0, 0.0);
+        glClear (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.
-        gl::Enable( gl::BLEND );
-        gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
+        glEnable( GL_BLEND );
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         for (i=0;i<=(int)shaders.size()-2;i+=2) {
             pingpong->bind();
-            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
-            gl::Clear (gl::COLOR_BUFFER_BIT);
+            glClearColor (0.0, 0.0, 0.0, 0.0);
+            glClear (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();
-            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
-            gl::Clear (gl::COLOR_BUFFER_BIT);
+            glClearColor (0.0, 0.0, 0.0, 0.0);
+            glClear (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();
-            gl::ClearColor (0.0, 0.0, 0.0, 0.0);
-            gl::Clear (gl::COLOR_BUFFER_BIT);
+            glClearColor (0.0, 0.0, 0.0, 0.0);
+            glClear (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();
         }
-        gl::Disable( gl::BLEND );
+        glDisable( 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 = gl::GetError();
-        if ( err != gl::NO_ERROR_ ) {
+        GLenum err = glGetError();
+        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!
-    gl::ClearColor (0.0, 0.0, 0.0, 0.0);
-    gl::Clear (gl::COLOR_BUFFER_BIT);
+    glClearColor (0.0, 0.0, 0.0, 0.0);
+    glClear (GL_COLOR_BUFFER_BIT);
     window->display();
-    gl::Clear (gl::COLOR_BUFFER_BIT);
+    glClear (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.
-    gl::exts::LoadTest didLoad = gl::sys::LoadFunctions();
-    if(!didLoad)
+    GLenum err = glewInit();
+    if (GLEW_OK != err)
     {
-        throw new std::runtime_error("Failed to load function pointers for OpenGL.");
+      throw new std::runtime_error((char*)glewGetErrorString(err));
     }
     framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
 
-    gl::Viewport( 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
+    glViewport( 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.
-    gl::ClearColor( 0, 0, 0, 0 );
-    gl::Clear( gl::COLOR_BUFFER_BIT );
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT );
     display();
-    gl::ClearColor( 0, 0, 0, 0 );
-    gl::Clear( gl::COLOR_BUFFER_BIT );
+    glClearColor( 0, 0, 0, 0 );
+    glClear( 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.hpp"
+#include <GL/glew.h>
 #include <GL/gl.h>
 #define GL_GLEXT_PROTOTYPES
 #define GLX_GLXEXT_PROTOTYPES