static void gl_glsl_find_uniforms_frame(glsl_shader_data_t *glsl,
GLuint prog,
struct shader_uniforms_frame *frame, const char *base)
{
char texture[64];
char texture_size[64];
char input_size[64];
char tex_coord[64];
texture[0] = texture_size[0] = input_size[0] = tex_coord[0] = '\0';
snprintf(texture, sizeof(texture), "%s%s", base, "Texture");
snprintf(texture_size, sizeof(texture_size), "%s%s", base, "TextureSize");
snprintf(input_size, sizeof(input_size), "%s%s", base, "InputSize");
snprintf(tex_coord, sizeof(tex_coord), "%s%s", base, "TexCoord");
if (frame->texture < 0)
frame->texture = gl_glsl_get_uniform(glsl, prog, texture);
if (frame->texture_size < 0)
frame->texture_size = gl_glsl_get_uniform(glsl, prog, texture_size);
if (frame->input_size < 0)
frame->input_size = gl_glsl_get_uniform(glsl, prog, input_size);
if (frame->tex_coord < 0)
frame->tex_coord = gl_glsl_get_attrib(glsl, prog, tex_coord);
}
static void gl_glsl_find_uniforms(glsl_shader_data_t *glsl,
unsigned pass, GLuint prog,
struct shader_uniforms *uni)
{
unsigned i;
char frame_base[64] = {0};
glUseProgram(prog);
uni->mvp = gl_glsl_get_uniform(glsl, prog, "MVPMatrix");
uni->tex_coord = gl_glsl_get_attrib(glsl, prog, "TexCoord");
uni->vertex_coord = gl_glsl_get_attrib(glsl, prog, "VertexCoord");
uni->color = gl_glsl_get_attrib(glsl, prog, "Color");
uni->lut_tex_coord = gl_glsl_get_attrib(glsl, prog, "LUTTexCoord");
uni->input_size = gl_glsl_get_uniform(glsl, prog, "InputSize");
uni->output_size = gl_glsl_get_uniform(glsl, prog, "OutputSize");
uni->texture_size = gl_glsl_get_uniform(glsl, prog, "TextureSize");
uni->frame_count = gl_glsl_get_uniform(glsl, prog, "FrameCount");
uni->frame_direction = gl_glsl_get_uniform(glsl, prog, "FrameDirection");
for (i = 0; i < glsl->shader->luts; i++)
uni->lut_texture[i] = glGetUniformLocation(prog, glsl->shader->lut[i].id);
gl_glsl_clear_uniforms_frame(&uni->orig);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->orig, "Orig");
gl_glsl_clear_uniforms_frame(&uni->feedback);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->feedback, "Feedback");
if (pass > 1)
{
snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->orig, frame_base);
}
for (i = 0; i + 1 < pass; i++)
{
snprintf(frame_base, sizeof(frame_base), "Pass%u", i + 1);
gl_glsl_clear_uniforms_frame(&uni->pass[i]);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->pass[i], frame_base);
snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass - (i + 1));
gl_glsl_find_uniforms_frame(glsl, prog, &uni->pass[i], frame_base);
if (*glsl->shader->pass[i].alias)
gl_glsl_find_uniforms_frame(glsl, prog, &uni->pass[i], glsl->shader->pass[i].alias);
}
gl_glsl_clear_uniforms_frame(&uni->prev[0]);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->prev[0], "Prev");
for (i = 1; i < PREV_TEXTURES; i++)
{
snprintf(frame_base, sizeof(frame_base), "Prev%u", i);
gl_glsl_clear_uniforms_frame(&uni->prev[i]);
gl_glsl_find_uniforms_frame(glsl, prog, &uni->prev[i], frame_base);
}
glUseProgram(0);
}
static bool gl_glsl_compile_program(
void *data,
unsigned idx,
void *program_data,
struct shader_program_info *program_info)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
struct shader_program_glsl_data *program = (struct shader_program_glsl_data*)program_data;
GLuint prog = glCreateProgram();
if (!program)
program = &glsl->prg[idx];
if (!prog)
goto error;
if (program_info->vertex)
{
RARCH_LOG("[GLSL]: Found GLSL vertex shader.\n");
program->vprg = glCreateShader(GL_VERTEX_SHADER);
if (!gl_glsl_compile_shader(
glsl,
program->vprg,
"#define VERTEX\n#define PARAMETER_UNIFORM\n", program_info->vertex))
{
RARCH_ERR("Failed to compile vertex shader #%u\n", idx);
goto error;
}
glAttachShader(prog, program->vprg);
}
if (program_info->fragment)
{
RARCH_LOG("[GLSL]: Found GLSL fragment shader.\n");
program->fprg = glCreateShader(GL_FRAGMENT_SHADER);
if (!gl_glsl_compile_shader(glsl, program->fprg,
"#define FRAGMENT\n#define PARAMETER_UNIFORM\n", program_info->fragment))
{
RARCH_ERR("Failed to compile fragment shader #%u\n", idx);
goto error;
}
glAttachShader(prog, program->fprg);
}
if (program_info->vertex || program_info->fragment)
{
RARCH_LOG("[GLSL]: Linking GLSL program.\n");
if (!gl_glsl_link_program(prog))
goto error;
/* Clean up dead memory. We're not going to relink the program.
* Detaching first seems to kill some mobile drivers
* (according to the intertubes anyways). */
if (program->vprg)
glDeleteShader(program->vprg);
if (program->fprg)
glDeleteShader(program->fprg);
program->vprg = 0;
program->fprg = 0;
glUseProgram(prog);
glUniform1i(gl_glsl_get_uniform(glsl, prog, "Texture"), 0);
glUseProgram(0);
}
program->id = prog;
return true;
error:
RARCH_ERR("Failed to link program #%u.\n", idx);
program->id = 0;
return false;
}
static GLuint gl_glsl_compile_program(glsl_shader_data_t *glsl,
const char *vertex,
const char *fragment, unsigned i)
{
GLuint vert = 0, frag = 0, prog = glCreateProgram();
if (!prog)
return 0;
if (vertex)
{
RARCH_LOG("Found GLSL vertex shader.\n");
vert = glCreateShader(GL_VERTEX_SHADER);
if (!gl_glsl_compile_shader(
glsl,
vert, "#define VERTEX\n#define PARAMETER_UNIFORM\n", vertex))
{
RARCH_ERR("Failed to compile vertex shader #%u\n", i);
return 0;
}
glAttachShader(prog, vert);
}
if (fragment)
{
RARCH_LOG("Found GLSL fragment shader.\n");
frag = glCreateShader(GL_FRAGMENT_SHADER);
if (!gl_glsl_compile_shader(glsl, frag,
"#define FRAGMENT\n#define PARAMETER_UNIFORM\n", fragment))
{
RARCH_ERR("Failed to compile fragment shader #%u\n", i);
return 0;
}
glAttachShader(prog, frag);
}
if (vertex || fragment)
{
RARCH_LOG("Linking GLSL program.\n");
if (!gl_glsl_link_program(prog))
{
RARCH_ERR("Failed to link program #%u.\n", i);
return 0;
}
/* Clean up dead memory. We're not going to relink the program.
* Detaching first seems to kill some mobile drivers
* (according to the intertubes anyways). */
if (vert)
glDeleteShader(vert);
if (frag)
glDeleteShader(frag);
glUseProgram(prog);
glUniform1i(gl_glsl_get_uniform(glsl, prog, "Texture"), 0);
glUseProgram(0);
}
return prog;
}
