flushed out shader support

CMakeLists.txt

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

src/framebuffer.cpp

 #include "framebuffer.hpp"
 
 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\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 );
     glGenTextures(1, &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_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
     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;
 }
 
-void slop::Framebuffer::setShader( std::string name ) {
-    delete shader;
-    shader = new Shader( name + ".vert", name + ".frag" );
+void slop::Framebuffer::setShader( slop::Shader* shader ) {
+    this->shader = shader;
+    if ( shader->hasParameter( "desktop" ) && !generatedDesktopImage ) {
+        XImage* image = XGetImage( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0xffffffff, ZPixmap );
+        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() {
     glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
-void slop::Framebuffer::draw(){
+void slop::Framebuffer::draw(glm::vec2 mouse, float time, glm::vec4 color){
     shader->bind();
     shader->setParameter( "texture", 0 );
     shader->setAttribute( "position", buffers[0], 2 );
     shader->setAttribute( "uv", buffers[1], 2 );
+    if ( shader->hasParameter( "mouse" ) ) {
+        shader->setParameter( "mouse", mouse );
+    }
+    if ( shader->hasParameter( "color" ) ) {
+        shader->setParameter( "color", color );
+    }
+    if ( shader->hasParameter( "screenSize" ) ) {
+        shader->setParameter( "screenSize", glm::vec2( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) ));
+    }
+    if ( shader->hasParameter( "time" ) ) {
+        shader->setParameter( "time", time );
+    }
     glActiveTexture(GL_TEXTURE0);
     glBindTexture( GL_TEXTURE_2D, image );
+    if ( shader->hasParameter( "desktop" ) ) {
+		shader->setParameter( "desktop", 1 );
+        glActiveTexture(GL_TEXTURE0 + 1);
+        glBindTexture( GL_TEXTURE_2D, desktopImage );
+    }
     glEnable( GL_TEXTURE_2D );
     glDrawArrays( GL_TRIANGLES, 0, vertCount );
     glDisable( GL_TEXTURE_2D );

src/framebuffer.hpp

     unsigned int image;
     unsigned int buffers[2];
     unsigned int vertCount;
+    unsigned int desktopImage;
+    bool generatedDesktopImage;
     Shader* shader;
 public:
     Framebuffer( int w, int h );
     ~Framebuffer();
-    void setShader( std::string );
-    void draw();
+    void setShader( slop::Shader* shader );
+    void draw(glm::vec2 mouse, float time, glm::vec4 color);
     void resize( int w, int h );
     void bind();
     void unbind();

src/main.cpp

 
 using namespace slop;
 
+template<typename Out>
+static void split(const std::string &s, char delim, Out result) {
+    std::stringstream ss;
+    ss.str(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        *(result++) = item;
+    }
+}
+static std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    split(s, delim, std::back_inserter(elems));
+    return elems;
+}
+
 SlopOptions* getOptions( Options& options ) {
     SlopOptions* foo = new SlopOptions();
     options.getFloat("bordersize", 'b', foo->borderSize);
     options.getBool("nokeyboard", 'k', foo->nokeyboard);
     options.getBool("noopengl", 'o', foo->noopengl);
     options.getString( "xdisplay", 'x', foo->xdisplay );
-    options.getString( "shader", 's', foo->shader );
+    std::string shaders = "textured";
+    options.getString( "shader", 'r', shaders );
+    foo->shaders = split( shaders, ',' );
     foo->r = color.r;
     foo->g = color.g;
     foo->b = color.b;

src/shader.cpp

         vert = resource->getRealPath(vert);
         frag = resource->getRealPath(frag);
         std::ifstream v( vert.c_str() );
+        if (!v.is_open()) {
+            throw new std::runtime_error( "Failed to open " + vert );
+        }
         vert_contents = std::string((std::istreambuf_iterator<char>(v)),
                                    std::istreambuf_iterator<char>());
         std::ifstream f( frag.c_str() );
+        if (!f.is_open()) {
+            throw new std::runtime_error( "Failed to open " + frag );
+        }
         frag_contents = std::string((std::istreambuf_iterator<char>(f)),
                                   std::istreambuf_iterator<char>());
     } else {
     return glGetUniformLocation( program, name.c_str() );
 }
 
+bool slop::Shader::hasParameter( std::string name ) {
+    glUseProgram( program );
+    return glGetUniformLocation( program, name.c_str() ) != -1;
+}
+
 void slop::Shader::setParameter( std::string name, int foo ) {
     glUniform1i( getUniformLocation( name ), foo );
 }

src/shader.hpp

 #include <GL/gl.h>
 
 #include "resource.hpp"
+#include "x.hpp"
 
 namespace slop {
 
     unsigned int    getProgram();
     void            bind();
     void            unbind();
+    bool            hasParameter( std::string name );
     void            setParameter( std::string name, int foo );
     void            setParameter( std::string name, float foo );
     void            setParameter( std::string name, glm::mat4& foo );

src/slop.cpp

     nodecorations = false;
     tolerance = 2;
     padding = 0;
-    shader = "textured";
+    shaders.push_back("textured");
     highlight = false;
     r = 0.5;
     g = 0.5;
 slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, bool* cancelled, SlopWindow* window ) {
     slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window );
 
-    if ( options->shader != "textured" ) {
-        window->framebuffer->setShader( options->shader );
+    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\n uniform sampler2D texture;\n varying vec2 uvCoord;\n out vec4 outColor;\n void main()\n {\n outColor = texture2D( texture, uvCoord );\n }\n";
+    slop::Shader* textured = new slop::Shader( vert, frag, false );
+    std::vector<slop::Shader*> shaders;
+    for( int i=0;i<options->shaders.size();i++ ) {
+        std::string sn = options->shaders[i];
+        if ( sn != "textured" ) {
+            shaders.push_back( new slop::Shader( sn + ".vert", sn + ".frag" ) );
+        } else {
+            shaders.push_back( textured );
+        }
     }
-
     // Init our little state machine, memory is a tad of a misnomer
     slop::SlopMemory memory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
 
+    slop::Framebuffer* pingpong;
+    if ( shaders.size() > 1 ) {
+        pingpong = new slop::Framebuffer(WidthOfScreen(x11->screen), HeightOfScreen(x11->screen));
+    }
+
     // This is where we'll run through all of our stuffs
+    auto start = std::chrono::high_resolution_clock::now();
     while( memory.running ) {
         slop::mouse->update();
         if ( !options->nokeyboard ) {
         memory.update( 1 );
 
         // Then we draw our junk to a framebuffer.
+        window->framebuffer->setShader( textured );
         window->framebuffer->bind();
         glClearColor (0.0, 0.0, 0.0, 0.0);
         glClear (GL_COLOR_BUFFER_BIT);
         memory.draw( window->camera );
         window->framebuffer->unbind();
 
-        // Then we draw the framebuffer to the screen
-        window->framebuffer->draw();
+        auto end = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double, std::milli> elapsed = end-start;
+        if ( shaders.size() > 1 ) {
+            int i;
+            // We have our clean buffer, now to slather it with some juicy shader chains.
+            for (i=0;i<=(int)shaders.size()-2;i+=2) {
+                pingpong->bind();
+                glClearColor (0.0, 0.0, 0.0, 0.0);
+                glClear (GL_COLOR_BUFFER_BIT);
+                window->framebuffer->setShader( shaders[i] );
+                window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
+                pingpong->unbind();
+
+                window->framebuffer->bind();
+                glClearColor (0.0, 0.0, 0.0, 0.0);
+                glClear (GL_COLOR_BUFFER_BIT);
+                pingpong->setShader( shaders[i+1] );
+                pingpong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
+                window->framebuffer->unbind();
+            }
+            for (;i<shaders.size();i++) {
+                pingpong->bind();
+                glClearColor (0.0, 0.0, 0.0, 0.0);
+                glClear (GL_COLOR_BUFFER_BIT);
+                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();
+            }
+            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 {
+                pingpong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
+            }
+        } else {
+            window->framebuffer->setShader( shaders[0] );
+            window->framebuffer->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) );
+        }
+
         window->display();
         GLenum err = glGetError();
         if ( err != GL_NO_ERROR ) {
-            throw err;
+            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;
+            }
+            throw new std::runtime_error( "OpenGL threw an error: " + error );
         }
         if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
             memory.running = false;

src/slop.hpp

 #define N_SLOP_H_
 
 #include <string>
+#include <vector>
 
 namespace slop {
 
     bool noopengl;
     bool nokeyboard;
     int nodecorations;
-    std::string shader;
+    std::vector<std::string> shaders;
     float r;
     float g;
     float b;