slop no longer needs files installed to function, it can still load custom shaders from ~/.config/slop though

CMakeLists.txt

 #Change this if you need to target a specific CMake version
 cmake_minimum_required(VERSION 3.1)
 
-add_definitions(-DSLOP_VERSION="v5.3.21")
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)" FORCE)
-endif()
-
-if( NOT CMAKE_INSTALL_PREFIX )
-    set( CMAKE_INSTALL_PREFIX "/usr" )
-endif()
-
-if( NOT SHADER_PREFIX )
-    set( SHADER_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path where slop thinks it resides in, so that it can find the shaders. This is not necessarily the CMAKE_INSTALL_PREFIX. For example if the shaders will exist in /usr/share/slop, SHADER_PREFIX should be \"/usr\"." )
+set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)")
+if ( NOT CMAKE_INSTALL_PREFIX )
+    set(CMAKE_INSTALL_PREFIX "/usr")
 endif()
 
 project(slop)
+add_definitions(-DSLOP_VERSION="v5.3.21")
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED on)
 
 # Install targets
 install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
-install( DIRECTORY "${CMAKE_SOURCE_DIR}/share" DESTINATION "${CMAKE_INSTALL_PREFIX}" )
-
-add_definitions(-DSHADER_PREFIX="${SHADER_PREFIX}")

share/slop/simple.frag

-#version 130
-
-uniform vec4 color;
-out vec4 outColor;
-
-void main()
-{
-    outColor = color;
-}

share/slop/simple.vert

-#version 130
-
-in vec2 position;
-uniform mat4 projection;
-
-void main()
-{
-    gl_Position = projection*vec4(position,0,1);
-}

share/slop/textured.frag

-#version 130
-
-uniform sampler2D texture;
-
-varying vec2 uvCoord;
-
-out vec4 outColor;
-
-void main()
-{
-    outColor = texture2D( texture, uvCoord );
-}
-

share/slop/textured.vert

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

src/framebuffer.cpp

 #include "framebuffer.hpp"
 
 Framebuffer::Framebuffer( int w, int h ) {
-    shader = new Shader( "textured.vert", "textured.frag" );
+    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";
+    shader = new Shader( vert, frag, false );
     glGenFramebuffers( 1, &fbuffer );
     glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
     glGenTextures(1, &image);

src/main.cpp

     glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
     options.getColor("color", 'c', color);
     options.getString( "xdisplay", 'x', foo->xdisplay );
+    options.getString( "shader", 's', foo->shader );
     foo->r = color.r;
     foo->g = color.g;
     foo->b = color.b;

src/rectangle.cpp

     our = ur + glm::vec2(border,border);
     obr = br + glm::vec2(border,-border);
     generateBuffers();
-    shader = new Shader( "simple.vert", "simple.frag" );
+    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}";
+
+    shader = new Shader( vert, frag, false );
 }
 
 void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {

src/resource.cpp

         char* home = getpwuid(getuid())->pw_dir;
         usrconfig += home;
         usrconfig += "/.config/slop/";
-        // SHADER_PREFIX is defined by the user within CMake, defaults to `/usr`.
-        sysconfig = SHADER_PREFIX;
-        sysconfig += "/share/slop/";
         return;
     }
     usrconfig += config;
     usrconfig += "/slop/";
-    sysconfig = SHADER_PREFIX;
-    sysconfig += "/share/slop/";
 }
 
 std::string Resource::getRealPath( std::string localpath ) {
     if ( validatePath( usrconfig + localpath ) ) {
         return usrconfig + localpath;
     }
-    if ( validatePath( sysconfig + localpath ) ) {
-        return sysconfig + localpath;
-    }
-    std::string err = "The file or folder " + localpath + " was not found in either " + sysconfig + " or " + usrconfig + "\n";
+    std::string err = "The file or folder " + localpath + " was not found in " + usrconfig + "\n";
     throw new std::runtime_error(err);
     return localpath;
 }

src/resource.hpp

 private:
     bool validatePath( std::string path );
     std::string usrconfig;
-    std::string sysconfig;
 };
 
 extern Resource* resource;

src/shader.cpp

 #include "shader.hpp"
 
