increased accuracy of mouse, some more shader polish

CMakeLists.txt

 
 include_directories("${PROJECT_BINARY_DIR}")
 
-add_definitions(-DSLOP_VERSION="v5.3.35")
+add_definitions(-DSLOP_VERSION="v5.3.36")
 
 # The names have to be unique unfortunately.
 set(EXECUTABLE_NAME "slop")

shaderexamples/blur1.frag

+#version 120
+
+uniform sampler2D texture;
+uniform sampler2D desktop;
+uniform vec2 screenSize;
+
+varying vec2 uvCoord;
+
+// Stolen from https://github.com/Jam3/glsl-fast-gaussian-blur kinda
+void main()
+{
+    float radius = 1;
+    vec2 upsideDownUV = vec2( uvCoord.x, -uvCoord.y );
+    vec4 color = vec4(0.0);
+    vec2 off1 = vec2(1.411764705882353) * vec2( radius, 0 );
+    vec2 off2 = vec2(3.2941176470588234) * vec2( radius, 0 );
+    vec2 off3 = vec2(5.176470588235294) * vec2( radius, 0 );
+    color += texture2D(desktop, upsideDownUV) * 0.1964825501511404;
+    color += texture2D(desktop, upsideDownUV + (off1 / screenSize)) * 0.2969069646728344;
+    color += texture2D(desktop, upsideDownUV - (off1 / screenSize)) * 0.2969069646728344;
+    color += texture2D(desktop, upsideDownUV + (off2 / screenSize)) * 0.09447039785044732;
+    color += texture2D(desktop, upsideDownUV - (off2 / screenSize)) * 0.09447039785044732;
+    color += texture2D(desktop, upsideDownUV + (off3 / screenSize)) * 0.010381362401148057;
+    color += texture2D(desktop, upsideDownUV - (off3 / screenSize)) * 0.010381362401148057;
+    gl_FragColor = (texture2D(texture, uvCoord) * color);
+}

shaderexamples/blur1.vert

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

shaderexamples/blur2.frag

+#version 120
+
+uniform sampler2D texture;
+uniform vec2 screenSize;
+
+varying vec2 uvCoord;
+
+// Stolen from https://github.com/Jam3/glsl-fast-gaussian-blur kinda
+void main()
+{
+    float radius = 1;
+    vec4 color = vec4(0.0);
+    vec2 off1 = vec2(1.411764705882353) * vec2( 0, radius );
+    vec2 off2 = vec2(3.2941176470588234) * vec2( 0, radius );
+    vec2 off3 = vec2(5.176470588235294) * vec2( 0, radius );
+    color += texture2D(texture, uvCoord) * 0.1964825501511404;
+    color += texture2D(texture, uvCoord + (off1 / screenSize)) * 0.2969069646728344;
+    color += texture2D(texture, uvCoord - (off1 / screenSize)) * 0.2969069646728344;
+    color += texture2D(texture, uvCoord + (off2 / screenSize)) * 0.09447039785044732;
+    color += texture2D(texture, uvCoord - (off2 / screenSize)) * 0.09447039785044732;
+    color += texture2D(texture, uvCoord + (off3 / screenSize)) * 0.010381362401148057;
+    color += texture2D(texture, uvCoord - (off3 / screenSize)) * 0.010381362401148057;
+    gl_FragColor = color;
+}

shaderexamples/blur2.vert

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

shaderexamples/crosshair.frag

