bool d3d_init_imports(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
if (!d3d->shader.variables)
return true;
state_tracker_info tracker_info = {0};
tracker_info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
tracker_info.info = d3d->shader.variable;
tracker_info.info_elem = d3d->shader.variables;
#ifdef HAVE_PYTHON
if (*d3d->shader.script_path)
{
tracker_info.script = d3d->shader.script_path;
tracker_info.script_is_file = true;
}
tracker_info.script_class = *d3d->shader.script_class ? d3d->shader.script_class : NULL;
#endif
state_tracker_t *state_tracker = state_tracker_init(&tracker_info);
if (!state_tracker)
{
RARCH_ERR("Failed to initialize state tracker.\n");
return false;
}
renderchain_add_state_tracker(d3d->chain, state_tracker);
return true;
}
static bool gl_cg_load_imports(cg_shader_data_t *cg)
{
unsigned i;
struct state_tracker_info tracker_info = {0};
if (!cg->shader->variables)
return true;
for (i = 0; i < cg->shader->variables; i++)
{
unsigned memtype;
switch (cg->shader->variable[i].ram_type)
{
case RARCH_STATE_WRAM:
memtype = RETRO_MEMORY_SYSTEM_RAM;
break;
default:
memtype = -1u;
}
if ((memtype != -1u) &&
(cg->shader->variable[i].addr >= core.retro_get_memory_size(memtype)))
{
RARCH_ERR("Address out of bounds.\n");
return false;
}
}
tracker_info.wram = (uint8_t*)
core.retro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
tracker_info.info = cg->shader->variable;
tracker_info.info_elem = cg->shader->variables;
#ifdef HAVE_PYTHON
if (*cg->shader->script_path)
{
tracker_info.script = cg->shader->script_path;
tracker_info.script_is_file = true;
}
tracker_info.script_class =
*cg->shader->script_class ? cg->shader->script_class : NULL;
#endif
cg->state_tracker = state_tracker_init(&tracker_info);
if (!cg->state_tracker)
RARCH_WARN("Failed to initialize state tracker.\n");
return true;
}
static bool d3d_init_imports(d3d_video_t *d3d)
{
retro_ctx_memory_info_t mem_info;
state_tracker_t *state_tracker = NULL;
state_tracker_info tracker_info = {0};
if (!d3d->shader.variables)
return true;
if (!d3d->renderchain_driver || !d3d->renderchain_driver->add_state_tracker)
return true;
mem_info.id = RETRO_MEMORY_SYSTEM_RAM;
core_get_memory(&mem_info);
tracker_info.wram = (uint8_t*)mem_info.data;
tracker_info.info = d3d->shader.variable;
tracker_info.info_elem = d3d->shader.variables;
#ifdef HAVE_PYTHON
if (*d3d->shader.script_path)
{
tracker_info.script = d3d->shader.script_path;
tracker_info.script_is_file = true;
}
tracker_info.script_class =
*d3d->shader.script_class ? d3d->shader.script_class : NULL;
#endif
state_tracker = state_tracker_init(&tracker_info);
if (!state_tracker)
{
RARCH_ERR("Failed to initialize state tracker.\n");
return false;
}
d3d->renderchain_driver->add_state_tracker(
d3d->renderchain_data, state_tracker);
return true;
}
static bool gl_cg_load_imports(void *data)
{
unsigned i;
retro_ctx_memory_info_t mem_info;
struct state_tracker_info tracker_info = {0};
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data->shader->variables)
return true;
for (i = 0; i < cg_data->shader->variables; i++)
{
unsigned memtype;
switch (cg_data->shader->variable[i].ram_type)
{
case RARCH_STATE_WRAM:
memtype = RETRO_MEMORY_SYSTEM_RAM;
break;
default:
memtype = -1u;
}
mem_info.id = memtype;
core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info);
if ((memtype != -1u) &&
(cg_data->shader->variable[i].addr >= mem_info.size))
{
RARCH_ERR("Address out of bounds.\n");
return false;
}
}
mem_info.data = NULL;
mem_info.size = 0;
mem_info.id = RETRO_MEMORY_SYSTEM_RAM;
core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info);
tracker_info.wram = (uint8_t*)mem_info.data;
tracker_info.info = cg_data->shader->variable;
tracker_info.info_elem = cg_data->shader->variables;
#ifdef HAVE_PYTHON
if (*cg_data->shader->script_path)
{
tracker_info.script = cg_data->shader->script_path;
tracker_info.script_is_file = true;
}
tracker_info.script_class =
*cg_data->shader->script_class ? cg_data->shader->script_class : NULL;
#endif
cg_data->state_tracker = state_tracker_init(&tracker_info);
if (!cg_data->state_tracker)
RARCH_WARN("Failed to initialize state tracker.\n");
return true;
}
static void *gl_glsl_init(void *data, const char *path)
{
unsigned i;
struct shader_program_info shader_prog_info;
bool shader_support = false;
#ifdef GLSL_DEBUG
char *error_string = NULL;
#endif
config_file_t *conf = NULL;
const char *stock_vertex = NULL;
const char *stock_fragment = NULL;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)
calloc(1, sizeof(glsl_shader_data_t));
if (!glsl)
return NULL;
(void)shader_support;
#ifndef HAVE_OPENGLES
RARCH_LOG("[GLSL]: Checking GLSL shader support ...\n");
shader_support = glCreateProgram && glUseProgram && glCreateShader
&& glDeleteShader && glShaderSource && glCompileShader && glAttachShader
&& glDetachShader && glLinkProgram && glGetUniformLocation
&& glUniform1i && glUniform1f && glUniform2fv && glUniform4fv
&& glUniformMatrix4fv
&& glGetShaderiv && glGetShaderInfoLog && glGetProgramiv
&& glGetProgramInfoLog
&& glDeleteProgram && glGetAttachedShaders
&& glGetAttribLocation && glEnableVertexAttribArray
&& glDisableVertexAttribArray
&& glVertexAttribPointer
&& glGenBuffers && glBufferData && glDeleteBuffers && glBindBuffer;
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
goto error;
}
#endif
glsl->shader = (struct video_shader*)calloc(1, sizeof(*glsl->shader));
if (!glsl->shader)
goto error;
if (!string_is_empty(path))
{
bool ret = false;
const char *path_ext = path_get_extension(path);
if (string_is_equal_fast(path_ext, "glslp", 5))
{
conf = config_file_new(path);
if (conf)
{
ret = video_shader_read_conf_cgp(conf, glsl->shader);
glsl->shader->modern = true;
}
}
else if (string_is_equal_fast(path_ext, "glsl", 4))
{
strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl->shader->pass[0].source.path));
glsl->shader->passes = 1;
glsl->shader->modern = true;
ret = true;
}
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
goto error;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl->shader->passes = 1;
glsl->shader->pass[0].source.string.vertex =
strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl->shader->modern = true;
}
if (!string_is_empty(path))
video_shader_resolve_relative(glsl->shader, path);
video_shader_resolve_parameters(conf, glsl->shader);
if (conf)
{
config_file_free(conf);
conf = NULL;
}
stock_vertex = (glsl->shader->modern) ?
stock_vertex_modern : stock_vertex_legacy;
stock_fragment = (glsl->shader->modern) ?
stock_fragment_modern : stock_fragment_legacy;
if (glsl_core)
{
stock_vertex = stock_vertex_core;
stock_fragment = stock_fragment_core;
}
#ifdef HAVE_OPENGLES
if (!glsl->shader->modern)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
goto error;
}
#else
if (glsl_core && !glsl->shader->modern)
{
RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n");
goto error;
}
#endif
/* 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. */
*glsl->alias_define = '\0';
for (i = 0; i < glsl->shader->passes; i++)
{
if (*glsl->shader->pass[i].alias)
{
char define[128];
define[0] = '\0';
snprintf(define, sizeof(define), "#define %s_ALIAS\n",
glsl->shader->pass[i].alias);
strlcat(glsl->alias_define, define, sizeof(glsl->alias_define));
}
}
shader_prog_info.vertex = stock_vertex;
shader_prog_info.fragment = stock_fragment;
shader_prog_info.is_file = false;
if (!gl_glsl_compile_program(glsl, 0, &glsl->prg[0], &shader_prog_info))
{
RARCH_ERR("GLSL stock programs failed to compile.\n");
goto error;
}
if (!gl_glsl_compile_programs(glsl, &glsl->prg[1]))
goto error;
if (!gl_load_luts(glsl->shader, glsl->lut_textures))
{
RARCH_ERR("[GL]: Failed to load LUTs.\n");
goto error;
}
for (i = 0; i <= glsl->shader->passes; i++)
gl_glsl_find_uniforms(glsl, i, glsl->prg[i].id, &glsl->uniforms[i]);
#ifdef GLSL_DEBUG
if (!gl_check_error(&error_string))
{
RARCH_ERR("%s\n", error_string);
free(error_string);
RARCH_WARN("Detected GL error in GLSL.\n");
}
#endif
if (glsl->shader->variables)
{
retro_ctx_memory_info_t mem_info;
struct state_tracker_info info;
mem_info.id = RETRO_MEMORY_SYSTEM_RAM;
core_get_memory(&mem_info);
info.wram = (uint8_t*)mem_info.data;
info.info = glsl->shader->variable;
info.info_elem = glsl->shader->variables;
info.script = NULL;
info.script_class = NULL;
#ifdef HAVE_PYTHON
info.script = glsl->shader->script;
if (*glsl->shader->script_class)
info.script_class= glsl->shader->script_class;
#endif
info.script_is_file = NULL;
glsl->state_tracker = state_tracker_init(&info);
if (!glsl->state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl->prg[glsl->shader->passes + 1] = glsl->prg[0];
glsl->uniforms[glsl->shader->passes + 1] = glsl->uniforms[0];
if (glsl->shader->modern)
{
shader_prog_info.vertex =
glsl_core ?
stock_vertex_core_blend : stock_vertex_modern_blend;
shader_prog_info.fragment =
glsl_core ?
stock_fragment_core_blend : stock_fragment_modern_blend;
shader_prog_info.is_file = false;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_STOCK_BLEND,
&glsl->prg[VIDEO_SHADER_STOCK_BLEND],
&shader_prog_info
);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_STOCK_BLEND].id,
&glsl->uniforms[VIDEO_SHADER_STOCK_BLEND]);
}
else
{
glsl->prg[VIDEO_SHADER_STOCK_BLEND] = glsl->prg[0];
glsl->uniforms[VIDEO_SHADER_STOCK_BLEND] = glsl->uniforms[0];
}
#ifdef HAVE_SHADERPIPELINE
#ifdef HAVE_OPENGLES
if (gl_query_extension("GL_OES_standard_derivatives"))
{
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_ribbon_modern : stock_vertex_xmb_ribbon_legacy;
shader_prog_info.fragment = stock_fragment_xmb;
}
else
{
shader_prog_info.vertex = stock_vertex_xmb_ribbon_simple_legacy;
shader_prog_info.fragment = stock_fragment_xmb_ribbon_simple;
}
#else
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_ribbon_modern : stock_vertex_xmb_ribbon_legacy;
shader_prog_info.fragment = stock_fragment_xmb;
#endif
shader_prog_info.is_file = false;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_MENU,
&glsl->prg[VIDEO_SHADER_MENU],
&shader_prog_info);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_MENU].id,
&glsl->uniforms[VIDEO_SHADER_MENU]);
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_simple_modern : stock_vertex_xmb_ribbon_simple_legacy;
shader_prog_info.fragment = stock_fragment_xmb_ribbon_simple;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_MENU_2,
&glsl->prg[VIDEO_SHADER_MENU_2],
&shader_prog_info);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_MENU_2].id,
&glsl->uniforms[VIDEO_SHADER_MENU_2]);
#if defined(HAVE_OPENGLES)
shader_prog_info.vertex = stock_vertex_xmb_snow_modern;
#else
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_snow_modern : stock_vertex_xmb_snow_legacy;
#endif
shader_prog_info.fragment = stock_fragment_xmb_simple_snow;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_MENU_3,
&glsl->prg[VIDEO_SHADER_MENU_3],
&shader_prog_info);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_MENU_3].id,
&glsl->uniforms[VIDEO_SHADER_MENU_3]);
#if defined(HAVE_OPENGLES)
shader_prog_info.vertex = stock_vertex_xmb_snow_modern;
#else
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_snow_modern : stock_vertex_xmb_snow_legacy;
#endif
shader_prog_info.fragment = stock_fragment_xmb_snow;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_MENU_4,
&glsl->prg[VIDEO_SHADER_MENU_4],
&shader_prog_info);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_MENU_4].id,
&glsl->uniforms[VIDEO_SHADER_MENU_4]);
#if defined(HAVE_OPENGLES)
shader_prog_info.vertex = stock_vertex_xmb_snow_modern;
#else
shader_prog_info.vertex = glsl_core ? stock_vertex_xmb_snow_modern : stock_vertex_xmb_snow_legacy;
#endif
shader_prog_info.fragment = stock_fragment_xmb_bokeh;
gl_glsl_compile_program(
glsl,
VIDEO_SHADER_MENU_5,
&glsl->prg[VIDEO_SHADER_MENU_5],
&shader_prog_info);
gl_glsl_find_uniforms(glsl, 0, glsl->prg[VIDEO_SHADER_MENU_5].id,
&glsl->uniforms[VIDEO_SHADER_MENU_5]);
#endif
gl_glsl_reset_attrib(glsl);
for (i = 0; i < GFX_MAX_SHADERS; i++)
{
glGenBuffers(1, &glsl->vbo[i].vbo_primary);
glGenBuffers(1, &glsl->vbo[i].vbo_secondary);
}
return glsl;
error:
gl_glsl_destroy_resources(glsl);
if (conf)
config_file_free(conf);
if (glsl)
free(glsl);
return NULL;
}
bool gl_glsl_init(const char *path)
{
#if !defined(HAVE_OPENGLES2) && !defined(HAVE_OPENGL_MODERN) && !defined(__APPLE__)
// Load shader functions.
LOAD_GL_SYM(CreateProgram);
LOAD_GL_SYM(UseProgram);
LOAD_GL_SYM(CreateShader);
LOAD_GL_SYM(DeleteShader);
LOAD_GL_SYM(ShaderSource);
LOAD_GL_SYM(CompileShader);
LOAD_GL_SYM(AttachShader);
LOAD_GL_SYM(DetachShader);
LOAD_GL_SYM(LinkProgram);
LOAD_GL_SYM(GetUniformLocation);
LOAD_GL_SYM(Uniform1i);
LOAD_GL_SYM(Uniform1f);
LOAD_GL_SYM(Uniform2fv);
LOAD_GL_SYM(Uniform4fv);
LOAD_GL_SYM(UniformMatrix4fv);
LOAD_GL_SYM(GetShaderiv);
LOAD_GL_SYM(GetShaderInfoLog);
LOAD_GL_SYM(GetProgramiv);
LOAD_GL_SYM(GetProgramInfoLog);
LOAD_GL_SYM(DeleteProgram);
LOAD_GL_SYM(GetAttachedShaders);
LOAD_GL_SYM(GetAttribLocation);
LOAD_GL_SYM(EnableVertexAttribArray);
LOAD_GL_SYM(DisableVertexAttribArray);
LOAD_GL_SYM(VertexAttribPointer);
RARCH_LOG("Checking GLSL shader support ...\n");
bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
&& pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
&& pglDetachShader && pglLinkProgram && pglGetUniformLocation
&& pglUniform1i && pglUniform1f && pglUniform2fv && pglUniform4fv && pglUniformMatrix4fv
&& pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog
&& pglDeleteProgram && pglGetAttachedShaders
&& pglGetAttribLocation && pglEnableVertexAttribArray && pglDisableVertexAttribArray
&& pglVertexAttribPointer;
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
return false;
}
#endif
unsigned num_progs = 0;
struct shader_program progs[RARCH_GLSL_MAX_SHADERS] = {{0}};
if (path)
{
num_progs = get_xml_shaders(path, progs, RARCH_GLSL_MAX_SHADERS - 1);
if (num_progs == 0)
{
RARCH_ERR("Couldn't find any valid shaders in XML file.\n");
return false;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
num_progs = 1;
progs[0].vertex = strdup(stock_vertex_modern);
progs[0].fragment = strdup(stock_fragment_modern);
glsl_modern = true;
}
#ifdef HAVE_OPENGLES2
if (!glsl_modern)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
return false;
}
#endif
struct shader_program stock_prog = {0};
stock_prog.vertex = strdup(glsl_modern ? stock_vertex_modern : stock_vertex_legacy);
stock_prog.fragment = strdup(glsl_modern ? stock_fragment_modern : stock_fragment_legacy);
if (!compile_programs(&gl_program[0], &stock_prog, 1))
{
RARCH_ERR("GLSL stock programs failed to compile.\n");
return false;
}
for (unsigned i = 0; i < num_progs; i++)
{
gl_filter_type[i + 1] = progs[i].filter;
gl_scale[i + 1].type_x = progs[i].type_x;
gl_scale[i + 1].type_y = progs[i].type_y;
gl_scale[i + 1].scale_x = progs[i].scale_x;
gl_scale[i + 1].scale_y = progs[i].scale_y;
gl_scale[i + 1].abs_x = progs[i].abs_x;
gl_scale[i + 1].abs_y = progs[i].abs_y;
gl_scale[i + 1].valid = progs[i].valid_scale;
}
if (!compile_programs(&gl_program[1], progs, num_progs))
return false;
// RetroArch custom two-pass with two different files.
if (num_progs == 1 && *g_settings.video.second_pass_shader && g_settings.video.render_to_texture)
{
unsigned secondary_progs = get_xml_shaders(g_settings.video.second_pass_shader, progs, 1);
if (secondary_progs == 1)
{
if (!compile_programs(&gl_program[2], progs, 1))
{
RARCH_ERR("Failed to compile second pass shader.\n");
return false;
}
num_progs++;
}
else
{
RARCH_ERR("Did not find exactly one valid shader in secondary shader file.\n");
return false;
}
}
for (unsigned i = 0; i <= num_progs; i++)
find_uniforms(gl_program[i], &gl_uniforms[i]);
#ifdef GLSL_DEBUG
if (!gl_check_error())
RARCH_WARN("Detected GL error in GLSL.\n");
#endif
if (gl_tracker_info_cnt > 0)
{
struct state_tracker_info info = {0};
info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = gl_tracker_info;
info.info_elem = gl_tracker_info_cnt;
#ifdef HAVE_PYTHON
info.script = gl_script_program;
info.script_class = *gl_tracker_script_class ? gl_tracker_script_class : NULL;
info.script_is_file = false;
#endif
gl_state_tracker = state_tracker_init(&info);
if (!gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl_enable = true;
gl_num_programs = num_progs;
gl_program[gl_num_programs + 1] = gl_program[0];
gl_uniforms[gl_num_programs + 1] = gl_uniforms[0];
gl_glsl_reset_attrib();
return true;
}
bool gl_glsl_init(const char *path)
{
#ifndef __APPLE__
// Load shader functions.
LOAD_GL_SYM(CreateProgram);
LOAD_GL_SYM(UseProgram);
LOAD_GL_SYM(CreateShader);
LOAD_GL_SYM(DeleteShader);
LOAD_GL_SYM(ShaderSource);
LOAD_GL_SYM(CompileShader);
LOAD_GL_SYM(AttachShader);
LOAD_GL_SYM(DetachShader);
LOAD_GL_SYM(LinkProgram);
LOAD_GL_SYM(GetUniformLocation);
LOAD_GL_SYM(Uniform1i);
LOAD_GL_SYM(Uniform1f);
LOAD_GL_SYM(Uniform2fv);
LOAD_GL_SYM(Uniform4fv);
LOAD_GL_SYM(GetShaderiv);
LOAD_GL_SYM(GetShaderInfoLog);
LOAD_GL_SYM(GetProgramiv);
LOAD_GL_SYM(GetProgramInfoLog);
LOAD_GL_SYM(DeleteProgram);
LOAD_GL_SYM(GetAttachedShaders);
LOAD_GL_SYM(GetAttribLocation);
LOAD_GL_SYM(EnableVertexAttribArray);
LOAD_GL_SYM(DisableVertexAttribArray);
LOAD_GL_SYM(VertexAttribPointer);
#endif
RARCH_LOG("Checking GLSL shader support ...\n");
#ifdef __APPLE__
const bool shader_support = true;
#else
bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
&& pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
&& pglDetachShader && pglLinkProgram && pglGetUniformLocation
&& pglUniform1i && pglUniform1f && pglUniform2fv && pglUniform4fv
&& pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog
&& pglDeleteProgram && pglGetAttachedShaders
&& pglGetAttribLocation && pglEnableVertexAttribArray && pglDisableVertexAttribArray
&& pglVertexAttribPointer;
#endif
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
return false;
}
struct shader_program stock_prog = {0};
stock_prog.vertex = strdup(stock_vertex);
stock_prog.fragment = strdup(stock_fragment);
if (!compile_programs(&gl_program[0], &stock_prog, 1))
return false;
struct shader_program progs[MAX_PROGRAMS];
unsigned num_progs = get_xml_shaders(path, progs, MAX_PROGRAMS - 1);
if (num_progs == 0)
{
RARCH_ERR("Couldn't find any valid shaders in XML file.\n");
return false;
}
for (unsigned i = 0; i < num_progs; i++)
{
gl_filter_type[i + 1] = progs[i].filter;
gl_scale[i + 1].type_x = progs[i].type_x;
gl_scale[i + 1].type_y = progs[i].type_y;
gl_scale[i + 1].scale_x = progs[i].scale_x;
gl_scale[i + 1].scale_y = progs[i].scale_y;
gl_scale[i + 1].abs_x = progs[i].abs_x;
gl_scale[i + 1].abs_y = progs[i].abs_y;
gl_scale[i + 1].valid = progs[i].valid_scale;
}
if (!compile_programs(&gl_program[1], progs, num_progs))
return false;
// RetroArch custom two-pass with two different files.
if (num_progs == 1 && *g_settings.video.second_pass_shader && g_settings.video.render_to_texture)
{
unsigned secondary_progs = get_xml_shaders(g_settings.video.second_pass_shader, progs, 1);
if (secondary_progs == 1)
{
compile_programs(&gl_program[2], progs, 1);
num_progs++;
}
else
{
RARCH_ERR("Did not find valid shader in secondary shader file.\n");
return false;
}
}
//if (!gl_check_error())
// RARCH_WARN("Detected GL error.\n");
if (gl_tracker_info_cnt > 0)
{
struct state_tracker_info info = {0};
info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = gl_tracker_info;
info.info_elem = gl_tracker_info_cnt;
#ifdef HAVE_PYTHON
if (*gl_tracker_script)
info.script = gl_tracker_script;
else if (gl_script_program)
info.script = (const char*)gl_script_program;
else
info.script = NULL;
info.script_class = *gl_tracker_script_class ? gl_tracker_script_class : NULL;
info.script_is_file = *gl_tracker_script;
#endif
gl_state_tracker = state_tracker_init(&info);
if (!gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl_enable = true;
gl_num_programs = num_progs;
gl_program[gl_num_programs + 1] = gl_program[0];
gl_glsl_reset_attrib();
return true;
}
static bool gl_glsl_init(void *data, const char *path)
{
unsigned i;
(void)data;
#ifndef HAVE_OPENGLES2
RARCH_LOG("Checking GLSL shader support ...\n");
bool shader_support = glCreateProgram && glUseProgram && glCreateShader
&& glDeleteShader && glShaderSource && glCompileShader && glAttachShader
&& glDetachShader && glLinkProgram && glGetUniformLocation
&& glUniform1i && glUniform1f && glUniform2fv && glUniform4fv && glUniformMatrix4fv
&& glGetShaderiv && glGetShaderInfoLog && glGetProgramiv && glGetProgramInfoLog
&& glDeleteProgram && glGetAttachedShaders
&& glGetAttribLocation && glEnableVertexAttribArray && glDisableVertexAttribArray
&& glVertexAttribPointer
&& glGenBuffers && glBufferData && glDeleteBuffers && glBindBuffer;
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
return false;
}
#endif
glsl_shader = (struct gfx_shader*)calloc(1, sizeof(*glsl_shader));
if (!glsl_shader)
return false;
if (path)
{
bool ret;
if (strcmp(path_get_extension(path), "glsl") == 0)
{
strlcpy(glsl_shader->pass[0].source.cg, path, sizeof(glsl_shader->pass[0].source.cg));
glsl_shader->passes = 1;
glsl_shader->modern = true;
ret = true;
}
else if (strcmp(path_get_extension(path), "glslp") == 0)
{
config_file_t *conf = config_file_new(path);
if (conf)
{
ret = gfx_shader_read_conf_cgp(conf, glsl_shader);
glsl_shader->modern = true;
config_file_free(conf);
}
else
ret = false;
}
else
ret = gfx_shader_read_xml(path, glsl_shader);
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
return false;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl_shader->passes = 1;
glsl_shader->pass[0].source.xml.vertex = strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl_shader->pass[0].source.xml.fragment = strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl_shader->modern = true;
}
gfx_shader_resolve_relative(glsl_shader, path);
const char *stock_vertex = glsl_shader->modern ?
stock_vertex_modern : stock_vertex_legacy;
const char *stock_fragment = glsl_shader->modern ?
stock_fragment_modern : stock_fragment_legacy;
if (glsl_core)
{
stock_vertex = stock_vertex_core;
stock_fragment = stock_fragment_core;
}
#ifdef HAVE_OPENGLES2
if (!glsl_shader->modern)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
goto error;
}
#else
if (glsl_core && !glsl_shader->modern)
{
RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n");
goto error;
}
#endif
if (!(gl_program[0] = compile_program(stock_vertex, stock_fragment, 0)))
{
RARCH_ERR("GLSL stock programs failed to compile.\n");
goto error;
}
if (!compile_programs(&gl_program[1]))
goto error;
if (!gl_load_luts(glsl_shader, gl_teximage))
{
RARCH_ERR("[GL]: Failed to load LUTs.\n");
goto error;
}
for (i = 0; i <= glsl_shader->passes; i++)
find_uniforms(i, gl_program[i], &gl_uniforms[i]);
#ifdef GLSL_DEBUG
if (!gl_check_error())
RARCH_WARN("Detected GL error in GLSL.\n");
#endif
if (glsl_shader->variables)
{
struct state_tracker_info info = {0};
info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = glsl_shader->variable;
info.info_elem = glsl_shader->variables;
#ifdef HAVE_PYTHON
info.script = glsl_shader->script;
info.script_class = *glsl_shader->script_class ?
glsl_shader->script_class : NULL;
#endif
gl_state_tracker = state_tracker_init(&info);
if (!gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl_enable = true;
gl_program[glsl_shader->passes + 1] = gl_program[0];
gl_uniforms[glsl_shader->passes + 1] = gl_uniforms[0];
if (glsl_shader->modern)
{
gl_program[GL_SHADER_STOCK_BLEND] = compile_program(glsl_core ? stock_vertex_core_blend : stock_vertex_modern_blend,
glsl_core ? stock_fragment_core_blend : stock_fragment_modern_blend, GL_SHADER_STOCK_BLEND);
find_uniforms(0, gl_program[GL_SHADER_STOCK_BLEND], &gl_uniforms[GL_SHADER_STOCK_BLEND]);
}
else
{
gl_program[GL_SHADER_STOCK_BLEND] = gl_program[0];
gl_uniforms[GL_SHADER_STOCK_BLEND] = gl_uniforms[0];
}
gl_glsl_reset_attrib();
for (i = 0; i < GFX_MAX_SHADERS; i++)
{
glGenBuffers(1, &glsl_vbo[i].vbo_primary);
glGenBuffers(1, &glsl_vbo[i].vbo_secondary);
}
return true;
error:
gl_glsl_deinit();
return false;
}
static bool gl_glsl_init(const char *path)
{
#if !defined(HAVE_OPENGLES2) && !defined(HAVE_OPENGL_MODERN) && !defined(__APPLE__)
// Load shader functions.
LOAD_GL_SYM(CreateProgram);
LOAD_GL_SYM(UseProgram);
LOAD_GL_SYM(CreateShader);
LOAD_GL_SYM(DeleteShader);
LOAD_GL_SYM(ShaderSource);
LOAD_GL_SYM(CompileShader);
LOAD_GL_SYM(AttachShader);
LOAD_GL_SYM(DetachShader);
LOAD_GL_SYM(LinkProgram);
LOAD_GL_SYM(GetUniformLocation);
LOAD_GL_SYM(Uniform1i);
LOAD_GL_SYM(Uniform1f);
LOAD_GL_SYM(Uniform2fv);
LOAD_GL_SYM(Uniform4fv);
LOAD_GL_SYM(UniformMatrix4fv);
LOAD_GL_SYM(GetShaderiv);
LOAD_GL_SYM(GetShaderInfoLog);
LOAD_GL_SYM(GetProgramiv);
LOAD_GL_SYM(GetProgramInfoLog);
LOAD_GL_SYM(DeleteProgram);
LOAD_GL_SYM(GetAttachedShaders);
LOAD_GL_SYM(GetAttribLocation);
LOAD_GL_SYM(EnableVertexAttribArray);
LOAD_GL_SYM(DisableVertexAttribArray);
LOAD_GL_SYM(VertexAttribPointer);
RARCH_LOG("Checking GLSL shader support ...\n");
bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
&& pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
&& pglDetachShader && pglLinkProgram && pglGetUniformLocation
&& pglUniform1i && pglUniform1f && pglUniform2fv && pglUniform4fv && pglUniformMatrix4fv
&& pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog
&& pglDeleteProgram && pglGetAttachedShaders
&& pglGetAttribLocation && pglEnableVertexAttribArray && pglDisableVertexAttribArray
&& pglVertexAttribPointer;
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
return false;
}
#endif
glsl_shader = (struct gfx_shader*)calloc(1, sizeof(*glsl_shader));
if (!glsl_shader)
return false;
if (path)
{
bool ret;
if (strcmp(path_get_extension(path), "glsl") == 0)
{
strlcpy(glsl_shader->pass[0].source.cg, path, sizeof(glsl_shader->pass[0].source.cg));
glsl_shader->passes = 1;
glsl_shader->modern = true;
ret = true;
}
else if (strcmp(path_get_extension(path), "glslp") == 0)
{
config_file_t *conf = config_file_new(path);
if (conf)
{
ret = gfx_shader_read_conf_cgp(conf, glsl_shader);
glsl_shader->modern = true;
config_file_free(conf);
}
else
ret = false;
}
else
ret = gfx_shader_read_xml(path, glsl_shader);
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
return false;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl_shader->passes = 1;
glsl_shader->pass[0].source.xml.vertex = strdup(stock_vertex_modern);
glsl_shader->pass[0].source.xml.fragment = strdup(stock_fragment_modern);
glsl_shader->modern = true;
}
gfx_shader_resolve_relative(glsl_shader, path);
#ifdef HAVE_OPENGLES2
if (!glsl_shader->modern)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
return false;
}
#endif
const char *stock_vertex = glsl_shader->modern ?
stock_vertex_modern : stock_vertex_legacy;
const char *stock_fragment = glsl_shader->modern ?
stock_fragment_modern : stock_fragment_legacy;
if (!(gl_program[0] = compile_program(stock_vertex, stock_fragment, 0)))
{
RARCH_ERR("GLSL stock programs failed to compile.\n");
gl_glsl_free_shader();
return false;
}
if (!compile_programs(&gl_program[1]))
{
gl_glsl_free_shader();
return false;
}
if (!load_luts())
{
RARCH_ERR("[GL]: Failed to load LUTs.\n");
gl_glsl_free_shader();
return false;
}
for (unsigned i = 0; i <= glsl_shader->passes; i++)
find_uniforms(gl_program[i], &gl_uniforms[i]);
#ifdef GLSL_DEBUG
if (!gl_check_error())
RARCH_WARN("Detected GL error in GLSL.\n");
#endif
if (glsl_shader->variables)
{
struct state_tracker_info info = {0};
info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = glsl_shader->variable;
info.info_elem = glsl_shader->variables;
#ifdef HAVE_PYTHON
info.script = glsl_shader->script;
info.script_class = *glsl_shader->script_class ?
glsl_shader->script_class : NULL;
#endif
gl_state_tracker = state_tracker_init(&info);
if (!gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl_enable = true;
gl_program[glsl_shader->passes + 1] = gl_program[0];
gl_uniforms[glsl_shader->passes + 1] = gl_uniforms[0];
if (glsl_shader->modern)
{
gl_program[GL_SHADER_STOCK_BLEND] = compile_program(stock_vertex_modern_blend,
stock_fragment_modern_blend, GL_SHADER_STOCK_BLEND);
find_uniforms(gl_program[GL_SHADER_STOCK_BLEND], &gl_uniforms[GL_SHADER_STOCK_BLEND]);
}
else
{
gl_program[GL_SHADER_STOCK_BLEND] = gl_program[0];
gl_uniforms[GL_SHADER_STOCK_BLEND] = gl_uniforms[0];
}
gl_glsl_reset_attrib();
return true;
}
static bool gl_glsl_init(void *data, const char *path)
{
unsigned i;
config_file_t *conf = NULL;
glsl_shader_data_t *glsl = NULL;
const char *stock_vertex = NULL;
const char *stock_fragment = NULL;
driver_t *driver = driver_get_ptr();
(void)data;
glsl = (glsl_shader_data_t*)calloc(1, sizeof(glsl_shader_data_t));
if (!glsl)
return false;
#ifndef HAVE_OPENGLES2
RARCH_LOG("Checking GLSL shader support ...\n");
bool shader_support = glCreateProgram && glUseProgram && glCreateShader
&& glDeleteShader && glShaderSource && glCompileShader && glAttachShader
&& glDetachShader && glLinkProgram && glGetUniformLocation
&& glUniform1i && glUniform1f && glUniform2fv && glUniform4fv
&& glUniformMatrix4fv
&& glGetShaderiv && glGetShaderInfoLog && glGetProgramiv
&& glGetProgramInfoLog
&& glDeleteProgram && glGetAttachedShaders
&& glGetAttribLocation && glEnableVertexAttribArray
&& glDisableVertexAttribArray
&& glVertexAttribPointer
&& glGenBuffers && glBufferData && glDeleteBuffers && glBindBuffer;
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
free(glsl);
return false;
}
#endif
glsl->shader = (struct video_shader*)calloc(1, sizeof(*glsl->shader));
if (!glsl->shader)
{
free(glsl);
return false;
}
if (path)
{
bool ret;
const char *path_ext = path_get_extension(path);
if (!strcmp(path_ext, "glsl"))
{
strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl->shader->pass[0].source.path));
glsl->shader->passes = 1;
glsl->shader->modern = true;
ret = true;
}
else if (!strcmp(path_ext, "glslp"))
{
conf = config_file_new(path);
if (conf)
{
ret = video_shader_read_conf_cgp(conf, glsl->shader);
glsl->shader->modern = true;
}
else
ret = false;
}
else
ret = false;
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
free(glsl->shader);
free(glsl);
return false;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl->shader->passes = 1;
glsl->shader->pass[0].source.string.vertex =
strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl->shader->modern = true;
}
video_shader_resolve_relative(glsl->shader, path);
video_shader_resolve_parameters(conf, glsl->shader);
if (conf)
{
config_file_free(conf);
conf = NULL;
}
stock_vertex = (glsl->shader->modern) ?
stock_vertex_modern : stock_vertex_legacy;
stock_fragment = (glsl->shader->modern) ?
stock_fragment_modern : stock_fragment_legacy;
if (glsl_core)
{
stock_vertex = stock_vertex_core;
stock_fragment = stock_fragment_core;
}
#ifdef HAVE_OPENGLES2
if (!glsl->shader->modern)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
goto error;
}
#else
if (glsl_core && !glsl->shader->modern)
{
RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n");
goto error;
}
#endif
/* 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. */
*glsl->glsl_alias_define = '\0';
for (i = 0; i < glsl->shader->passes; i++)
{
if (*glsl->shader->pass[i].alias)
{
char define[128] = {0};
snprintf(define, sizeof(define), "#define %s_ALIAS\n",
glsl->shader->pass[i].alias);
strlcat(glsl->glsl_alias_define, define, sizeof(glsl->glsl_alias_define));
}
}
if (!(glsl->gl_program[0] = compile_program(glsl, stock_vertex, stock_fragment, 0)))
{
RARCH_ERR("GLSL stock programs failed to compile.\n");
goto error;
}
if (!compile_programs(glsl, &glsl->gl_program[1]))
goto error;
if (!gl_load_luts(glsl->shader, glsl->gl_teximage))
{
RARCH_ERR("[GL]: Failed to load LUTs.\n");
goto error;
}
for (i = 0; i <= glsl->shader->passes; i++)
find_uniforms(glsl, i, glsl->gl_program[i], &glsl->gl_uniforms[i]);
#ifdef GLSL_DEBUG
if (!gl_check_error())
RARCH_WARN("Detected GL error in GLSL.\n");
#endif
if (glsl->shader->variables)
{
struct state_tracker_info info = {0};
info.wram = (uint8_t*)pretro_get_memory_data(RETRO_MEMORY_SYSTEM_RAM);
info.info = glsl->shader->variable;
info.info_elem = glsl->shader->variables;
#ifdef HAVE_PYTHON
info.script = glsl->shader->script;
info.script_class = *glsl->shader->script_class ?
glsl->shader->script_class : NULL;
#endif
glsl->gl_state_tracker = state_tracker_init(&info);
if (!glsl->gl_state_tracker)
RARCH_WARN("Failed to init state tracker.\n");
}
glsl->gl_program[glsl->shader->passes + 1] = glsl->gl_program[0];
glsl->gl_uniforms[glsl->shader->passes + 1] = glsl->gl_uniforms[0];
if (glsl->shader->modern)
{
glsl->gl_program[GL_SHADER_STOCK_BLEND] = compile_program(
glsl,
glsl_core ?
stock_vertex_core_blend : stock_vertex_modern_blend,
glsl_core ?
stock_fragment_core_blend : stock_fragment_modern_blend,
GL_SHADER_STOCK_BLEND);
find_uniforms(glsl, 0, glsl->gl_program[GL_SHADER_STOCK_BLEND],
&glsl->gl_uniforms[GL_SHADER_STOCK_BLEND]);
}
else
{
glsl->gl_program [GL_SHADER_STOCK_BLEND] = glsl->gl_program[0];
glsl->gl_uniforms[GL_SHADER_STOCK_BLEND] = glsl->gl_uniforms[0];
}
gl_glsl_reset_attrib(glsl);
for (i = 0; i < GFX_MAX_SHADERS; i++)
{
glGenBuffers(1, &glsl->glsl_vbo[i].vbo_primary);
glGenBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
}
driver->video_shader_data = glsl;
return true;
error:
gl_glsl_destroy_resources(glsl);
if (glsl)
free(glsl);
return false;
}