C++ (Cpp) generate_fragment_shader Examples

Example #1

File: blur.c Project: zygzagZ/i3lock-blur

void glx_init(int scr, int w, int h, int radius, float sigma) {
    int i;
    configs = glXChooseFBConfig(display, scr, pixmap_config, &i);
    vis = glXGetVisualFromFBConfig(display, configs[0]);
    ctx = glXCreateContext(display, vis, NULL, True);

    glXBindTexImageEXT_f = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress(
        (GLubyte *)"glXBindTexImageEXT");
    if (glXBindTexImageEXT_f == NULL) {
        errx(EXIT_FAILURE, "Failed to load extension glXBindTexImageEXT.\n");
    }

    glXReleaseTexImageEXT_f = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress(
        (GLubyte *)"glXReleaseTexImageEXT");

    if (glXReleaseTexImageEXT_f == NULL) {
        errx(EXIT_FAILURE, "Failed to load extension glXReleaseTexImageEXT.\n");
    }

    tmp = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                        vis->depth);
    glx_tmp = glXCreatePixmap(display, configs[0], tmp, pixmap_attribs);
    glXMakeCurrent(display, glx_tmp, ctx);

    tmp1 = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                         vis->depth);
    glx_tmp1 = glXCreatePixmap(display, configs[0], tmp1, pixmap_attribs);

    v_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(v_shader, 1, &VERT_SHADER, NULL);
    glCompileShader(v_shader);
    glGetShaderiv(v_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
    printf("V Shader: %d\n", i);
    printShaderInfoLog(v_shader);
#endif
    f_shader = glCreateShader(GL_FRAGMENT_SHADER);
    char *fragment_shader = generate_fragment_shader(radius, sigma);
    GLchar const *files[] = {fragment_shader};
    glShaderSource(f_shader, 1, files, NULL);
    free(fragment_shader);
    glCompileShader(f_shader);
    glGetShaderiv(f_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
    printf("F Shader: %d\n", i);
    printShaderInfoLog(f_shader);
#endif
    shader_prog = glCreateProgram();
    glAttachShader(shader_prog, v_shader);
    glAttachShader(shader_prog, f_shader);
    glLinkProgram(shader_prog);
    glGetShaderiv(f_shader, GL_LINK_STATUS, &i);
#if DEBUG_GL
    printf("Program: %d\n", i);
    printShaderInfoLog(f_shader);
    printProgramInfoLog(shader_prog);
#endif
}

Example #2

File: gl_program.cpp Project: tomalexander/topaz

    void gl_program::create_program()
    {
        vector<string> uniforms;
        program_id = glCreateProgram();
        GLuint fragment_id = glCreateShader(GL_FRAGMENT_SHADER);
        GLuint vertex_id = glCreateShader(GL_VERTEX_SHADER);
        
        string vertex_shader = generate_vertex_shader(uniforms);
        string fragment_shader = generate_fragment_shader(uniforms);
        debug_flags(PRINT_SHADERS, "---------- Vertex Shader ----------\n%s\n", vertex_shader.c_str());
        debug_flags(PRINT_SHADERS, "---------- Fragment Shader ----------\n%s\n", fragment_shader.c_str());
        
        const char* _vertex_shader = vertex_shader.c_str();
        const char* _fragment_shader = fragment_shader.c_str();

        glShaderSource(fragment_id, 1, &(_fragment_shader), NULL);
        glCompileShader(fragment_id);

        glShaderSource(vertex_id, 1, &(_vertex_shader), NULL);
        glCompileShader(vertex_id);

        check_shader(fragment_id);
        check_shader(vertex_id);

        //Link all the things
        glAttachShader(program_id, fragment_id);
        glAttachShader(program_id, vertex_id);
        glLinkProgram(program_id);
        CHECK_GL_ERROR("Linking Program");

        //Use the program
        glUseProgram(program_id);
        CHECK_GL_ERROR("Use Program");

        //Add the IDs to array so they get deleted in cleanup
        shader_ids.push_back(fragment_id);
        shader_ids.push_back(vertex_id);

        for (const string & cur : uniforms)
        {
            GLuint uniform_loc = glGetUniformLocation(program_id, cur.c_str());
            uniform_locations.insert(make_pair(cur, uniform_loc));
            CHECK_GL_ERROR("Getting Uniform Location for " + cur);
        }
    }