Added shader support

CMakeLists.txt

      src/cmdline.c
      src/selectrectangle.cpp
      src/glselectrectangle.cpp
+     src/shader.cpp
+     src/framebuffer.cpp
      src/resource.cpp
      src/xselectrectangle.cpp
      src/x.cpp
 find_package( XRender   REQUIRED )
 find_package( XRandr    REQUIRED )
 find_package( DevIL     REQUIRED )
+find_package( GLEW      REQUIRED )
 # This library is needed only for Ubuntu it seems, some platforms don't even
 # ship with it. I couldn't find a way to do a test compile to check if librt
 # was needed, so instead I just didn't mark it as REQUIRED.
                          ${OPENGL_INCLUDE_DIR}
                          ${IL_INCLUDE_DIR}
                          ${GLX_INCLUDE_DIR}
+                         ${GLEW_INCLUDE_DIRS}
                          ${XRENDER_INCLUDE_DIRS}
                          ${RT_INCLUDE_DIR} )
 else()
     include_directories( ${X11_INCLUDE_DIR}
                          ${OPENGL_INCLUDE_DIR}
                          ${IL_INCLUDE_DIR}
+                         ${GLEW_INCLUDE_DIRS}
                          ${GLX_INCLUDE_DIR}
                          ${XEXT_INCLUDE_DIR} )
 endif()
                            ${IL_LIBRARIES}
                            ${ILUT_LIBRARIES}
                            ${GLX_LIBRARIES}
+                           ${GLEW_LIBRARIES}
                            ${XRENDER_LIBRARIES}
                            "${XEXT_LIBRARY}"
                            "${XRANDR_LIBRARY}"
                            ${OPENGL_LIBRARIES}
                            ${IL_LIBRARIES}
                            ${ILUT_LIBRARIES}
+                           ${GLEW_LIBRARIES}
                            ${GLX_LIBRARIES}
                            ${X11_LIBRARIES}
                            "${XEXT_LIBRARY}" )
 install( TARGETS ${BIN_TARGET}
          DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
 
+install( DIRECTORY "${CMAKE_SOURCE_DIR}/share"
+         DESTINATION "${CMAKE_INSTALL_PREFIX}" )
+
 add_definitions(-DINSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}")

share/slop/gothic/corner_bl.png

+corner_tl.png

share/slop/gothic/corner_br.png

+corner_tl.png

share/slop/gothic/corner_tr.png

+corner_tl.png

share/slop/refract.frag

+#version 120
+
+uniform sampler2D texture;
+uniform sampler2D desktop;
+uniform int desktopWidth;
+uniform int desktopHeight;
+uniform float time;
+
+varying vec2 uvCoord;
+
+vec2 getDesktopUV( vec2 uv ) {
+    // Desktop image is upside-down, blame X11 lmao
+    uv.y = -uv.y;
+    return uv;
+}
+
+const float pi = 3.14159265f;
+
+void main() {
+    float sigma = 5;
+    float numBlurPixelsPerSide = 2.0f;
+    float blurMultiplier = 2.0f;
+
+    // Don't change anything below.
+    float blurSize = 1.f/desktopHeight*blurMultiplier;
+    vec2  blurMultiplyVec      = vec2(0.0f, 1.0f);
+    // Higher strength means bigger wobble
+    float strength = 8;
+    // Higher speed means faster wobble
+    float speed = 1;
+    float x = (sin( time*speed + uvCoord.y * desktopHeight/strength ) + 0.5)/desktopWidth*strength;
+    float y = (cos( time*speed + uvCoord.x * desktopWidth/strength ) + 0.5)/desktopHeight*strength;
+    x = x - (sin( time*speed*0.5 + uvCoord.y * desktopHeight/strength ) + 0.5)/desktopWidth*strength/2;
+    y = y - (cos( time*speed*0.5 + uvCoord.x * desktopWidth/strength ) + 0.5)/desktopHeight*strength/2;
+    vec2 offset = vec2(x,y);
+
+    // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
+    vec3 incrementalGaussian;
+    incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma);
+    incrementalGaussian.y = exp(-0.5f / (sigma * sigma));
+    incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
+
+    vec4 avgValue = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+    float coefficientSum = 0.0f;
+
+    // Take the central sample first...
+    vec4 color = texture2D( desktop, getDesktopUV( uvCoord.xy ) + offset );
+    color.a = texture2D( texture, uvCoord.xy ).a;
+    avgValue += color * incrementalGaussian.x;
+    coefficientSum += incrementalGaussian.x;
+    incrementalGaussian.xy *= incrementalGaussian.yz;
+
+    // Go through the remaining 8 vertical samples (4 on each side of the center)
+    for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) {
+        vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec);
+        color = texture2D( desktop, getDesktopUV( uv ) + offset );
+        color.a = texture2D( texture, uv ).a;
+        avgValue += color * incrementalGaussian.x;
+        uv = (uvCoord.xy + i * blurSize * blurMultiplyVec);
+        color = texture2D( desktop, getDesktopUV( uv ) + offset );
+        color.a = texture2D( texture, uv ).a;
+        avgValue += color * incrementalGaussian.x;
+        coefficientSum += 2 * incrementalGaussian.x;
+        incrementalGaussian.xy *= incrementalGaussian.yz;
+    }
+
+    //Reset
+    blurSize = 1.f/desktopWidth*blurMultiplier;
+    blurMultiplyVec      = vec2(1.0f, 0.0f);
+    incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma);
+    incrementalGaussian.y = exp(-0.5f / (sigma * sigma));
+    incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
+
+    // Go through the remaining 8 horizontal samples (4 on each side of the center)
+    for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) {
+        vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec);
+        vec4 color = texture2D( desktop, getDesktopUV( uv ) + offset );
+        color.a = texture2D( texture, uv ).a;
+        avgValue += color * incrementalGaussian.x;
+        uv = (uvCoord.xy + i * blurSize * blurMultiplyVec);
+        color = texture2D( desktop, getDesktopUV( uv ) + offset );
+        color.a = texture2D( texture, uv ).a;
+        avgValue += color * incrementalGaussian.x;
+        coefficientSum += 2 * incrementalGaussian.x;
+        incrementalGaussian.xy *= incrementalGaussian.yz;
+    }
+
+    gl_FragColor = avgValue / coefficientSum;
+}

