fixed nvidia transparency issues

CMakeLists.txt

 find_package(XExt REQUIRED)
 find_package(GLX REQUIRED)
 find_package(OpenGL REQUIRED)
+find_package(XRender REQUIRED)
 
 include_directories(${X11_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}
                     ${XEXT_INCLUDE_DIR}
                     ${GLX_INCLUDE_DIR}
+		    ${XRENDER_INCLUDE_DIR}
                     ${OPENGL_INCLUDE_DIR})
 
 target_link_libraries(${LIBRARY_NAME} ${X11_LIBRARIES}
                                       ${GLM_LIBRARIES}
                                       ${OPENGL_LIBRARIES}
                                       ${GLX_LIBRARY}
+				      ${XRENDER_LIBRARY}
                                       ${XEXT_LIBRARIES})
 
 target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME})

modules/FindXRender.cmake

+# - Find XRender
+# Find the XRender libraries
+#
+# This module defines the following variables:
+#   XRENDER_FOUND - true if XRENDER_INCLUDE_DIR & XRENDER_LIBRARY are found
+#   XRENDER_LIBRARIES - Set when Xrender_LIBRARY is found
+#   XRENDER_INCLUDE_DIRS - Set when Xrender_INCLUDE_DIR is found
+#
+#   XRENDER_INCLUDE_DIR - where to find Xrender.h, etc.
+#   XRENDER_LIBRARY - the Xrender library
+#
+
+#=============================================================================
+# Copyright 2013 Corey Clayton <can.of.tuna@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#=============================================================================
+
+find_path(XRENDER_INCLUDE_DIR NAMES X11/extensions/Xrender.h
+          PATHS /opt/X11/include
+          DOC "The Xrender include directory")
+
+find_library(XRENDER_LIBRARY NAMES Xrender
+          PATHS /opt/X11/lib
+          DOC "The Xrender library")
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Xrender DEFAULT_MSG XRENDER_LIBRARY XRENDER_INCLUDE_DIR)
+
+if(XRENDER_FOUND)
+
+    set(XRENDER_LIBRARIES ${XRENDER_LIBRARY})
+    set(XRENDER_INCLUDE_DIRS ${XRENDER_INCLUDE_DIR})
+
+endif()
+
+mark_as_advanced(XRENDER_INCLUDE_DIR XRENDER_LIBRARY)

src/framebuffer.cpp

 
 slop::Framebuffer::Framebuffer( int w, int h ) {
     std::string vert = "#version 130\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 uvCoord;\nvoid main()\n{\nuvCoord = uv;\ngl_Position = vec4(position,0,1);\n}\n";
-    std::string frag = "#version 130\nuniform sampler2D texture;\nvarying vec2 uvCoord;\nout vec4 outColor;void main()\n{\noutColor = texture2D( texture, uvCoord );\n}\n";
+    std::string frag = "#version 130\n uniform sampler2D texture;\n varying vec2 uvCoord;\n out vec4 outColor;\n void main()\n {\n outColor = texture2D( texture, uvCoord );\n }\n";
     shader = new Shader( vert, frag, false );
     glGenFramebuffers( 1, &fbuffer );
     glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
 }
 
 void slop::Framebuffer::draw(){
-    glEnable( GL_BLEND );
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     shader->bind();
     shader->setParameter( "texture", 0 );
     shader->setAttribute( "position", buffers[0], 2 );
     glEnable( GL_TEXTURE_2D );
     glDrawArrays( GL_TRIANGLES, 0, vertCount );
     glDisable( GL_TEXTURE_2D );
-    glDisable( GL_BLEND );
     shader->unbind();
 }

src/glrectangle.cpp

     our = ur + glm::vec2(border,border);
     obr = br + glm::vec2(border,-border);
     generateBuffers();