-Shader::Shader( std::string vert, std::string frag) {
-    vert = resource->getRealPath(vert);
-    frag = resource->getRealPath(frag);
-    // 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>());
+Shader::Shader( std::string vert, std::string frag, bool file ) {
+    std::string vert_contents;
+    std::string frag_contents;
+    if ( file ) {
+        vert = resource->getRealPath(vert);
+        frag = resource->getRealPath(frag);
+        std::ifstream v( vert.c_str() );
+        vert_contents = std::string((std::istreambuf_iterator<char>(v)),
+                                   std::istreambuf_iterator<char>());
+        std::ifstream f( frag.c_str() );
+        frag_contents = std::string((std::istreambuf_iterator<char>(f)),
+                                  std::istreambuf_iterator<char>());
+    } else {
+        vert_contents = vert;
+        frag_contents = frag;
+    }
 
     const char* vertsrc = vert_contents.c_str();
     const char* fragsrc = frag_contents.c_str();
+
+    // Create the program to link to.
+    program = glCreateProgram();
     
     if ( vert_contents.length() <= 0 ) {
         std::string errstring = "Failed to open file (or is empty) `" + vert + "`.\n";
 }
 
 Shader::~Shader() {
-    glDeleteProgram( m_program );
+    glDeleteProgram( program );
 }
 
 unsigned int Shader::getProgram() {
-    return m_program;
+    return program;
 }
 
 void Shader::bind() {
-    glUseProgram( m_program );
+    glUseProgram( program );
 }
 
 int Shader::compile( unsigned int shader, std::string& error ) {
 }
 
 int Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
-    glAttachShader( m_program, vertshader );
-    glAttachShader( m_program, fragshader );
-    glLinkProgram( m_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 = GL_FALSE;
     int logLength;
-    glGetProgramiv( m_program, GL_LINK_STATUS, &result);
-    glGetProgramiv( m_program, GL_INFO_LOG_LENGTH, &logLength);
+    glGetProgramiv( program, GL_LINK_STATUS, &result);
+    glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logLength);
     if ( result == GL_FALSE ) {
         char* errormsg = new char[ logLength ];
-        glGetProgramInfoLog( m_program, logLength, NULL, errormsg );
+        glGetProgramInfoLog( program, logLength, NULL, errormsg );
         error = errormsg;
         delete[] errormsg;
         return 1;
 }
 
 unsigned int Shader::getUniformLocation( std::string name ) {
-    glUseProgram( m_program );
-    return glGetUniformLocation( m_program, name.c_str() );
+    glUseProgram( program );
+    return glGetUniformLocation( program, name.c_str() );
 }
 
 void Shader::setParameter( std::string name, int foo ) {
 }
 
 void Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
-    unsigned int a = glGetAttribLocation( m_program, name.c_str() );
+    unsigned int a = glGetAttribLocation( 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 );
+    activeAttributes.push_back( a );
 }
 
 void Shader::unbind() {
-    for ( unsigned int i=0; i<m_activeattribs.size(); i++ ) {
-        glDisableVertexAttribArray( m_activeattribs[i] );
+    for ( unsigned int i=0; i<activeAttributes.size(); i++ ) {
+        glDisableVertexAttribArray( activeAttributes[i] );
     }
-    m_activeattribs.clear();
+    activeAttributes.clear();
     glUseProgram( 0 );
 }

src/shader.hpp

 
 class Shader {
 public:
-    Shader( std::string vert, std::string frag );
+    Shader( std::string vert, std::string frag, bool file = true );
     ~Shader();
     unsigned int    getProgram();
     void            bind();
     void            setParameter( std::string name, glm::vec2 foo );
     void            setAttribute( std::string name, unsigned int buffer, unsigned int stepsize );
 private:
-    std::vector<unsigned int>   m_activeattribs;
+    void loadFromFile( std::string vert, std::string frag );
+    void loadFromMemory( std::string vert, std::string frag );
+    std::vector<unsigned int>   activeAttributes;
     unsigned int                getUniformLocation( std::string );
     int                         compile( unsigned int shader, std::string& error );
     int                         link( unsigned int vert, unsigned int frag, std::string& error );
-    unsigned int                m_program;
+    unsigned int                program;
 };
 
 #endif // N_SHADER_H_

src/slop.cpp

     // Set up window with GL context
     SlopWindow* window = new SlopWindow();
 
-    window->framebuffer->setShader( options->shader );
+    if ( options->shader != "textured" ) {
+        window->framebuffer->setShader( options->shader );
+    }
 
     // Init our little state machine, memory is a tad of a misnomer
     SlopMemory memory( options );