share/slop/refract.vert

+#version 120
+
+attribute vec2 vertex;
+attribute vec2 uv;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    uvCoord = uv;
+	gl_Position = vec4(vertex,0,1);
+}

share/slop/simple.frag

+#version 120
+
+uniform sampler2D texture;
+uniform sampler2D desktop;
+uniform float time;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    gl_FragColor = texture2D( texture, uvCoord );
+}

share/slop/simple.vert

+#version 120
+
+attribute vec2 vertex;
+attribute vec2 uv;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    uvCoord = uv;
+	gl_Position = vec4(vertex,0,1);
+}

share/slop/wiggle.frag

+#version 120
+
+uniform sampler2D texture;
+uniform sampler2D desktop;
+uniform int desktopWidth;
+uniform int desktopHeight;
+uniform float time;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    // Higher strength means bigger wobble
+    float strength = 8;
+    // Higher speed means faster wobble
+    float speed = 2;
+    float x = uvCoord.x + (sin( time*speed + uvCoord.y * desktopHeight/strength ) + 0.5)/desktopWidth*strength;
+    float y = uvCoord.y + (cos( time*speed + uvCoord.x * desktopWidth/strength ) + 0.5)/desktopHeight*strength;
+    gl_FragColor = texture2D( texture, vec2( x, y ) );
+}

share/slop/wiggle.vert

+#version 120
+
+attribute vec2 vertex;
+attribute vec2 uv;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    uvCoord = uv;
+	gl_Position = vec4(vertex,0,1);
+}

src/cmdline.c

   "      --magnify                 Display a magnifying glass when --opengl is\n                                  also enabled.  (default=off)",
   "      --magstrength=FLOAT       Sets how many times the magnification window\n                                  size is multiplied.  (default=`4')",
   "      --magpixels=INT           Sets how many pixels are displayed in the\n                                  magnification. The less pixels the bigger the\n                                  magnification.  (default=`64')",
+  "      --theme=STRING            Sets the theme of the selection, using textures\n                                  from ~/.config/slop/ or /usr/share/.\n                                  (default=`none')",
+  "      --shader=STRING           Sets the shader to load and use from\n                                  ~/.config/slop/ or /usr/share/.\n                                  (default=`simple')",
   "  -f, --format=STRING           Set the output format string. Format specifiers\n                                  are %x, %y, %w, %h, %i, %g, and %c.\n                                  (default=`X=%x\\nY=%y\\nW=%w\\nH=%h\\nG=%g\\nID=%i\\nCancel=%c\\n')",
-  "\nExamples\n    $ # Gray, thick, transparent border for maximum visiblity.\n    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n\n    $ # Remove window decorations.\n    $ slop --nodecorations\n\n    $ # Disable window selections. Useful for selecting individual pixels.\n    $ slop -t 0\n\n    $ # Classic Windows XP selection.\n    $ slop -l -c 0.3,0.4,0.6,0.4\n\n    $ # Change output format to use safer parsing\n    $ slopoutput=$(slop -f \"%x %y %w %h\")\n    $ X=$(echo $slopoutput | awk '{print $1}')\n    $ Y=$(echo $slopoutput | awk '{print $2}')\n    $ W=$(echo $slopoutput | awk '{print $3}')\n    $ H=$(echo $slopoutput | awk '{print $4}')\n\nTips\n    * You can use the arrow keys to move the starting point of a\ndrag-selection, just in case you missed it by a few pixels.\n    * If you don't like a selection: you can cancel it by right-clicking\nregardless of which options are enabled or disabled for slop.\n    * If slop doesn't seem to select a window accurately, the problem could be\nbecause of decorations getting in the way. Try enabling the --nodecorations\nflag.\n",
+  "\nExamples\n    $ # Gray, thick, transparent border for maximum visiblity.\n    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n\n    $ # Remove window decorations.\n    $ slop --nodecorations\n\n    $ # Disable window selections. Useful for selecting individual pixels.\n    $ slop -t 0\n\n    $ # Classic Windows XP selection.\n    $ slop -l -c 0.3,0.4,0.6,0.4\n\n    $ # Wiggle wiggle!\n    $ slop --opengl --shader wiggle\n\n    $ # Edgy textures or something.\n    $ slop --opengl --theme gothic\n\n    $ # Change output format to use safer parsing\n    $ slopoutput=$(slop -f \"%x %y %w %h\")\n    $ X=$(echo $slopoutput | awk '{print $1}')\n    $ Y=$(echo $slopoutput | awk '{print $2}')\n    $ W=$(echo $slopoutput | awk '{print $3}')\n    $ H=$(echo $slopoutput | awk '{print $4}')\n\nTips\n    * You can use the arrow keys to move the starting point of a\ndrag-selection, just in case you missed it by a few pixels.\n    * If you don't like a selection: you can cancel it by right-clicking\nregardless of which options are enabled or disabled for slop.\n    * If slop doesn't seem to select a window accurately, the problem could be\nbecause of decorations getting in the way. Try enabling the --nodecorations\nflag.\n",
     0
 };
 
   args_info->magnify_given = 0 ;
   args_info->magstrength_given = 0 ;
   args_info->magpixels_given = 0 ;