-    std::string vert = "#version 130\nin vec2 position;\nuniform mat4 projection;\nvoid main() {\ngl_Position = projection*vec4(position,0,1);\n }";
-    std::string frag = "#version 130\nuniform vec4 color;\nout vec4 outColor;\nvoid main() {\noutColor = color;\n}";
+    std::string vert = "#version 130\n in vec2 position;\n uniform mat4 projection;\n void main() {\n gl_Position = projection*vec4(position,0,1);\n }";
+    std::string frag = "#version 130\n uniform vec4 color;\n out vec4 outColor;\n void main() {\n outColor = color;\n }";
 
     shader = new Shader( vert, frag, false );
 }
 }
 
 void slop::GLRectangle::draw( glm::mat4& matrix ) {
-    glEnable( GL_BLEND );
-    glBlendFunc(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 ) {
         glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
     }
     shader->unbind();
-    glDisable( GL_BLEND );
+    //glDisable( GL_BLEND );
 }
 
 glm::vec4 slop::GLRectangle::getRect() {

src/options.cpp

     validArguments.push_back( Argument( "padding",      'p', false ) );
     validArguments.push_back( Argument( "color",        'c', false ) );
     validArguments.push_back( Argument( "shader",       'r', false ) );
-    validArguments.push_back( Argument( "highlight",    'h', true ) );
+    validArguments.push_back( Argument( "highlight",    'l', true ) );
     validArguments.push_back( Argument( "format",       'f', false ) );
     validArguments.push_back( Argument( "tolerance",    't', false ) );
     validArguments.push_back( Argument( "nodecorations", 'n', false ) );

src/slop.cpp

         window->framebuffer->unbind();
 
         // Then we draw the framebuffer to the screen
-        glClearColor (0.0, 0.0, 0.0, 0.0);
-        glClear (GL_COLOR_BUFFER_BIT);
         window->framebuffer->draw();
         window->display();
         GLenum err = glGetError();

src/window.cpp

 using namespace slop;
 
 slop::SlopWindow::SlopWindow() {
-    XVisualInfo visual;
-    XMatchVisualInfo(x11->display, DefaultScreen(x11->display), 32, TrueColor, &visual);
+    // Load up a opengl context
+    static int attributeList[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                                   GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+                                   GLX_DOUBLEBUFFER, True,
+                                   GLX_RED_SIZE, 1,
+                                   GLX_GREEN_SIZE, 1,
+                                   GLX_BLUE_SIZE, 1,
+                                   GLX_ALPHA_SIZE, 1,
+				   GLX_DEPTH_SIZE, 1,
+                                   None };
+    int nelements;
+    int render_event_base, render_error_base;
+    if(!XRenderQueryExtension(x11->display, &render_event_base, &render_error_base)) {
+        throw new std::runtime_error("No XRENDER extension found\n");
+    }
+
+    GLXFBConfig* fbc = glXChooseFBConfig(x11->display, DefaultScreen(x11->display), attributeList, &nelements);
+    GLXFBConfig fbconfig;
+    if ( !fbc ) {
+        throw new std::runtime_error("No matching visuals available.\n");
+    }
+    XVisualInfo* vi ;
+    XRenderPictFormat *pictFormat;
+    int i;
+    for (i=0; i<nelements; i++) {
+        vi = glXGetVisualFromFBConfig(x11->display, fbc[i]);
+        if (!vi) { continue; }
+        pictFormat = XRenderFindVisualFormat(x11->display, vi->visual);
+        if (!pictFormat) { continue; }
+        if(pictFormat->direct.alphaMask > 0) {
+            fbconfig = fbc[i];
+            break;
+        }
+    }
+    if (i == nelements ) {
+	    throw new std::runtime_error( "No matching visuals available" );
+    }
 
     XSetWindowAttributes attributes;
-    attributes.colormap = XCreateColormap( x11->display, x11->root, visual.visual, AllocNone );
+    attributes.colormap = XCreateColormap(x11->display, RootWindow(x11->display, vi->screen), vi->visual, AllocNone);
     attributes.background_pixmap = None;
     attributes.border_pixel = 0;
     // Disable window decorations.
 
 
     // Create the window
-    window = XCreateWindow( slop::x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
-                            0, visual.depth, InputOutput,
-                            visual.visual, valueMask, &attributes );
+    window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
+                            0, vi->depth, InputOutput,
+                            vi->visual, valueMask, &attributes );
 
     if ( !window ) {
         throw new std::runtime_error( "Couldn't create a GL window!" );
     }
 
-	// Prep some hints for the window
+    // Prep some hints for the window
     static char title[] = "slop";
     XWMHints* startup_state = XAllocWMHints();
     startup_state->initial_state = NormalState;
     char name[] = "slop";
     classhints.res_name = name;
     classhints.res_class = name;
-	// Finally send it all over...
+    // Finally send it all over...
     XSetClassHint( x11->display, window, &classhints );
     XSetWMProperties( x11->display, window, &textprop, &textprop, NULL, 0, &sizehints, startup_state, NULL );
     XFree( startup_state );
-	// Keep the window on top of all other windows.
-	Atom stateAbove = XInternAtom(x11->display, "_NET_WM_STATE_ABOVE", False);
-	XChangeProperty(x11->display, window, XInternAtom(x11->display, "_NET_WM_STATE", False), XA_ATOM, 32, PropModeReplace, (unsigned char *) &stateAbove, 1);
+    // Keep the window on top of all other windows.
+    Atom stateAbove = XInternAtom(x11->display, "_NET_WM_STATE_ABOVE", False);
+    XChangeProperty(x11->display, window, XInternAtom(x11->display, "_NET_WM_STATE", False), XA_ATOM, 32, PropModeReplace, (unsigned char *) &stateAbove, 1);
 
-    // Load up a opengl context
-    context = glXCreateContext( x11->display, &visual, 0, True );
+    context = glXCreateNewContext( x11->display, fbconfig, GLX_RGBA_TYPE, 0, True );
     if ( !context ) {
-		throw new std::runtime_error( "Failed to create an OpenGL context." );
+        throw new std::runtime_error( "Failed to create an OpenGL context." );
     }
     setCurrent();
     // Finally we grab some OpenGL 3.3 stuffs.
     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)
-	XMapWindow( x11->display, window );
+    XMapWindow( x11->display, window );
 }
 
 slop::SlopWindow::~SlopWindow() {

src/window.hpp

 #include <iostream>
 #include "gl_core_3_3.h"
 #include <GL/gl.h>
+#define GL_GLEXT_PROTOTYPES
+#define GLX_GLXEXT_PROTOTYPES
 #include <GL/glx.h>
+#include <GL/glxext.h>
 #include <glm/gtc/matrix_transform.hpp>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
+#include <X11/extensions/Xrender.h>
 
 #include "x.hpp"
 #include "framebuffer.hpp"