+#version 120
+
+uniform sampler2D texture;
+uniform sampler2D desktop;
+uniform vec2 screenSize;
+uniform vec2 mouse;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    // adjustable parameters
+    float circleSize = 128;
+    float borderSize = 2;
+    // The smaller this value is, the more intense the magnification!
+    float magnifyNerf = 1.1;
+    vec4 borderColor = vec4(0,0,0,1);
+    bool crosshair = true;
+
+    // actual code
+    vec2 mUV = vec2(mouse.x, -mouse.y)/screenSize + vec2(0,1);
+    float du = distance(mUV,uvCoord);
+    float dr = distance(mUV*screenSize,uvCoord*screenSize);
+    vec4 color = vec4(0);
+    if ( dr > circleSize+borderSize ) {
+        color = texture2D( texture, uvCoord );
+    } else if ( dr < circleSize ) {
+        if ( crosshair && (distance(mUV.x, uvCoord.x)<1/screenSize.x || distance(mUV.y,uvCoord.y)<1/screenSize.y) ) {
+            color = borderColor;
+        } else {
+            float t = 1-du;
+            vec2 b = uvCoord;
+            vec2 c = (mUV-uvCoord);
+            vec2 upsideDown = c/magnifyNerf*t*t+b;
+
+            vec4 textureColor = texture2D( texture, upsideDown );
+            color = texture2D( desktop, vec2(upsideDown.x, -upsideDown.y) )*(1-textureColor.a) + textureColor;
+        }
+    } else if ( dr < circleSize+borderSize ) {
+        color = borderColor;
+    }
+    gl_FragColor = color;
+}

shaderexamples/crosshair.vert

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

shaderexamples/wiggle.frag

+#version 120
+
+uniform sampler2D texture;
+uniform vec2 screenSize;
+uniform float time;
+
+varying vec2 uvCoord;
+
+void main()
+{
+    // Higher strength means bigger wobble
+    float strength = 10;
+    float flatness = 4;
+    // Higher speed means faster wobble
+    float speed = 2;
+    float variation = cos(time);
+
+    float x = uvCoord.x + (sin( time*speed + uvCoord.y/flatness * screenSize.y/strength ) + 0.5)/screenSize.x*strength;
+    float y = uvCoord.y + variation*(cos( time*speed + uvCoord.x/flatness * screenSize.x/strength ) + 0.5)/screenSize.y*strength;
+    gl_FragColor = texture2D( texture, vec2( x, y ) );
+}

shaderexamples/wiggle.vert

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

src/framebuffer.cpp

     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_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    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);
 void slop::Framebuffer::setShader( slop::Shader* shader ) {
     this->shader = shader;
     if ( shader->hasParameter( "desktop" ) && !generatedDesktopImage ) {
+        // Try to keep the image from being changed under our feet.
+        XGrabServer(x11->display);
         XImage* image = XGetImage( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0xffffffff, ZPixmap );
+        XUngrabServer(x11->display);
         glEnable(GL_TEXTURE_2D);
         glGenTextures(1, &desktopImage);
         glBindTexture(GL_TEXTURE_2D, desktopImage);

src/slopstates.cpp

     char a = startPoint.y > mouse->getMousePos().y;
     char b = startPoint.x > mouse->getMousePos().x;
     char c = (a << 1) | b;
+    int xm = (mouse->getMousePos().x == 0 || mouse->getMousePos().x == WidthOfScreen(x11->screen)-1);
+    int ym = (mouse->getMousePos().y == 0 || mouse->getMousePos().y == HeightOfScreen(x11->screen)-1);
     switch ( c ) {
         case 0: mouse->setCursor( XC_lr_angle );
-                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1,1));
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1*xm,1*ym));
                 break;
         case 1: mouse->setCursor( XC_ll_angle );
-                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1,1));
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1*xm,1*ym));
                 break;
         case 2: mouse->setCursor( XC_ur_angle );
-                memory.rectangle->setPoints(startPoint+glm::vec2(0,1), mouse->getMousePos()+glm::vec2(1,0));
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,1*ym), mouse->getMousePos()+glm::vec2(1*xm,0));
                 break;
         case 3: mouse->setCursor( XC_ul_angle );
-                memory.rectangle->setPoints(startPoint+glm::vec2(1,1), mouse->getMousePos()+glm::vec2(0,0));
+                memory.rectangle->setPoints(startPoint+glm::vec2(1*xm,1*ym), mouse->getMousePos()+glm::vec2(0,0));
                 break;
     }
     if ( !mouse->getButton( 1 ) ) {