+  args_info->theme_given = 0 ;
+  args_info->shader_given = 0 ;
   args_info->format_given = 0 ;
 }
 
   args_info->magstrength_orig = NULL;
   args_info->magpixels_arg = 64;
   args_info->magpixels_orig = NULL;
+  args_info->theme_arg = gengetopt_strdup ("none");
+  args_info->theme_orig = NULL;
+  args_info->shader_arg = gengetopt_strdup ("simple");
+  args_info->shader_orig = NULL;
   args_info->format_arg = gengetopt_strdup ("X=%x\nY=%y\nW=%w\nH=%h\nG=%g\nID=%i\nCancel=%c\n");
   args_info->format_orig = NULL;
   
   args_info->magnify_help = gengetopt_args_info_help[15] ;
   args_info->magstrength_help = gengetopt_args_info_help[16] ;
   args_info->magpixels_help = gengetopt_args_info_help[17] ;
-  args_info->format_help = gengetopt_args_info_help[18] ;
+  args_info->theme_help = gengetopt_args_info_help[18] ;
+  args_info->shader_help = gengetopt_args_info_help[19] ;
+  args_info->format_help = gengetopt_args_info_help[20] ;
   
 }
 
   free_string_field (&(args_info->max_orig));
   free_string_field (&(args_info->magstrength_orig));
   free_string_field (&(args_info->magpixels_orig));
+  free_string_field (&(args_info->theme_arg));
+  free_string_field (&(args_info->theme_orig));
+  free_string_field (&(args_info->shader_arg));
+  free_string_field (&(args_info->shader_orig));
   free_string_field (&(args_info->format_arg));
   free_string_field (&(args_info->format_orig));
   
     write_into_file(outfile, "magstrength", args_info->magstrength_orig, 0);
   if (args_info->magpixels_given)
     write_into_file(outfile, "magpixels", args_info->magpixels_orig, 0);
+  if (args_info->theme_given)
+    write_into_file(outfile, "theme", args_info->theme_orig, 0);
+  if (args_info->shader_given)
+    write_into_file(outfile, "shader", args_info->shader_orig, 0);
   if (args_info->format_given)
     write_into_file(outfile, "format", args_info->format_orig, 0);
   
         { "magnify",	0, NULL, 0 },
         { "magstrength",	1, NULL, 0 },
         { "magpixels",	1, NULL, 0 },
+        { "theme",	1, NULL, 0 },
+        { "shader",	1, NULL, 0 },
         { "format",	1, NULL, 'f' },
         { 0,  0, 0, 0 }
       };
                 additional_error))
               goto failure;
           
+          }
+          /* Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/..  */
+          else if (strcmp (long_options[option_index].name, "theme") == 0)
+          {
+          
+          
+            if (update_arg( (void *)&(args_info->theme_arg), 
+                 &(args_info->theme_orig), &(args_info->theme_given),
+                &(local_args_info.theme_given), optarg, 0, "none", ARG_STRING,
+                check_ambiguity, override, 0, 0,
+                "theme", '-',
+                additional_error))
+              goto failure;
+          
+          }
+          /* Sets the shader to load and use from ~/.config/slop/ or /usr/share/..  */
+          else if (strcmp (long_options[option_index].name, "shader") == 0)
+          {
+          
+          
+            if (update_arg( (void *)&(args_info->shader_arg), 
+                 &(args_info->shader_orig), &(args_info->shader_given),
+                &(local_args_info.shader_given), optarg, 0, "simple", ARG_STRING,
+                check_ambiguity, override, 0, 0,
+                "shader", '-',
+                additional_error))
+              goto failure;
+          
           }
           
           break;

src/cmdline.in

   int magpixels_arg;	/**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. (default='64').  */
   char * magpixels_orig;	/**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. original value given at command line.  */
   const char *magpixels_help; /**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. help description.  */
+  char * theme_arg;	/**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. (default='none').  */
+  char * theme_orig;	/**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. original value given at command line.  */
+  const char *theme_help; /**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. help description.  */
+  char * shader_arg;	/**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. (default='simple').  */
+  char * shader_orig;	/**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. original value given at command line.  */
+  const char *shader_help; /**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. help description.  */
   char * format_arg;	/**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. (default='REPLACEME').  */
   char * format_orig;	/**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. original value given at command line.  */
   const char *format_help; /**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. help description.  */
   unsigned int magnify_given ;	/**< @brief Whether magnify was given.  */
   unsigned int magstrength_given ;	/**< @brief Whether magstrength was given.  */
   unsigned int magpixels_given ;	/**< @brief Whether magpixels was given.  */
+  unsigned int theme_given ;	/**< @brief Whether theme was given.  */
+  unsigned int shader_given ;	/**< @brief Whether shader was given.  */
   unsigned int format_given ;	/**< @brief Whether format was given.  */
 
 } ;

src/framebuffer.cpp

