mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-25 16:44:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

(GLSL) Fix regression

Browse Source
This commit is contained in:
Twinaphex 2015-12-01 07:12:26 +01:00
parent d35840ebcd
commit d0340d0f80
2 changed files with 239 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
driver.h
View File

@ -205,6 +205,7 @@ typedef struct driver
void *camera_data; void *camera_data;
void *location_data; void *location_data;
void *recording_data; void *recording_data;
void *video_shader_data;
void *netplay_data; void *netplay_data;
void *ui_companion_data; void *ui_companion_data;

436
gfx/drivers_shader/shader_glsl.c
View File

@ -221,19 +221,18 @@ typedef struct glsl_shader_data
state_tracker_t *gl_state_tracker; state_tracker_t *gl_state_tracker;
} glsl_shader_data_t; } glsl_shader_data_t;
static glsl_shader_data_t *glsl_data;
static bool glsl_core; static bool glsl_core;
static unsigned glsl_major; static unsigned glsl_major;
static unsigned glsl_minor; static unsigned glsl_minor;
static GLint glsl_get_uniform(GLuint prog, const char *base) static GLint get_uniform(glsl_shader_data_t *glsl,
GLuint prog, const char *base)
{ {
unsigned i; unsigned i;
GLint loc; GLint loc;
char buf[64] = {0}; char buf[64] = {0};
snprintf(buf, sizeof(buf), "%s%s", glsl_data->shader->prefix, base); snprintf(buf, sizeof(buf), "%s%s", glsl->shader->prefix, base);
loc = glGetUniformLocation(prog, buf); loc = glGetUniformLocation(prog, buf);
if (loc >= 0) if (loc >= 0)
return loc; return loc;
@ -249,13 +248,14 @@ static GLint glsl_get_uniform(GLuint prog, const char *base)
return -1; return -1;
} }
static GLint glsl_get_attrib(GLuint prog, const char *base) static GLint get_attrib(glsl_shader_data_t *glsl,
GLuint prog, const char *base)
{ {
unsigned i; unsigned i;
GLint loc; GLint loc;
char buf[64] = {0}; char buf[64] = {0};
snprintf(buf, sizeof(buf), "%s%s", glsl_data->shader->prefix, base); snprintf(buf, sizeof(buf), "%s%s", glsl->shader->prefix, base);
loc = glGetUniformLocation(prog, buf); loc = glGetUniformLocation(prog, buf);
if (loc >= 0) if (loc >= 0)
return loc; return loc;
@ -293,7 +293,7 @@ static void print_shader_log(GLuint obj)
free(info_log); free(info_log);
} }
static void glsl_print_linker_log(GLuint obj) static void print_linker_log(GLuint obj)
{ {
char *info_log = NULL; char *info_log = NULL;
GLint max_len, info_len = 0; GLint max_len, info_len = 0;
@ -315,7 +315,9 @@ static void glsl_print_linker_log(GLuint obj)
free(info_log); free(info_log);
} }
static bool glsl_compile_shader(GLuint shader, const char *define, const char *program) static bool compile_shader(glsl_shader_data_t *glsl,
GLuint shader,
const char *define, const char *program)
{ {
GLint status; GLint status;
const char *source[4]; const char *source[4];
@ -346,9 +348,9 @@ static bool glsl_compile_shader(GLuint shader, const char *define, const char *p
RARCH_LOG("[GL]: Using GLSL version %u.\n", version_no); RARCH_LOG("[GL]: Using GLSL version %u.\n", version_no);
} }
source[0] = version; source[0]= version;
source[1] = define; source[1] = define;
source[2] = glsl_data->glsl_alias_define; source[2] = glsl->glsl_alias_define;
source[3] = program; source[3] = program;
glShaderSource(shader, ARRAY_SIZE(source), source, NULL); glShaderSource(shader, ARRAY_SIZE(source), source, NULL);
@ -367,7 +369,7 @@ static bool link_program(GLuint prog)
glLinkProgram(prog); glLinkProgram(prog);
glGetProgramiv(prog, GL_LINK_STATUS, &status); glGetProgramiv(prog, GL_LINK_STATUS, &status);
glsl_print_linker_log(prog); print_linker_log(prog);
if (status != GL_TRUE) if (status != GL_TRUE)
return false; return false;
@ -376,7 +378,9 @@ static bool link_program(GLuint prog)
return true; return true;
} }
static GLuint glsl_compile_program(const char *vertex, const char *fragment, unsigned i) static GLuint compile_program(glsl_shader_data_t *glsl,
const char *vertex,
const char *fragment, unsigned i)
{ {
GLuint vert = 0, frag = 0, prog = glCreateProgram(); GLuint vert = 0, frag = 0, prog = glCreateProgram();
if (!prog) if (!prog)
@ -386,7 +390,8 @@ static GLuint glsl_compile_program(const char *vertex, const char *fragment, uns
{ {
RARCH_LOG("Found GLSL vertex shader.\n"); RARCH_LOG("Found GLSL vertex shader.\n");
vert = glCreateShader(GL_VERTEX_SHADER); vert = glCreateShader(GL_VERTEX_SHADER);
if (!glsl_compile_shader( if (!compile_shader(
glsl,
vert, "#define VERTEX\n#define PARAMETER_UNIFORM\n", vertex)) vert, "#define VERTEX\n#define PARAMETER_UNIFORM\n", vertex))
{ {
RARCH_ERR("Failed to compile vertex shader #%u\n", i); RARCH_ERR("Failed to compile vertex shader #%u\n", i);
@ -400,7 +405,7 @@ static GLuint glsl_compile_program(const char *vertex, const char *fragment, uns
{ {
RARCH_LOG("Found GLSL fragment shader.\n"); RARCH_LOG("Found GLSL fragment shader.\n");
frag = glCreateShader(GL_FRAGMENT_SHADER); frag = glCreateShader(GL_FRAGMENT_SHADER);
if (!glsl_compile_shader(frag, if (!compile_shader(glsl, frag,
"#define FRAGMENT\n#define PARAMETER_UNIFORM\n", fragment)) "#define FRAGMENT\n#define PARAMETER_UNIFORM\n", fragment))
{ {
RARCH_ERR("Failed to compile fragment shader #%u\n", i); RARCH_ERR("Failed to compile fragment shader #%u\n", i);
@ -428,7 +433,7 @@ static GLuint glsl_compile_program(const char *vertex, const char *fragment, uns
glDeleteShader(frag); glDeleteShader(frag);
glUseProgram(prog); glUseProgram(prog);
glUniform1i(glsl_get_uniform(prog, "Texture"), 0); glUniform1i(get_uniform(glsl, prog, "Texture"), 0);
glUseProgram(0); glUseProgram(0);
} }
@ -447,16 +452,16 @@ static bool load_source_path(struct video_shader_pass *pass,
return pass->source.string.fragment && pass->source.string.vertex; return pass->source.string.fragment && pass->source.string.vertex;
} }
static bool glsl_compile_programs(GLuint *gl_prog) static bool compile_programs(glsl_shader_data_t *glsl, GLuint *gl_prog)
{ {
unsigned i; unsigned i;
for (i = 0; i < glsl_data->shader->passes; i++) for (i = 0; i < glsl->shader->passes; i++)
{ {
const char *vertex = NULL; const char *vertex = NULL;
const char *fragment = NULL; const char *fragment = NULL;
struct video_shader_pass *pass = (struct video_shader_pass*) struct video_shader_pass *pass = (struct video_shader_pass*)
&glsl_data->shader->pass[i]; &glsl->shader->pass[i];
/* If we load from GLSLP (CGP), /* If we load from GLSLP (CGP),
* load the file here, and pretend * load the file here, and pretend
@ -472,7 +477,7 @@ static bool glsl_compile_programs(GLuint *gl_prog)
vertex = pass->source.string.vertex; vertex = pass->source.string.vertex;
fragment = pass->source.string.fragment; fragment = pass->source.string.fragment;
gl_prog[i] = glsl_compile_program(vertex, fragment, i); gl_prog[i] = compile_program(glsl, vertex, fragment, i);
if (!gl_prog[i]) if (!gl_prog[i])
{ {
@ -484,16 +489,16 @@ static bool glsl_compile_programs(GLuint *gl_prog)
return true; return true;
} }
static void gl_glsl_reset_attrib(void) static void gl_glsl_reset_attrib(glsl_shader_data_t *glsl)
{ {
unsigned i; unsigned i;
/* Add sanity check that we did not overflow. */ /* Add sanity check that we did not overflow. */
retro_assert(glsl_data->gl_attrib_index <= ARRAY_SIZE(glsl_data->gl_attribs)); retro_assert(glsl->gl_attrib_index <= ARRAY_SIZE(glsl->gl_attribs));
for (i = 0; i < glsl_data->gl_attrib_index; i++) for (i = 0; i < glsl->gl_attrib_index; i++)
glDisableVertexAttribArray(glsl_data->gl_attribs[i]); glDisableVertexAttribArray(glsl->gl_attribs[i]);
glsl_data->gl_attrib_index = 0; glsl->gl_attrib_index = 0;
} }
static void gl_glsl_set_vbo(GLfloat **buffer, size_t *buffer_elems, static void gl_glsl_set_vbo(GLfloat **buffer, size_t *buffer_elems,
@ -517,7 +522,7 @@ static void gl_glsl_set_vbo(GLfloat **buffer, size_t *buffer_elems,
} }
} }
static void gl_glsl_set_attribs( static void gl_glsl_set_attribs(glsl_shader_data_t *glsl,
GLuint vbo, GLuint vbo,
GLfloat **buffer, size_t *buffer_elems, GLfloat **buffer, size_t *buffer_elems,
const GLfloat *data, size_t elems, const GLfloat *data, size_t elems,
@ -533,12 +538,12 @@ static void gl_glsl_set_attribs(
{ {
GLint loc = attrs[i].loc; GLint loc = attrs[i].loc;
if (glsl_data->gl_attrib_index < ARRAY_SIZE(glsl_data->gl_attribs)) if (glsl->gl_attrib_index < ARRAY_SIZE(glsl->gl_attribs))
{ {
glEnableVertexAttribArray(loc); glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, attrs[i].size, GL_FLOAT, GL_FALSE, 0, glVertexAttribPointer(loc, attrs[i].size, GL_FLOAT, GL_FALSE, 0,
(const GLvoid*)(uintptr_t)attrs[i].offset); (const GLvoid*)(uintptr_t)attrs[i].offset);
glsl_data->gl_attribs[glsl_data->gl_attrib_index++] = loc; glsl->gl_attribs[glsl->gl_attrib_index++] = loc;
} }
else else
RARCH_WARN("Attrib array buffer was overflown!\n"); RARCH_WARN("Attrib array buffer was overflown!\n");
@ -555,7 +560,8 @@ static void clear_uniforms_frame(struct shader_uniforms_frame *frame)
frame->tex_coord = -1; frame->tex_coord = -1;
} }
static void glsl_find_uniforms_frame(GLuint prog, static void find_uniforms_frame(glsl_shader_data_t *glsl,
GLuint prog,
struct shader_uniforms_frame *frame, const char *base) struct shader_uniforms_frame *frame, const char *base)
{ {
char texture[64] = {0}; char texture[64] = {0};
@ -569,16 +575,16 @@ static void glsl_find_uniforms_frame(GLuint prog,
snprintf(tex_coord, sizeof(tex_coord), "%s%s", base, "TexCoord"); snprintf(tex_coord, sizeof(tex_coord), "%s%s", base, "TexCoord");
if (frame->texture < 0) if (frame->texture < 0)
frame->texture = glsl_get_uniform(prog, texture); frame->texture = get_uniform(glsl, prog, texture);
if (frame->texture_size < 0) if (frame->texture_size < 0)
frame->texture_size = glsl_get_uniform(prog, texture_size); frame->texture_size = get_uniform(glsl, prog, texture_size);
if (frame->input_size < 0) if (frame->input_size < 0)
frame->input_size = glsl_get_uniform(prog, input_size); frame->input_size = get_uniform(glsl, prog, input_size);
if (frame->tex_coord < 0) if (frame->tex_coord < 0)
frame->tex_coord = glsl_get_attrib(prog, tex_coord); frame->tex_coord = get_attrib(glsl, prog, tex_coord);
} }
static void glsl_find_uniforms( static void find_uniforms(glsl_shader_data_t *glsl,
unsigned pass, GLuint prog, unsigned pass, GLuint prog,
struct shader_uniforms *uni) struct shader_uniforms *uni)
{ {
@ -587,141 +593,148 @@ static void glsl_find_uniforms(
glUseProgram(prog); glUseProgram(prog);
uni->mvp = glsl_get_uniform(prog, "MVPMatrix"); uni->mvp = get_uniform(glsl, prog, "MVPMatrix");
uni->tex_coord = glsl_get_attrib(prog, "TexCoord"); uni->tex_coord = get_attrib(glsl, prog, "TexCoord");
uni->vertex_coord = glsl_get_attrib(prog, "VertexCoord"); uni->vertex_coord = get_attrib(glsl, prog, "VertexCoord");
uni->color = glsl_get_attrib(prog, "Color"); uni->color = get_attrib(glsl, prog, "Color");
uni->lut_tex_coord = glsl_get_attrib(prog, "LUTTexCoord"); uni->lut_tex_coord = get_attrib(glsl, prog, "LUTTexCoord");
uni->input_size = glsl_get_uniform(prog, "InputSize"); uni->input_size = get_uniform(glsl, prog, "InputSize");
uni->output_size = glsl_get_uniform(prog, "OutputSize"); uni->output_size = get_uniform(glsl, prog, "OutputSize");
uni->texture_size = glsl_get_uniform(prog, "TextureSize"); uni->texture_size = get_uniform(glsl, prog, "TextureSize");
uni->frame_count = glsl_get_uniform(prog, "FrameCount"); uni->frame_count = get_uniform(glsl, prog, "FrameCount");
uni->frame_direction = glsl_get_uniform(prog, "FrameDirection"); uni->frame_direction = get_uniform(glsl, prog, "FrameDirection");
for (i = 0; i < glsl_data->shader->luts; i++) for (i = 0; i < glsl->shader->luts; i++)
uni->lut_texture[i] = glGetUniformLocation(prog, glsl_data->shader->lut[i].id); uni->lut_texture[i] = glGetUniformLocation(prog, glsl->shader->lut[i].id);
clear_uniforms_frame(&uni->orig); clear_uniforms_frame(&uni->orig);
glsl_find_uniforms_frame(prog, &uni->orig, "Orig"); find_uniforms_frame(glsl, prog, &uni->orig, "Orig");
clear_uniforms_frame(&uni->feedback); clear_uniforms_frame(&uni->feedback);
glsl_find_uniforms_frame(prog, &uni->feedback, "Feedback"); find_uniforms_frame(glsl, prog, &uni->feedback, "Feedback");
if (pass > 1) if (pass > 1)
{ {
snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass); snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass);
glsl_find_uniforms_frame(prog, &uni->orig, frame_base); find_uniforms_frame(glsl, prog, &uni->orig, frame_base);
} }
for (i = 0; i + 1 < pass; i++) for (i = 0; i + 1 < pass; i++)
{ {
snprintf(frame_base, sizeof(frame_base), "Pass%u", i + 1); snprintf(frame_base, sizeof(frame_base), "Pass%u", i + 1);
clear_uniforms_frame(&uni->pass[i]); clear_uniforms_frame(&uni->pass[i]);
glsl_find_uniforms_frame(prog, &uni->pass[i], frame_base); find_uniforms_frame(glsl, prog, &uni->pass[i], frame_base);
snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass - (i + 1)); snprintf(frame_base, sizeof(frame_base), "PassPrev%u", pass - (i + 1));
glsl_find_uniforms_frame(prog, &uni->pass[i], frame_base); find_uniforms_frame(glsl, prog, &uni->pass[i], frame_base);
if (*glsl_data->shader->pass[i].alias) if (*glsl->shader->pass[i].alias)
glsl_find_uniforms_frame(prog, &uni->pass[i], glsl_data->shader->pass[i].alias); find_uniforms_frame(glsl, prog, &uni->pass[i], glsl->shader->pass[i].alias);
} }
clear_uniforms_frame(&uni->prev[0]); clear_uniforms_frame(&uni->prev[0]);
glsl_find_uniforms_frame(prog, &uni->prev[0], "Prev"); find_uniforms_frame(glsl, prog, &uni->prev[0], "Prev");
for (i = 1; i < PREV_TEXTURES; i++) for (i = 1; i < PREV_TEXTURES; i++)
{ {
snprintf(frame_base, sizeof(frame_base), "Prev%u", i); snprintf(frame_base, sizeof(frame_base), "Prev%u", i);
clear_uniforms_frame(&uni->prev[i]); clear_uniforms_frame(&uni->prev[i]);
glsl_find_uniforms_frame(prog, &uni->prev[i], frame_base); find_uniforms_frame(glsl, prog, &uni->prev[i], frame_base);
} }
glUseProgram(0); glUseProgram(0);
} }
static void gl_glsl_deinit_shader(void) static void gl_glsl_deinit_shader(glsl_shader_data_t *glsl)
{ {
unsigned i; unsigned i;
if (!glsl_data || !glsl_data->shader) if (!glsl || !glsl->shader)
return; return;
for (i = 0; i < glsl_data->shader->passes; i++) for (i = 0; i < glsl->shader->passes; i++)
{ {
free(glsl_data->shader->pass[i].source.string.vertex); free(glsl->shader->pass[i].source.string.vertex);
free(glsl_data->shader->pass[i].source.string.fragment); free(glsl->shader->pass[i].source.string.fragment);
} }
free(glsl_data->shader->script); free(glsl->shader->script);
free(glsl_data->shader); free(glsl->shader);
glsl_data->shader = NULL; glsl->shader = NULL;
} }
static void gl_glsl_destroy_resources(void) static void gl_glsl_destroy_resources(glsl_shader_data_t *glsl)
{ {
unsigned i; unsigned i;
if (!glsl_data) if (!glsl)
return; return;
glUseProgram(0); glUseProgram(0);
for (i = 0; i < GFX_MAX_SHADERS; i++) for (i = 0; i < GFX_MAX_SHADERS; i++)
{ {
if (glsl_data->gl_program[i] == 0 || (i && glsl_data->gl_program[i] == glsl_data->gl_program[0])) if (glsl->gl_program[i] == 0 || (i && glsl->gl_program[i] == glsl->gl_program[0]))
continue; continue;
glDeleteProgram(glsl_data->gl_program[i]); glDeleteProgram(glsl->gl_program[i]);
} }
if (glsl_data->shader && glsl_data->shader->luts) if (glsl->shader && glsl->shader->luts)
glDeleteTextures(glsl_data->shader->luts, glsl_data->gl_teximage); glDeleteTextures(glsl->shader->luts, glsl->gl_teximage);
memset(glsl_data->gl_program, 0, sizeof(glsl_data->gl_program)); memset(glsl->gl_program, 0, sizeof(glsl->gl_program));
memset(glsl_data->gl_uniforms, 0, sizeof(glsl_data->gl_uniforms)); memset(glsl->gl_uniforms, 0, sizeof(glsl->gl_uniforms));
glsl_data->glsl_active_index = 0; glsl->glsl_active_index = 0;
gl_glsl_deinit_shader(); gl_glsl_deinit_shader(glsl);
if (glsl_data->gl_state_tracker) if (glsl->gl_state_tracker)
state_tracker_free(glsl_data->gl_state_tracker); state_tracker_free(glsl->gl_state_tracker);
glsl_data->gl_state_tracker = NULL; glsl->gl_state_tracker = NULL;
gl_glsl_reset_attrib(); gl_glsl_reset_attrib(glsl);
for (i = 0; i < GFX_MAX_SHADERS; i++) for (i = 0; i < GFX_MAX_SHADERS; i++)
{ {
if (glsl_data->glsl_vbo[i].vbo_primary) if (glsl->glsl_vbo[i].vbo_primary)
glDeleteBuffers(1, &glsl_data->glsl_vbo[i].vbo_primary); glDeleteBuffers(1, &glsl->glsl_vbo[i].vbo_primary);
if (glsl_data->glsl_vbo[i].vbo_secondary) if (glsl->glsl_vbo[i].vbo_secondary)
glDeleteBuffers(1, &glsl_data->glsl_vbo[i].vbo_secondary); glDeleteBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
free(glsl_data->glsl_vbo[i].buffer_primary); free(glsl->glsl_vbo[i].buffer_primary);
free(glsl_data->glsl_vbo[i].buffer_secondary); free(glsl->glsl_vbo[i].buffer_secondary);
} }
memset(&glsl_data->glsl_vbo, 0, sizeof(glsl_data->glsl_vbo)); memset(&glsl->glsl_vbo, 0, sizeof(glsl->glsl_vbo));
} }
static void gl_glsl_deinit(void) static void gl_glsl_deinit(void)
{ {
if (!glsl_data) driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return; return;
gl_glsl_destroy_resources(); gl_glsl_destroy_resources(glsl);
if (glsl_data) if (driver->video_shader_data)
free(glsl_data); free(driver->video_shader_data);
glsl_data = NULL; driver->video_shader_data = NULL;
} }
static bool gl_glsl_init(void *data, const char *path) static bool gl_glsl_init(void *data, const char *path)
{ {
unsigned i; unsigned i;
config_file_t *conf = NULL; config_file_t *conf = NULL;
glsl_shader_data_t *glsl = NULL;
const char *stock_vertex = NULL; const char *stock_vertex = NULL;
const char *stock_fragment = NULL; const char *stock_fragment = NULL;
driver_t *driver = driver_get_ptr();
glsl_data = (glsl_shader_data_t*)calloc(1, sizeof(glsl_shader_data_t)); (void)data;
if (!glsl_data) glsl = (glsl_shader_data_t*)calloc(1, sizeof(glsl_shader_data_t));
if (!glsl)
return false; return false;
#ifndef HAVE_OPENGLES2 #ifndef HAVE_OPENGLES2
@ -742,17 +755,15 @@ static bool gl_glsl_init(void *data, const char *path)
if (!shader_support) if (!shader_support)
{ {
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n"); RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
free(glsl_data); free(glsl);
glsl_data = NULL;
return false; return false;
} }
#endif #endif
glsl_data->shader = (struct video_shader*)calloc(1, sizeof(*glsl_data->shader)); glsl->shader = (struct video_shader*)calloc(1, sizeof(*glsl->shader));
if (!glsl_data->shader) if (!glsl->shader)
{ {
free(glsl_data); free(glsl);
glsl_data = NULL;
return false; return false;
} }
@ -763,10 +774,10 @@ static bool gl_glsl_init(void *data, const char *path)
if (!strcmp(path_ext, "glsl")) if (!strcmp(path_ext, "glsl"))
{ {
strlcpy(glsl_data->shader->pass[0].source.path, path, strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl_data->shader->pass[0].source.path)); sizeof(glsl->shader->pass[0].source.path));
glsl_data->shader->passes = 1; glsl->shader->passes = 1;
glsl_data->shader->modern = true; glsl->shader->modern = true;
ret = true; ret = true;
} }
else if (!strcmp(path_ext, "glslp")) else if (!strcmp(path_ext, "glslp"))
@ -774,8 +785,8 @@ static bool gl_glsl_init(void *data, const char *path)
conf = config_file_new(path); conf = config_file_new(path);
if (conf) if (conf)
{ {
ret = video_shader_read_conf_cgp(conf, glsl_data->shader); ret = video_shader_read_conf_cgp(conf, glsl->shader);
glsl_data->shader->modern = true; glsl->shader->modern = true;
} }
else else
ret = false; ret = false;
@ -786,25 +797,24 @@ static bool gl_glsl_init(void *data, const char *path)
if (!ret) if (!ret)
{ {
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n"); RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
free(glsl_data->shader); free(glsl->shader);
free(glsl_data); free(glsl);
glsl_data = NULL;
return false; return false;
} }
} }
else else
{ {
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n"); RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl_data->shader->passes = 1; glsl->shader->passes = 1;
glsl_data->shader->pass[0].source.string.vertex = glsl->shader->pass[0].source.string.vertex =
strdup(glsl_core ? stock_vertex_core : stock_vertex_modern); strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl_data->shader->pass[0].source.string.fragment = glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern); strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl_data->shader->modern = true; glsl->shader->modern = true;
} }
video_shader_resolve_relative(glsl_data->shader, path); video_shader_resolve_relative(glsl->shader, path);
video_shader_resolve_parameters(conf, glsl_data->shader); video_shader_resolve_parameters(conf, glsl->shader);
if (conf) if (conf)
{ {
@ -812,9 +822,9 @@ static bool gl_glsl_init(void *data, const char *path)
conf = NULL; conf = NULL;
} }
stock_vertex = (glsl_data->shader->modern) ? stock_vertex = (glsl->shader->modern) ?
stock_vertex_modern : stock_vertex_legacy; stock_vertex_modern : stock_vertex_legacy;
stock_fragment = (glsl_data->shader->modern) ? stock_fragment = (glsl->shader->modern) ?
stock_fragment_modern : stock_fragment_legacy; stock_fragment_modern : stock_fragment_legacy;
if (glsl_core) if (glsl_core)
@ -824,13 +834,13 @@ static bool gl_glsl_init(void *data, const char *path)
} }
#ifdef HAVE_OPENGLES2 #ifdef HAVE_OPENGLES2
if (!glsl_data->shader->modern) if (!glsl->shader->modern)
{ {
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n"); RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
goto error; goto error;
} }
#else #else
if (glsl_core && !glsl_data->shader->modern) if (glsl_core && !glsl->shader->modern)
{ {
RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n"); RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n");
goto error; goto error;
@ -839,97 +849,99 @@ static bool gl_glsl_init(void *data, const char *path)
/* Find all aliases we use in our GLSLP and add #defines for them so /* Find all aliases we use in our GLSLP and add #defines for them so
* that a shader can choose a fallback if we are not using a preset. */ * that a shader can choose a fallback if we are not using a preset. */
*glsl_data->glsl_alias_define = '\0'; *glsl->glsl_alias_define = '\0';
for (i = 0; i < glsl_data->shader->passes; i++) for (i = 0; i < glsl->shader->passes; i++)
{ {
if (*glsl_data->shader->pass[i].alias) if (*glsl->shader->pass[i].alias)
{ {
char define[128] = {0}; char define[128] = {0};
snprintf(define, sizeof(define), "#define %s_ALIAS\n", snprintf(define, sizeof(define), "#define %s_ALIAS\n",
glsl_data->shader->pass[i].alias); glsl->shader->pass[i].alias);
strlcat(glsl_data->glsl_alias_define, define, sizeof(glsl_data->glsl_alias_define)); strlcat(glsl->glsl_alias_define, define, sizeof(glsl->glsl_alias_define));
} }
} }
if (!(glsl_data->gl_program[0] = glsl_compile_program(stock_vertex, stock_fragment, 0))) if (!(glsl->gl_program[0] = compile_program(glsl, stock_vertex, stock_fragment, 0)))
{ {
RARCH_ERR("GLSL stock programs failed to compile.\n"); RARCH_ERR("GLSL stock programs failed to compile.\n");
goto error; goto error;
} }
if (!glsl_compile_programs(&glsl_data->gl_program[1])) if (!compile_programs(glsl, &glsl->gl_program[1]))
goto error; goto error;
if (!gl_load_luts(glsl_data->shader, glsl_data->gl_teximage)) if (!gl_load_luts(glsl->shader, glsl->gl_teximage))
{ {
RARCH_ERR("[GL]: Failed to load LUTs.\n"); RARCH_ERR("[GL]: Failed to load LUTs.\n");
goto error; goto error;
} }
for (i = 0; i <= glsl_data->shader->passes; i++) for (i = 0; i <= glsl->shader->passes; i++)
glsl_find_uniforms(i, glsl_data->gl_program[i], &glsl_data->gl_uniforms[i]); find_uniforms(glsl, i, glsl->gl_program[i], &glsl->gl_uniforms[i]);
#ifdef GLSL_DEBUG #ifdef GLSL_DEBUG
if (!gl_check_error()) if (!gl_check_error())
RARCH_WARN("Detected GL error in GLSL.\n"); RARCH_WARN("Detected GL error in GLSL.\n");
#endif #endif
if (glsl_data->shader->variables) if (glsl->shader->variables)
{ {
struct state_tracker_info info = {0}; struct state_tracker_info info = {0};
info.wram = (uint8_t*)core.retro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM); info.wram = (uint8_t*)core.retro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = glsl_data->shader->variable; info.info = glsl->shader->variable;
info.info_elem = glsl_data->shader->variables; info.info_elem = glsl->shader->variables;
#ifdef HAVE_PYTHON #ifdef HAVE_PYTHON
info.script = glsl_data->shader->script; info.script = glsl->shader->script;
info.script_class = *glsl_data->shader->script_class ? info.script_class = *glsl->shader->script_class ?
glsl_data->shader->script_class : NULL; glsl->shader->script_class : NULL;
#endif #endif
glsl_data->gl_state_tracker = state_tracker_init(&info); glsl->gl_state_tracker = state_tracker_init(&info);
if (!glsl_data->gl_state_tracker) if (!glsl->gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n"); RARCH_WARN("Failed to init state tracker.\n");
} }
glsl_data->gl_program[glsl_data->shader->passes + 1] = glsl_data->gl_program[0]; glsl->gl_program[glsl->shader->passes + 1] = glsl->gl_program[0];
glsl_data->gl_uniforms[glsl_data->shader->passes + 1] = glsl_data->gl_uniforms[0]; glsl->gl_uniforms[glsl->shader->passes + 1] = glsl->gl_uniforms[0];
if (glsl_data->shader->modern) if (glsl->shader->modern)
{ {
glsl_data->gl_program[GL_SHADER_STOCK_BLEND] = glsl_compile_program( glsl->gl_program[GL_SHADER_STOCK_BLEND] = compile_program(
glsl,
glsl_core ? glsl_core ?
stock_vertex_core_blend : stock_vertex_modern_blend, stock_vertex_core_blend : stock_vertex_modern_blend,
glsl_core ? glsl_core ?
stock_fragment_core_blend : stock_fragment_modern_blend, stock_fragment_core_blend : stock_fragment_modern_blend,
GL_SHADER_STOCK_BLEND); GL_SHADER_STOCK_BLEND);
glsl_find_uniforms(0, glsl_data->gl_program[GL_SHADER_STOCK_BLEND], find_uniforms(glsl, 0, glsl->gl_program[GL_SHADER_STOCK_BLEND],
&glsl_data->gl_uniforms[GL_SHADER_STOCK_BLEND]); &glsl->gl_uniforms[GL_SHADER_STOCK_BLEND]);
} }
else else
{ {
glsl_data->gl_program [GL_SHADER_STOCK_BLEND] = glsl_data->gl_program[0]; glsl->gl_program [GL_SHADER_STOCK_BLEND] = glsl->gl_program[0];
glsl_data->gl_uniforms[GL_SHADER_STOCK_BLEND] = glsl_data->gl_uniforms[0]; glsl->gl_uniforms[GL_SHADER_STOCK_BLEND] = glsl->gl_uniforms[0];
} }
gl_glsl_reset_attrib(); gl_glsl_reset_attrib(glsl);
for (i = 0; i < GFX_MAX_SHADERS; i++) for (i = 0; i < GFX_MAX_SHADERS; i++)
{ {
glGenBuffers(1, &glsl_data->glsl_vbo[i].vbo_primary); glGenBuffers(1, &glsl->glsl_vbo[i].vbo_primary);
glGenBuffers(1, &glsl_data->glsl_vbo[i].vbo_secondary); glGenBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
} }
driver->video_shader_data = glsl;
return true; return true;
error: error:
gl_glsl_destroy_resources(); gl_glsl_destroy_resources(glsl);
if (glsl_data) if (glsl)
free(glsl_data); free(glsl);
glsl_data = NULL;
return false; return false;
} }
@ -954,15 +966,17 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info; const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info;
const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info; const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info;
struct glsl_attrib *attr = (struct glsl_attrib*)attribs; struct glsl_attrib *attr = (struct glsl_attrib*)attribs;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl_data) if (!glsl)
return; return;
uni = (const struct shader_uniforms*)&glsl_data->gl_uniforms[glsl_data->glsl_active_index]; uni = (const struct shader_uniforms*)&glsl->gl_uniforms[glsl->glsl_active_index];
(void)data; (void)data;
if (glsl_data->gl_program[glsl_data->glsl_active_index] == 0) if (glsl->gl_program[glsl->glsl_active_index] == 0)
return; return;
input_size [0] = (float)width; input_size [0] = (float)width;
@ -981,9 +995,9 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
if (uni->texture_size >= 0) if (uni->texture_size >= 0)
glUniform2fv(uni->texture_size, 1, texture_size); glUniform2fv(uni->texture_size, 1, texture_size);
if (uni->frame_count >= 0 && glsl_data->glsl_active_index) if (uni->frame_count >= 0 && glsl->glsl_active_index)
{ {
unsigned modulo = glsl_data->shader->pass[glsl_data->glsl_active_index - 1].frame_count_mod; unsigned modulo = glsl->shader->pass[glsl->glsl_active_index - 1].frame_count_mod;
if (modulo) if (modulo)
frame_count %= modulo; frame_count %= modulo;
@ -994,19 +1008,19 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
glUniform1i(uni->frame_direction, state_manager_frame_is_reversed() ? -1 : 1); glUniform1i(uni->frame_direction, state_manager_frame_is_reversed() ? -1 : 1);
for (i = 0; i < glsl_data->shader->luts; i++) for (i = 0; i < glsl->shader->luts; i++)
{ {
if (uni->lut_texture[i] < 0) if (uni->lut_texture[i] < 0)
continue; continue;
/* Have to rebind as HW render could override this. */ /* Have to rebind as HW render could override this. */
glActiveTexture(GL_TEXTURE0 + texunit); glActiveTexture(GL_TEXTURE0 + texunit);
glBindTexture(GL_TEXTURE_2D, glsl_data->gl_teximage[i]); glBindTexture(GL_TEXTURE_2D, glsl->gl_teximage[i]);
glUniform1i(uni->lut_texture[i], texunit); glUniform1i(uni->lut_texture[i], texunit);
texunit++; texunit++;
} }
if (glsl_data->glsl_active_index) if (glsl->glsl_active_index)
{ {
/* Set original texture. */ /* Set original texture. */
if (uni->orig.texture >= 0) if (uni->orig.texture >= 0)
@ -1130,37 +1144,37 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
if (size) if (size)
{ {
gl_glsl_set_attribs(glsl_data->glsl_vbo[glsl_data->glsl_active_index].vbo_secondary, gl_glsl_set_attribs(glsl, glsl->glsl_vbo[glsl->glsl_active_index].vbo_secondary,
&glsl_data->glsl_vbo[glsl_data->glsl_active_index].buffer_secondary, &glsl->glsl_vbo[glsl->glsl_active_index].buffer_secondary,
&glsl_data->glsl_vbo[glsl_data->glsl_active_index].size_secondary, &glsl->glsl_vbo[glsl->glsl_active_index].size_secondary,
buffer, size, attribs, attribs_size); buffer, size, attribs, attribs_size);
} }
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
/* #pragma parameters. */ /* #pragma parameters. */
for (i = 0; i < glsl_data->shader->num_parameters; i++) for (i = 0; i < glsl->shader->num_parameters; i++)
{ {
int location = glGetUniformLocation( int location = glGetUniformLocation(
glsl_data->gl_program[glsl_data->glsl_active_index], glsl->gl_program[glsl->glsl_active_index],
glsl_data->shader->parameters[i].id); glsl->shader->parameters[i].id);
glUniform1f(location, glsl_data->shader->parameters[i].current); glUniform1f(location, glsl->shader->parameters[i].current);
} }
/* Set state parameters. */ /* Set state parameters. */
if (glsl_data->gl_state_tracker) if (glsl->gl_state_tracker)
{ {
static struct state_tracker_uniform state_info[GFX_MAX_VARIABLES]; static struct state_tracker_uniform state_info[GFX_MAX_VARIABLES];
static unsigned cnt = 0; static unsigned cnt = 0;
if (glsl_data->glsl_active_index == 1) if (glsl->glsl_active_index == 1)
cnt = state_tracker_get_uniform(glsl_data->gl_state_tracker, state_info, cnt = state_tracker_get_uniform(glsl->gl_state_tracker, state_info,
GFX_MAX_VARIABLES, frame_count); GFX_MAX_VARIABLES, frame_count);
for (i = 0; i < cnt; i++) for (i = 0; i < cnt; i++)
{ {
int location = glGetUniformLocation( int location = glGetUniformLocation(
glsl_data->gl_program[glsl_data->glsl_active_index], glsl->gl_program[glsl->glsl_active_index],
state_info[i].id); state_info[i].id);
glUniform1f(location, state_info[i].value); glUniform1f(location, state_info[i].value);
} }
@ -1170,14 +1184,18 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat) static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat)
{ {
int loc; int loc;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl_data || !glsl_data->shader->modern) (void)data;
if (!glsl || !glsl->shader->modern)
{ {
gl_ff_matrix(mat); gl_ff_matrix(mat);
return false; return false;
} }
loc = glsl_data->gl_uniforms[glsl_data->glsl_active_index].mvp; loc = glsl->gl_uniforms[glsl->glsl_active_index].mvp;
if (loc >= 0) if (loc >= 0)
glUniformMatrix4fv(loc, 1, GL_FALSE, mat->data); glUniformMatrix4fv(loc, 1, GL_FALSE, mat->data);
@ -1194,8 +1212,10 @@ static bool gl_glsl_set_coords(const void *data)
struct glsl_attrib *attr = NULL; struct glsl_attrib *attr = NULL;
const struct shader_uniforms *uni = NULL; const struct shader_uniforms *uni = NULL;
const struct gfx_coords *coords = (const struct gfx_coords*)data; const struct gfx_coords *coords = (const struct gfx_coords*)data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl_data || !glsl_data->shader->modern || !coords) if (!glsl || !glsl->shader->modern || !coords)
{ {
gl_ff_vertex(coords); gl_ff_vertex(coords);
return false; return false;
@ -1213,7 +1233,7 @@ static bool gl_glsl_set_coords(const void *data)
} }
attr = attribs; attr = attribs;
uni = &glsl_data->gl_uniforms[glsl_data->glsl_active_index]; uni = &glsl->gl_uniforms[glsl->glsl_active_index];
if (uni->tex_coord >= 0) if (uni->tex_coord >= 0)
{ {
@ -1269,10 +1289,10 @@ static bool gl_glsl_set_coords(const void *data)
if (size) if (size)
{ {
gl_glsl_set_attribs( gl_glsl_set_attribs(glsl,
glsl_data->glsl_vbo[glsl_data->glsl_active_index].vbo_primary, glsl->glsl_vbo[glsl->glsl_active_index].vbo_primary,
&glsl_data->glsl_vbo[glsl_data->glsl_active_index].buffer_primary, &glsl->glsl_vbo[glsl->glsl_active_index].buffer_primary,
&glsl_data->glsl_vbo[glsl_data->glsl_active_index].size_primary, &glsl->glsl_vbo[glsl->glsl_active_index].size_primary,
buffer, size, buffer, size,
attribs, attribs_size); attribs, attribs_size);
} }
@ -1285,29 +1305,38 @@ static bool gl_glsl_set_coords(const void *data)
static void gl_glsl_use(void *data, unsigned idx) static void gl_glsl_use(void *data, unsigned idx)
{ {
if (!glsl_data) driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
(void)data;
if (!glsl)
return; return;
gl_glsl_reset_attrib(); gl_glsl_reset_attrib(glsl);
glsl_data->glsl_active_index = idx; glsl->glsl_active_index = idx;
glUseProgram(glsl_data->gl_program[idx]); glUseProgram(glsl->gl_program[idx]);
} }
static unsigned gl_glsl_num(void) static unsigned gl_glsl_num(void)
{ {
if (glsl_data && glsl_data->shader) driver_t *driver = driver_get_ptr();
return glsl_data->shader->passes; glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && glsl->shader)
return glsl->shader->passes;
return 0; return 0;
} }
static bool gl_glsl_filter_type(unsigned idx, bool *smooth) static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
{ {
if (glsl_data && idx driver_t *driver = driver_get_ptr();
&& (glsl_data->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC) glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx
&& (glsl->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
) )
{ {
*smooth = (glsl_data->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR); *smooth = (glsl->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR);
return true; return true;
} }
return false; return false;
@ -1315,15 +1344,19 @@ static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx) static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx)
{ {
if (glsl_data && idx) driver_t *driver = driver_get_ptr();
return glsl_data->shader->pass[idx - 1].wrap; glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
return glsl->shader->pass[idx - 1].wrap;
return RARCH_WRAP_BORDER; return RARCH_WRAP_BORDER;
} }
static void gl_glsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale) static void gl_glsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
{ {
if (glsl_data && idx) driver_t *driver = driver_get_ptr();
*scale = glsl_data->shader->pass[idx - 1].fbo; glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
*scale = glsl->shader->pass[idx - 1].fbo;
else else
scale->valid = false; scale->valid = false;
} }
@ -1332,13 +1365,15 @@ static unsigned gl_glsl_get_prev_textures(void)
{ {
unsigned i, j; unsigned i, j;
unsigned max_prev = 0; unsigned max_prev = 0;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl_data) if (!glsl)
return 0; return 0;
for (i = 1; i <= glsl_data->shader->passes; i++) for (i = 1; i <= glsl->shader->passes; i++)
for (j = 0; j < PREV_TEXTURES; j++) for (j = 0; j < PREV_TEXTURES; j++)
if (glsl_data->gl_uniforms[i].prev[j].texture >= 0) if (glsl->gl_uniforms[i].prev[j].texture >= 0)
max_prev = max(j + 1, max_prev); max_prev = max(j + 1, max_prev);
return max_prev; return max_prev;
@ -1346,25 +1381,31 @@ static unsigned gl_glsl_get_prev_textures(void)
static bool gl_glsl_mipmap_input(unsigned idx) static bool gl_glsl_mipmap_input(unsigned idx)
{ {
if (glsl_data && idx) driver_t *driver = driver_get_ptr();
return glsl_data->shader->pass[idx - 1].mipmap; glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
return glsl->shader->pass[idx - 1].mipmap;
return false; return false;
} }
static bool gl_glsl_get_feedback_pass(unsigned *index) static bool gl_glsl_get_feedback_pass(unsigned *index)
{ {
if (!glsl_data || glsl_data->shader->feedback_pass < 0) driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl || glsl->shader->feedback_pass < 0)
return false; return false;
*index = glsl_data->shader->feedback_pass; *index = glsl->shader->feedback_pass;
return true; return true;
} }
static struct video_shader *gl_glsl_get_current_shader(void) static struct video_shader *gl_glsl_get_current_shader(void)
{ {
if (!glsl_data) driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return NULL; return NULL;
return glsl_data->shader; return glsl->shader;
} }
void gl_glsl_set_get_proc_address(gfx_ctx_proc_t (*proc)(const char*)) void gl_glsl_set_get_proc_address(gfx_ctx_proc_t (*proc)(const char*))
@ -1399,4 +1440,3 @@ const shader_backend_t gl_glsl_backend = {
RARCH_SHADER_GLSL, RARCH_SHADER_GLSL,
"glsl" "glsl"
}; };