+#include "framebuffer.hpp"
+
+slop::Framebuffer::Framebuffer() {
+    m_shader = new slop::Shader( "simple", resource->getRealPath( "simple.vert" ), resource->getRealPath( "simple.frag" ) );
+    generatedBuffers = false;
+    m_width = 0;
+    m_height = 0;
+    m_flags = (slop::Framebuffer::buffers)0;
+    m_depth = 0;
+    m_stencil = 0;
+    m_frame = 0;
+    m_buffers[0] = 0;
+    m_buffers[1] = 0;
+    m_texture = 0;
+}
+
+void slop::Framebuffer::setShader( std::string shader ) {
+    delete m_shader;
+    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
+}
+
+slop::Framebuffer::Framebuffer( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) {
+    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
+    generatedBuffers = false;
+    m_width = width;
+    m_height = height;
+    m_flags = flags;
+    if ( m_flags & stencil && m_flags & depth ) {
+        fprintf( stderr, "Most hardware doesn't support using a FBO with a depth and stencil attached! Condensing them to one render buffer..." );
+    }
+    if ( GLEW_VERSION_3_0 ) {
+        glGenFramebuffers( 1, &m_frame );
+        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
+        if ( m_flags & color ) {
+            glGenTextures( 1, &m_texture );
+            glBindTexture( GL_TEXTURE_2D, m_texture );
+            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+            glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
+        }
+
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glGenRenderbuffers( 1, &m_depth );
+            glBindRenderbuffer( GL_RENDERBUFFER, m_depth );
+            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth );
+        }
+
+        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
+        if ( m_flags & stencil ) {
+            glGenRenderbuffers( 1, &m_stencil );
+            glBindRenderbuffer( GL_RENDERBUFFER, m_stencil );
+            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
+        }
+        check();
+        //Make sure we unbind when we're done.
+        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glGenFramebuffersEXT( 1, &m_frame );
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+
+        if ( m_flags & color ) {
+            glGenTextures( 1, &m_texture );
+            glBindTexture( GL_TEXTURE_2D, m_texture );
+            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+            glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
+        }
+
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glGenRenderbuffersEXT( 1, &m_depth );
+            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth );
+            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth );
+        }
+
+        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
+        if ( m_flags & stencil ) {
+            glGenRenderbuffersEXT( 1, &m_stencil );
+            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil );
+            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
+        }
+        check();
+        //Make sure we unbind when we're done.
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
+    } else {
+        fprintf( stderr, "Error: Failed to create framebuffer! You need OpenGL 3.0 or the GL_EXT_framebuffer_object extension!\n" );
+    }
+}
+
+slop::Framebuffer::~Framebuffer() {
+    if ( GLEW_VERSION_3_0 ) {
+        glDeleteFramebuffers( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffers( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffers( 1, &m_stencil );
+        }
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glDeleteFramebuffersEXT( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffersEXT( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffersEXT( 1, &m_stencil );
+        }
+    }
+    if ( generatedBuffers ) {
+        glDeleteBuffers( 2, m_buffers );
+    }
+    delete m_shader;
+}
+
+void slop::Framebuffer::bind() {
+    if ( GLEW_VERSION_3_0 ) {
+        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+    }
+}
+
+void slop::Framebuffer::unbind() {
+    if ( GLEW_VERSION_3_0 ) {
+        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
+    }
+}
+
+void slop::Framebuffer::createFromTexture( unsigned int texture, std::string shader ) {
+    // First make sure we're empty.
+    if ( GLEW_VERSION_3_0 ) {
+        glDeleteFramebuffers( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffers( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffers( 1, &m_stencil );
+        }
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glDeleteFramebuffersEXT( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffersEXT( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffersEXT( 1, &m_stencil );
+        }
+    }
+    delete m_shader;
+    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
+    // Set flags to 0 so we don't delete the texture on deconstruction.
+    m_flags = 0;
+    m_texture = texture;
+    if ( GLEW_VERSION_3_0 ) {
+        glGenFramebuffers( 1, &m_frame );
+        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
+        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glGenFramebuffersEXT( 1, &m_frame );
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
+    }
+    check();
+    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+}
+
+void slop::Framebuffer::create( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) {
+    if ( m_width == width && m_height == height && m_flags == flags ) {
+        return;
+    }
+    delete m_shader;
+    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
+    if ( GLEW_VERSION_3_0 ) {
+        glDeleteFramebuffers( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffers( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffers( 1, &m_stencil );
+        }
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glDeleteFramebuffersEXT( 1, &m_frame );
+        if ( m_flags & color ) {
+            glDeleteTextures( 1, &m_texture );
+        }
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glDeleteRenderbuffersEXT( 1, &m_depth );
+        }
+        if ( m_flags & stencil ) {
+            glDeleteRenderbuffersEXT( 1, &m_stencil );
+        }
+    }
+    m_flags = flags;
+    m_width = width;
+    m_height = height;
+    if ( GLEW_VERSION_3_0 ) {
+        glGenFramebuffers( 1, &m_frame );
+        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
+
+        if ( m_flags & color ) {
+            glGenTextures( 1, &m_texture );
+            glBindTexture( GL_TEXTURE_2D, m_texture );
+            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+            glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
+        }
+
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glGenRenderbuffers( 1, &m_depth );
+            glBindRenderbuffer( GL_RENDERBUFFER, m_depth );
+            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth );
+        }
+
+        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
+        if ( m_flags & stencil ) {
+            glGenRenderbuffers( 1, &m_stencil );
+            glBindRenderbuffer( GL_RENDERBUFFER, m_stencil );
+            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
+            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
+        }
+        //Make sure we unbind when we're done.
+        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glGenFramebuffersEXT( 1, &m_frame );
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+
+        if ( m_flags & color ) {
+            glGenTextures( 1, &m_texture );
+            glBindTexture( GL_TEXTURE_2D, m_texture );
+            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
+           glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+            glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
+        }
+
+        if ( m_flags & depth && !( m_flags & stencil ) ) {
+            glGenRenderbuffersEXT( 1, &m_depth );
+            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth );
+            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth );
+        }
+
+        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
+        if ( m_flags & stencil ) {
+            glGenRenderbuffersEXT( 1, &m_stencil );
+            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil );
+            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
+            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
+        }
+        //Make sure we unbind when we're done.
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
+    }
+}
+
+void slop::Framebuffer::check()
+{
+    if ( GLEW_VERSION_3_0 ) {
+        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
+        unsigned int err = glCheckFramebufferStatus( GL_FRAMEBUFFER );
+        if ( err == GL_FRAMEBUFFER_COMPLETE ) {
+            return;
+        }
+        fprintf( stderr, "Error: Framebuffer failed a check procedure for reason: " );
+        switch ( err ) {
+            case GL_FRAMEBUFFER_UNDEFINED: {
+                fprintf( stderr, "GL_FRAMEBUFFER_UNDEFINED\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_UNSUPPORTED: {
+                fprintf( stderr, "GL_FRAMEBUFFER_UNSUPPORTED\n" );
+                break;
+            }
+            default: {
+                fprintf( stderr, "UNKNOWN\n" );
+                break;
+            }
+        }
+        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+    } else if ( GLEW_EXT_framebuffer_object ) {
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+        unsigned int err = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
+        if ( err == GL_FRAMEBUFFER_COMPLETE_EXT ) {
+            return;
+        }
+        switch ( err ) {
+            /* Apparently doesn't exist as an extension.
+               case GL_FRAMEBUFFER_UNDEFINED_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_UNDEFINED_EXT\n" );
+                break;
+            }*/
+            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT\n" );
+                break;
+            }
+            case GL_FRAMEBUFFER_UNSUPPORTED_EXT: {
+                fprintf( stderr, "GL_FRAMEBUFFER_UNSUPPORTED_EXT\n" );
+                break;
+            }
+            default: {
+                fprintf( stderr, "Unknown framebuffer error!\n" );
+                break;
+            }
+        }
+        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
+    }
+}
+
+void slop::Framebuffer::generateBuffers() {
+    if ( generatedBuffers ) {
+        return;
+    }
+    std::vector<glm::vec2> verts;
+    std::vector<glm::vec2> uvs;
+    verts.push_back( glm::vec2( -1, -1 ) );
+    verts.push_back( glm::vec2( 1, -1 ) );
+    verts.push_back( glm::vec2( 1, 1 ) );
+    verts.push_back( glm::vec2( -1, 1 ) );
+    uvs.push_back( glm::vec2( 0, 0 ) );
+    uvs.push_back( glm::vec2( 1, 0 ) );
+    uvs.push_back( glm::vec2( 1, 1 ) );
+    uvs.push_back( glm::vec2( 0, 1 ) );
+
+    glGenBuffers( 2, m_buffers );
+    glBindBuffer( GL_ARRAY_BUFFER, m_buffers[0] );
+    glBufferData( GL_ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, m_buffers[1] );
+    glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW );
+    generatedBuffers = true;
+}
+
+void slop::Framebuffer::clear( glm::vec4 clearcolor, unsigned char flags ) {
+    // FIXME: This should auto-bind and unbind, but I was too lazy to find out how to push and pop gl states.
+    unsigned int colorbit = 0;
+    if ( flags & color ) {
+        colorbit = colorbit | GL_COLOR_BUFFER_BIT;
+    }
+    if ( m_flags & depth && flags & depth ) {
+        colorbit = colorbit | GL_DEPTH_BUFFER_BIT;
+    }
+    if ( m_flags & stencil && flags & stencil) {
+        colorbit = colorbit | GL_STENCIL_BUFFER_BIT;
+    }
+    glClearColor( clearcolor.x, clearcolor.y, clearcolor.z, clearcolor.w );
+    glClear( colorbit );
+}
+
+void slop::Framebuffer::draw( float time, unsigned int desktop ) {
+    if ( !( m_flags & color ) ) {
+        return;
+    }
+
+    generateBuffers();
+
+    //slop::Shader* shader = shaders->get( "simple" );
+    m_shader->bind();
+    m_shader->setParameter( "texture", 0 );
+    m_shader->setParameter( "desktop", 1 );
+    m_shader->setParameter( "time", time );
+    m_shader->setParameter( "desktopWidth", (int)xengine->getWidth() );
+    m_shader->setParameter( "desktopHeight", (int)xengine->getHeight() );
+    m_shader->setAttribute( "vertex", m_buffers[0], 2 );
+    m_shader->setAttribute( "uv", m_buffers[1], 2 );
+
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glBindTexture( GL_TEXTURE_2D, m_texture );
+    glActiveTexture(GL_TEXTURE0 + 1);
+    glBindTexture( GL_TEXTURE_2D, desktop );
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glEnable( GL_TEXTURE_2D );
+    glDrawArrays( GL_QUADS, 0, 4 );
+    glDisable( GL_TEXTURE_2D );
+
+    m_shader->unbind();
+}

src/framebuffer.hpp

+#ifndef IS_FRAMEBUFFER_H_
+#define IS_FRAMEBUFFER_H_
+
+#include <GL/glew.h>
+#include <GL/gl.h>
+#include <glm/glm.hpp>
+
+#include "x.hpp"
+#include "shader.hpp"
+#include "resource.hpp"
+
+namespace slop {
+
+class Framebuffer
+{
+public:
+    enum buffers
+    {
+        color = 0x01,
+        depth = 0x02,
+        stencil = 0x04
+    };
+    Framebuffer();
+    Framebuffer( unsigned int width, unsigned int height, unsigned char flags = color, std::string shader = "simple" );
+    ~Framebuffer();
+    void create( unsigned int width, unsigned int height, unsigned char flags = color, std::string shader = "simple" );
+    void createFromTexture( unsigned int texture, std::string shader = "simple" );
+    void setShader( std::string shader = "simple" );
+    void clear( glm::vec4 color = glm::vec4( 0, 0, 0, 1 ), unsigned char flags = color | depth | stencil );
+    void bind();
+    void unbind();
+    void draw( float time, unsigned int image );
+    unsigned int m_texture;
+    unsigned int m_depth;
+    unsigned int m_stencil;
+    slop::Shader* m_shader;
+private:
+    unsigned int m_width;
+    unsigned int m_height;
+    void check();
+    void generateBuffers();
+    unsigned char m_flags;
+    bool generatedBuffers;
+    unsigned int m_frame;
+    unsigned int m_buffers[2];
+};
+
+}
+
+#endif //IS_FRAMEBUFFER_H_

src/glselectrectangle.cpp

     if ( m_window == None ) {
         return;
     }
+    delete m_framebuffer;
     // Try to erase the window before destroying it.
     glClearColor( 0, 0, 0, 0 );
     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
     m_offseth *= m_glassSize;
 }
 
+void slop::GLSelectRectangle::setShader( std::string shader ) {
+    m_shader = shader;
+    m_framebuffer->setShader( shader );
+}
+
 void slop::GLSelectRectangle::setMagnifySettings( bool on, float magstrength, unsigned int pixels ) {
     m_glassSize = magstrength;
     m_glassPixels = pixels;
     m_glassBorder = 1;
     m_monitors = xengine->getCRTCS();
     m_themed = false;
+    m_shader = "simple";
+    m_time = 0;
 
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
     if ( !glXMakeContextCurrent( xengine->m_display, m_glxWindow, m_glxWindow, m_renderContext ) ) {
         fprintf( stderr, "Failed to attach GL context to window!\n" );
     }
+    GLenum err = glewInit();
+    if ( GLEW_OK != err ) {
+        /* Problem: glewInit failed, something is seriously wrong. */
+        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
+    }
+
+    // Get an image of the entire desktop for use in shaders.
+    XImage* image = XGetImage( xengine->m_display, xengine->m_root, 0, 0, xengine->getWidth(), xengine->getHeight(), 0xffffffff, ZPixmap );
+    glEnable(GL_TEXTURE_2D);
+    glGenTextures(1, &m_desktop);
+    glBindTexture(GL_TEXTURE_2D, m_desktop);
+    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, xengine->getWidth(), xengine->getHeight(), 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(image->data[0])));
+    XDestroyImage( image );
+
+    glDisable(GL_TEXTURE_2D);
+    m_framebuffer = new slop::Framebuffer( xengine->getWidth(), xengine->getHeight(), slop::Framebuffer::color, m_shader );
+    m_framebuffer->bind();
     glEnable( GL_BLEND );
     glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
     glClearColor( 0, 0, 0, 0 );
     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
     glXSwapBuffers( xengine->m_display, m_glxWindow );
+    m_framebuffer->unbind();
 }
 
 void slop::GLSelectRectangle::setGeo( int sx, int sy, int ex, int ey ) {
 }
 
 void slop::GLSelectRectangle::update( double dt ) {
+    m_time += dt;
+    m_framebuffer->bind();
     glViewport( 0, 0, xengine->getWidth(), xengine->getHeight() );
 
     glClearColor( 0, 0, 0, 0 );
         glEnd();
     }
 
+    m_framebuffer->unbind();
+
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+    m_framebuffer->draw( (float) m_time, m_desktop );
+
     if ( m_glassEnabled ) {
         generateMagnifyingGlass();
         findOptimalGlassPosition();

src/glselectrectangle.hpp

 #include "x.hpp"
 #include "selectrectangle.hpp"
 #include "resource.hpp"
+#include "framebuffer.hpp"
 
 #include <unistd.h>
 
 #include <GL/gl.h>
 #include <GL/glx.h>
+#include <GL/glew.h>
 #include <GL/glxext.h>
 #define ILUT_USE_OPENGL
 #include <IL/il.h>
     void                findOptimalGlassPosition();
     void                constrainWithinMonitor( int* x, int* y, int* w, int* h );
     void                setTheme( bool on, std::string name );
+    void                setShader( std::string name );
     float               m_r;
     float               m_g;
     float               m_b;
     int                 m_offsety;
     int                 m_offsetw;
     int                 m_offseth;
+    unsigned int        m_desktop;
     unsigned int        m_glassPixels;
     float               m_glassSize;
     int                 m_glassBorder;
     int                 m_glassx;
     int                 m_glassy;
     bool                m_glassEnabled;
+    double              m_time;
+    std::string         m_shader;
     std::vector<XRRCrtcInfo*> m_monitors;
+    slop::Framebuffer*  m_framebuffer;
 };
 
 }

src/main.cpp

 #include <time.h>
 #include <cstdio>
 #include <sstream>
+#include <execinfo.h>
 
 #ifdef __MACH__
 #include <mach/clock.h>
     bool highlight = options.highlight_flag;
     bool keyboard = !options.nokeyboard_flag;
     bool decorations = !options.nodecorations_flag;
+    bool themeon = (bool)options.theme_given;
+    std::string theme = options.theme_arg;
+    std::string shader = options.shader_arg;
     struct timespec start, time;
     int xoffset = 0;
     int yoffset = 0;
                                                                      r, g, b, a );
                             // Haha why is this so hard to cast?
                             ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
-                            ((slop::GLSelectRectangle*)(selection))->setTheme( true, "gothic" );
+                            ((slop::GLSelectRectangle*)(selection))->setTheme( themeon, theme );
+                            ((slop::GLSelectRectangle*)(selection))->setShader( shader );
                         } else {
                             selection = new slop::XSelectRectangle( t.m_x, t.m_y,
                                                                     t.m_x + t.m_width,
                                                                  r, g, b, a );
                         // Haha why is this so hard to cast?
                         ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
-                        ((slop::GLSelectRectangle*)(selection))->setTheme( true, "gothic" );
+                        ((slop::GLSelectRectangle*)(selection))->setTheme( themeon, theme );
+                        ((slop::GLSelectRectangle*)(selection))->setShader( shader );
                     } else {
                         selection = new slop::XSelectRectangle( sx, sy,
                                                                 ex, ey,
         return app( argc, argv );
     } catch( std::bad_alloc const& exception ) {
         fprintf( stderr, "Couldn't allocate enough memory! No space left in RAM." );
-        return EXIT_FAILURE;
     } catch( std::exception const& exception ) {
         fprintf( stderr, "Unhandled Exception Thrown: %s\n", exception.what() );
-        return EXIT_FAILURE;
+    } catch( std::string err ) {
+        fprintf( stderr, "Unhandled Exception Thrown: %s\n", err.c_str() );
     } catch( ... ) {
         fprintf( stderr, "Unknown Exception Thrown!\n" );
-        return EXIT_FAILURE;
     }
+    return EXIT_FAILURE;
 }

src/options.ggo

     default="64"
     optional
 
+option "theme" - "Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/."
+    string
+    default="none"
+    optional
+
+option "shader" - "Sets the shader to load and use from ~/.config/slop/ or /usr/share/."
+    string
+    default="simple"
+    optional
+
 option "format" f "Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c."
     string
     default="REPLACEME"
 text "    $ # Classic Windows XP selection.\n"
 text "    $ slop -l -c 0.3,0.4,0.6,0.4\n"
 text "\n"
+text "    $ # Wiggle wiggle!\n"
+text "    $ slop --opengl --shader wiggle\n"
+text "\n"
+text "    $ # Edgy textures or something.\n"
+text "    $ slop --opengl --theme gothic\n"
+text "\n"
 text "    $ # Change output format to use safer parsing\n"
 text "    $ slopoutput=$(slop -f \"%x %y %w %h\")\n"
 text "    $ X=$(echo $slopoutput | awk '{print $1}')\n"

src/resource.cpp

         char* home = getpwuid(getuid())->pw_dir;
         m_usrconfig += home;
         m_usrconfig += "/.config/slop/";
+        m_sysconfig = INSTALL_PREFIX;
+        m_sysconfig += "/share/slop/";
         return;
     }
     m_usrconfig += config;
     m_usrconfig += "/slop/";
     m_sysconfig = INSTALL_PREFIX;
-    m_sysconfig += "/share/slop";
+    m_sysconfig += "/share/slop/";
 }
 
 std::string slop::Resource::getRealPath( std::string localpath ) {
-    if ( !validatePath( m_usrconfig + localpath ) ) {
-        if ( !validatePath( m_sysconfig + localpath ) ) {
-            fprintf( stderr, "Failed to find directory %s in %s or %s...\n", localpath.c_str(), m_usrconfig.c_str(), m_sysconfig.c_str() );
-        }
+    if ( validatePath( m_usrconfig + localpath ) ) {
+        return m_usrconfig + localpath;
+    }
+    if ( validatePath( m_sysconfig + localpath ) ) {
         return m_sysconfig + localpath;
     }
-    return m_usrconfig + localpath;
+    std::string err = "The file or folder " + localpath + " was not found in either " + m_sysconfig + " or " + m_usrconfig + "\n";
+    throw err;
+    return localpath;
 }
 
 bool slop::Resource::validatePath( std::string path ) {

src/resource.hpp

 #define IS_RESOURCE_H_
 
 #include <stdlib.h>
+#include <cassert>
 #include <cstdio>
 #include <string>
 #include <unistd.h>

src/selectrectangle.hpp

 
 #include "x.hpp"
 #include "selectrectangle.hpp"
+#include "shader.hpp"
 
 #include <unistd.h>
 

src/shader.cpp

+#include "shader.hpp"
+
+slop::Shader::Shader( std::string name, std::string vert, std::string frag, std::string type ) {
+    m_name = name;
+    // Set up the type of the shader, this is read by render to know what kind of matricies it needs.
+    if ( type == "perspective" ) {
+        m_type = 0;
+    } else if ( type == "orthographic" ) {
+        m_type = 1;
+    } else {
+        m_type = -1;
+    }
+    m_good = false;
+    // Create the program to link to.
+    m_program = glCreateProgram();
+
+    std::ifstream v( vert.c_str() );
+    std::string vert_contents((std::istreambuf_iterator<char>(v)),
+                               std::istreambuf_iterator<char>());
+    std::ifstream f( frag.c_str() );
+    std::string frag_contents((std::istreambuf_iterator<char>(f)),
+                              std::istreambuf_iterator<char>());
+
+    const char* vertsrc = vert_contents.c_str();
+    const char* fragsrc = frag_contents.c_str();
+
+    // Compile both shaders.
+    unsigned int vertShader = glCreateShader( GL_VERTEX_SHADER );
+    glShaderSource( vertShader, 1, &vertsrc , NULL );
+    int err = compile( vertShader );
+
+    if ( err ) {
+        fprintf( stderr, "Failed to compile shader %s.\n", vert.c_str() );
+        glDeleteShader( vertShader );
+        return;
+    }
+
+    unsigned int fragShader = glCreateShader( GL_FRAGMENT_SHADER );
+    glShaderSource( fragShader, 1, &fragsrc, NULL );
+    err = compile( fragShader );
+    if ( err ) {
+        fprintf( stderr, "Failed to compile shader %s.\n", frag.c_str() );
+        glDeleteShader( vertShader );
+        glDeleteShader( fragShader );
+        return;
+    }
+
+
+    // Then attempt to link them to this shader.
+    err = link( vertShader, fragShader );
+    if ( err ) {
+        fprintf( stderr, "Failed to link shader %s.\n", name.c_str() );
+        glDeleteShader( vertShader );
+        glDeleteShader( fragShader );
+        return;
+    }
+
+    // Clean up :)
+    glDeleteShader( vertShader );
+    glDeleteShader( fragShader );
+    m_good = true;
+    glUseProgram( 0 );
+}
+
+slop::Shader::~Shader() {
+    glDeleteProgram( m_program );
+}
+
+unsigned int slop::Shader::getProgram() {
+    return m_program;
+}
+
+void slop::Shader::bind() {
+    glUseProgram( m_program );
+}
+
+int slop::Shader::compile( unsigned int 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;
+    glGetShaderiv( shader, GL_COMPILE_STATUS, &result );
+    glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logLength );
+    if ( result == GL_FALSE ) {
+        char* errormsg = new char[ logLength ];
+        glGetShaderInfoLog( shader, logLength, NULL, errormsg );
+        fprintf( stderr, "%s\n", errormsg );
+        delete[] errormsg;
+        return 1;
+    }
+    return 0;
+}
+
+int slop::Shader::link( unsigned int vertshader, unsigned int fragshader ) {
+    glAttachShader( m_program, vertshader );
+    glAttachShader( m_program, fragshader );
+    glLinkProgram( m_program );
+
+    // Linking the shader is the easy part, all this junk down here is for printing the error it might generate.
+    int result;
+    int logLength;
+    glGetProgramiv( m_program, GL_LINK_STATUS, &result);
+    glGetProgramiv( m_program, GL_INFO_LOG_LENGTH, &logLength);
+    if ( result == GL_FALSE ) {
+        char* errormsg = new char[ logLength ];
+        glGetProgramInfoLog( m_program, logLength, NULL, errormsg );
+        fprintf( stderr, "%s\n", errormsg );
+        delete[] errormsg;
+        return 1;
+    }
+    return 0;
+}
+
+unsigned int slop::Shader::getUniformLocation( std::string name ) {
+    if ( !m_good ) {
+        return 0;
+    }
+    glUseProgram( m_program );
+    return glGetUniformLocation( m_program, name.c_str() );
+}
+
+void slop::Shader::setParameter( std::string name, int foo ) {
+    if ( !m_good ) {
+        return;
+    }
+    glUniform1i( getUniformLocation( name ), foo );
+}
+
+void slop::Shader::setParameter( std::string name, float foo ) {
+    if ( !m_good ) {
+        return;
+    }
+    glUniform1f( getUniformLocation( name ), foo );
+}
+
+void slop::Shader::setParameter( std::string name, glm::mat4 foo ) {
+    if ( !m_good ) {
+        return;
+    }
+    glUniformMatrix4fv( getUniformLocation( name ), 1, GL_FALSE, glm::value_ptr( foo ) );
+}
+
+void slop::Shader::setParameter( std::string name, glm::vec4 foo ) {
+    if ( !m_good ) {
+        return;
+    }
+    glUniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w );
+}
+
+void slop::Shader::setParameter( std::string name, glm::vec2 foo ) {
+    if ( !m_good ) {
+        return;
+    }
+    glUniform2f( getUniformLocation( name ), foo.x, foo.y );
+}
+
+void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
+    unsigned int a = glGetAttribLocation( m_program, name.c_str() );
+    glEnableVertexAttribArray( a );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer );
+    glVertexAttribPointer( a, stepsize, GL_FLOAT, GL_FALSE, 0, NULL );
+    m_activeattribs.push_back( a );
+}
+
+void slop::Shader::unbind() {
+    for ( unsigned int i=0; i<m_activeattribs.size(); i++ ) {
+        glDisableVertexAttribArray( m_activeattribs[i] );
+    }
+    m_activeattribs.clear();
+    glUseProgram( 0 );
+}

src/shader.hpp

+// shader.hpp: Loads shaders into opengl
+
+#ifndef IS_SHADER_H_
+#define IS_SHADER_H_
+
+#include <string>
+#include <cstdio>
+#include <vector>
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <GL/glew.h>
+#include <string>
+#include <fstream>
+#include <streambuf>
+
+namespace slop {
+
+class Shader {
+public:
+    Shader( std::string name, std::string vert, std::string frag, std::string shadertype = "other" );
+    ~Shader();
+    unsigned int    getProgram();
+    std::string     m_name;
+    void            bind();
+    void            unbind();
+    void            setParameter( std::string name, int foo );
+    void            setParameter( std::string name, float foo );
+    void            setParameter( std::string name, glm::mat4 foo );
+    void            setParameter( std::string name, glm::vec4 foo );
+    void            setParameter( std::string name, glm::vec2 foo );
+    void            setAttribute( std::string name, unsigned int buffer, unsigned int stepsize );
+    int             m_type;
+private:
+    std::vector<unsigned int>   m_activeattribs;
+    bool                        m_good;
+    unsigned int                getUniformLocation( std::string );
+    int                         compile( unsigned int shader );
+    int                         link( unsigned int vert, unsigned int frag );
+    unsigned int                m_program;
+};
+
+};
+
+#endif // IS_SHADER_H_