mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-17 11:43:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor shader subsystem

Browse Source
This commit is contained in:
twinaphex 2015-12-05 07:33:21 +01:00
parent 0cda0d042b
commit e735f84baa
11 changed files with 254 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
driver.h
View File

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

10
gfx/drivers/gl.c
View File

@ -1117,7 +1117,7 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
tex_info, gl->prev_info, feedback_info, fbo_tex_info, fbo_tex_info_cnt);
gl->coords.vertices = 4;
video_shader_driver_set_coords(gl->shader, &gl->coords);
video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@ -1166,7 +1166,7 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
gl->coords.vertex = gl->vertex_ptr;
gl->coords.vertices = 4;
video_shader_driver_set_coords(gl->shader, &gl->coords);
video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@ -1605,7 +1605,7 @@ static INLINE void gl_draw_texture(gl_t *gl)
video_shader_driver_use(gl->shader, gl, GL_SHADER_STOCK_BLEND);
gl->coords.vertices = 4;
video_shader_driver_set_coords(gl->shader, &gl->coords);
video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
glEnable(GL_BLEND);
@ -1774,7 +1774,7 @@ static bool gl_frame(void *data, const void *frame,
NULL, 0);
gl->coords.vertices = 4;
video_shader_driver_set_coords(gl->shader, &gl->coords);
video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@ -3247,7 +3247,7 @@ static void gl_render_overlay(void *data)
gl->coords.color = gl->overlay_color_coord;
gl->coords.vertices = 4 * gl->overlays;
video_shader_driver_set_coords(gl->shader, &gl->coords);
video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
for (i = 0; i < gl->overlays; i++)

12
gfx/drivers_font/gl_raster_font.c
View File

@ -228,8 +228,8 @@ static void gl_raster_font_draw_vertices(gl_t *gl, const gfx_coords_t *coords)
if (!gl)
return;
gl->shader->set_coords(coords);
gl->shader->set_mvp(gl, &gl->mvp_no_rot);
video_shader_driver_set_coords(gl->shader, NULL, coords);
video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
}
@ -367,10 +367,7 @@ static void gl_raster_font_render_message(
static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
{
unsigned width, height;
gl_t *gl = font->gl;
if (!gl)
return;
gl_t *gl = font ? font->gl : NULL;
video_driver_get_size(&width, &height);
@ -382,8 +379,7 @@ static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
glBindTexture(GL_TEXTURE_2D, font->tex);
if (gl->shader && gl->shader->use)
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
}
static void gl_raster_font_restore_viewport(gl_t *gl)

149
gfx/drivers_shader/shader_gl_cg.c
View File

@ -156,11 +156,10 @@ typedef struct cg_shader_data
CGcontext cgCtx;
} cg_shader_data_t;
static cg_shader_data_t *cg_data;
static void gl_cg_reset_attrib(void)
static void gl_cg_reset_attrib(void *data)
{
unsigned i;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
/* Add sanity check that we did not overflow. */
retro_assert(cg_data->cg_attrib_idx <= ARRAY_SIZE(cg_data->cg_attribs));
@ -170,8 +169,9 @@ static void gl_cg_reset_attrib(void)
cg_data->cg_attrib_idx = 0;
}
static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
if (cg_data && cg_data->prg[cg_data->active_idx].mvp)
{
cgGLSetMatrixParameterfc(cg_data->prg[cg_data->active_idx].mvp, mat->data);
@ -191,9 +191,10 @@ static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
} \
} while(0)
static bool gl_cg_set_coords(const void *data)
static bool gl_cg_set_coords(void *handle_data, void *shader_data, const void *data)
{
const struct gfx_coords *coords = (const struct gfx_coords*)data;
cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
if (!cg_data || !coords)
goto fallback;
@ -214,8 +215,10 @@ fallback:
#define set_param_1f(param, x) \
if (param) cgGLSetParameter1f(param, x)
static void gl_cg_set_texture_info(const struct cg_fbo_params *params, const struct gfx_tex_info *info)
static void gl_cg_set_texture_info(void *data,
const struct cg_fbo_params *params, const struct gfx_tex_info *info)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
CGparameter param = params->tex;
if (param)
{
@ -241,7 +244,8 @@ static void gl_cg_set_texture_info(const struct cg_fbo_params *params, const str
}
}
static void gl_cg_set_params(void *data, unsigned width, unsigned height,
static void gl_cg_set_params(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_count,
@ -256,8 +260,8 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_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;
cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
(void)data;
if (!cg_data || (cg_data->active_idx == 0) ||
(cg_data->active_idx == GL_SHADER_STOCK_BLEND))
return;
@ -286,14 +290,14 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
}
/* Set orig texture. */
gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].orig, info);
gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].orig, info);
/* Set feedback texture. */
gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].feedback, feedback_info);
gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].feedback, feedback_info);
/* Set prev textures. */
for (i = 0; i < PREV_TEXTURES; i++)
gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]);
gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]);
/* Set lookup textures. */
for (i = 0; i < cg_data->shader->luts; i++)
@ -322,7 +326,7 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
if (cg_data->active_idx)
{
for (i = 0; i < fbo_info_cnt; i++)
gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]);
gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]);
}
/* #pragma parameters. */
@ -359,9 +363,10 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
}
}
static void gl_cg_deinit_progs()
static void gl_cg_deinit_progs(void *data)
{
unsigned i;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return;
@ -387,14 +392,15 @@ static void gl_cg_deinit_progs()
memset(cg_data->prg, 0, sizeof(cg_data->prg));
}
static void gl_cg_destroy_resources()
static void gl_cg_destroy_resources(void *data)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return;
gl_cg_reset_attrib();
gl_cg_reset_attrib(data);
gl_cg_deinit_progs();
gl_cg_deinit_progs(data);
if (cg_data->shader && cg_data->shader->luts)
{
@ -413,8 +419,9 @@ static void gl_cg_destroy_resources()
}
/* Final deinit. */
static void gl_cg_deinit_context_state(void)
static void gl_cg_deinit_context_state(void *data)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (cg_data->cgCtx)
{
RARCH_LOG("CG: Destroying context.\n");
@ -424,16 +431,16 @@ static void gl_cg_deinit_context_state(void)
}
/* Full deinit. */
static void gl_cg_deinit(void)
static void gl_cg_deinit(void *data)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return;
gl_cg_destroy_resources();
gl_cg_deinit_context_state();
gl_cg_destroy_resources(cg_data);
gl_cg_deinit_context_state(cg_data);
free(cg_data);
cg_data = NULL;
}
#define SET_LISTING(cg_data, type) \
@ -443,13 +450,14 @@ static void gl_cg_deinit(void)
listing_##type = strdup(list); \
}
static bool load_program(unsigned idx, const char *prog, bool path_is_file)
static bool load_program(void *data, unsigned idx, const char *prog, bool path_is_file)
{
const char *argv[2 + GFX_MAX_SHADERS];
bool ret = true;
char *listing_f = NULL;
char *listing_v = NULL;
unsigned i, argc = 0;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
argv[argc++] = "-DPARAMETER_UNIFORM";
for (i = 0; i < GFX_MAX_SHADERS; i++)
@ -499,24 +507,25 @@ end:
return ret;
}
static void set_program_base_attrib(unsigned i);
static void set_program_base_attrib(void *data, unsigned i);
static bool load_stock(void)
static bool load_stock(void *data)
{
if (!load_program(0, stock_cg_program, false))
if (!load_program(data, 0, stock_cg_program, false))
{
RARCH_ERR("Failed to compile passthrough shader, is something wrong with your environment?\n");
return false;
}
set_program_base_attrib(0);
set_program_base_attrib(data, 0);
return true;
}
static bool load_plain(const char *path)
static bool load_plain(void *data, const char *path)
{
if (!load_stock())
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!load_stock(cg_data))
return false;
cg_data->shader = (struct video_shader*)calloc(1, sizeof(*cg_data->shader));
@ -530,7 +539,7 @@ static bool load_plain(const char *path)
RARCH_LOG("Loading Cg file: %s\n", path);
strlcpy(cg_data->shader->pass[0].source.path, path,
sizeof(cg_data->shader->pass[0].source.path));
if (!load_program(1, path, true))
if (!load_program(data, 1, path, true))
return false;
}
else
@ -543,10 +552,11 @@ static bool load_plain(const char *path)
return true;
}
static bool gl_cg_load_imports(void)
static bool gl_cg_load_imports(void *data)
{
unsigned i;
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;
@ -595,24 +605,27 @@ static bool gl_cg_load_imports(void)
return true;
}
static bool load_shader(unsigned i)
static bool load_shader(void *data, unsigned i)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
RARCH_LOG("Loading Cg shader: \"%s\".\n",
cg_data->shader->pass[i].source.path);
if (!load_program(i + 1,
if (!load_program(data, i + 1,
cg_data->shader->pass[i].source.path, true))
return false;
return true;
}
static bool load_preset(const char *path)
static bool load_preset(void *data, const char *path)
{
unsigned i;
config_file_t *conf = NULL;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!load_stock())
if (!load_stock(cg_data))
return false;
RARCH_LOG("Loading Cg meta-shader: %s\n", path);
@ -657,7 +670,7 @@ static bool load_preset(const char *path)
for (i = 0; i < cg_data->shader->passes; i++)
{
if (!load_shader(i))
if (!load_shader(cg_data, i))
{
RARCH_ERR("Failed to load shaders ...\n");
return false;
@ -670,7 +683,7 @@ static bool load_preset(const char *path)
return false;
}
if (!gl_cg_load_imports())
if (!gl_cg_load_imports(cg_data))
{
RARCH_ERR("Failed to load imports ...\n");
return false;
@ -686,9 +699,11 @@ static bool load_preset(const char *path)
#define SEMANTIC_COLOR0 0xa9e93e54U
#define SEMANTIC_POSITION 0xd87309baU
static void set_program_base_attrib(unsigned i)
static void set_program_base_attrib(void *data, unsigned i)
{
CGparameter param = cgGetFirstParameter(cg_data->prg[i].vprg, CG_PROGRAM);
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
CGparameter param = cgGetFirstParameter(cg_data->prg[i].vprg, CG_PROGRAM);
for (; param; param = cgGetNextParameter(param))
{
uint32_t semantic_hash;
@ -760,9 +775,10 @@ static void set_pass_attrib(struct cg_program *program, struct cg_fbo_params *fb
fbo->coord = cgGetNamedParameter(program->vprg, attr_buf);
}
static void set_program_attributes(unsigned i)
static void set_program_attributes(void *data, unsigned i)
{
unsigned j;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return;
@ -770,7 +786,7 @@ static void set_program_attributes(unsigned i)
cgGLBindProgram(cg_data->prg[i].fprg);
cgGLBindProgram(cg_data->prg[i].vprg);
set_program_base_attrib(i);
set_program_base_attrib(cg_data, i);
cg_data->prg[i].vid_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.video_size");
cg_data->prg[i].tex_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.texture_size");
@ -863,13 +879,14 @@ static void set_program_attributes(unsigned i)
}
}
static bool gl_cg_init(void *data, const char *path)
static void *gl_cg_init(void *data, const char *path)
{
unsigned i;
cg_data = (cg_shader_data_t*)calloc(1, sizeof(cg_shader_data_t));
cg_shader_data_t *cg_data = (cg_shader_data_t*)
calloc(1, sizeof(cg_shader_data_t));
if (!cg_data)
return false;
return NULL;
#ifdef HAVE_CG_RUNTIME_COMPILER
cgRTCgcInit();
@ -880,9 +897,7 @@ static bool gl_cg_init(void *data, const char *path)
if (!cg_data->cgCtx)
{
RARCH_ERR("Failed to create Cg context\n");
free(cg_data);
cg_data = NULL;
return false;
goto error;
}
#ifdef RARCH_CG_DEBUG
@ -914,18 +929,18 @@ static bool gl_cg_init(void *data, const char *path)
if (path && !strcmp(path_get_extension(path), "cgp"))
{
if (!load_preset(path))
if (!load_preset(cg_data, path))
goto error;
}
else
{
if (!load_plain(path))
if (!load_plain(cg_data, path))
goto error;
}
cg_data->prg[0].mvp = cgGetNamedParameter(cg_data->prg[0].vprg, "IN.mvp_matrix");
for (i = 1; i <= cg_data->shader->passes; i++)
set_program_attributes(i);
set_program_attributes(cg_data, i);
/* If we aren't using last pass non-FBO shader,
* this shader will be assumed to be "fixed-function".
@ -940,21 +955,21 @@ static bool gl_cg_init(void *data, const char *path)
cgGLBindProgram(cg_data->prg[1].fprg);
cgGLBindProgram(cg_data->prg[1].vprg);
return true;
return cg_data;
error:
gl_cg_destroy_resources();
gl_cg_destroy_resources(cg_data);
if (!cg_data)
free(cg_data);
cg_data = NULL;
return false;
return NULL;
}
static void gl_cg_use(void *data, unsigned idx)
static void gl_cg_use(void *data, void *shader_data, unsigned idx)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
if (cg_data && cg_data->prg[idx].vprg && cg_data->prg[idx].fprg)
{
gl_cg_reset_attrib();
gl_cg_reset_attrib(cg_data);
cg_data->active_idx = idx;
cgGLBindProgram(cg_data->prg[idx].vprg);
@ -962,15 +977,17 @@ static void gl_cg_use(void *data, unsigned idx)
}
}
static unsigned gl_cg_num(void)
static unsigned gl_cg_num(void *data)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return 0;
return cg_data->shader->passes;
}
static bool gl_cg_filter_type(unsigned idx, bool *smooth)
static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (cg_data && idx &&
(cg_data->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
)
@ -982,25 +999,28 @@ static bool gl_cg_filter_type(unsigned idx, bool *smooth)
return false;
}
static enum gfx_wrap_type gl_cg_wrap_type(unsigned idx)
static enum gfx_wrap_type gl_cg_wrap_type(void *data, unsigned idx)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (cg_data && idx)
return cg_data->shader->pass[idx - 1].wrap;
return RARCH_WRAP_BORDER;
}
static void gl_cg_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
static void gl_cg_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (cg_data && idx)
*scale = cg_data->shader->pass[idx - 1].fbo;
else
scale->valid = false;
}
static unsigned gl_cg_get_prev_textures(void)
static unsigned gl_cg_get_prev_textures(void *data)
{
unsigned i, j;
unsigned max_prev = 0;
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return 0;
@ -1013,8 +1033,9 @@ static unsigned gl_cg_get_prev_textures(void)
return max_prev;
}
static bool gl_cg_get_feedback_pass(unsigned *pass)
static bool gl_cg_get_feedback_pass(void *data, unsigned *pass)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data || cg_data->shader->feedback_pass < 0)
return false;
@ -1022,15 +1043,17 @@ static bool gl_cg_get_feedback_pass(unsigned *pass)
return true;
}
static bool gl_cg_mipmap_input(unsigned idx)
static bool gl_cg_mipmap_input(void *data, unsigned idx)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (cg_data && idx)
return cg_data->shader->pass[idx - 1].mipmap;
return false;
}
static struct video_shader *gl_cg_get_current_shader(void)
static struct video_shader *gl_cg_get_current_shader(void *data)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
if (!cg_data)
return NULL;
return cg_data->shader;

100
gfx/drivers_shader/shader_glsl.c
View File

@ -707,36 +707,27 @@ static void gl_glsl_destroy_resources(glsl_shader_data_t *glsl)
memset(&glsl->glsl_vbo, 0, sizeof(glsl->glsl_vbo));
}
static void gl_glsl_deinit(void)
static void gl_glsl_deinit(void *data)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (!glsl)
return;
gl_glsl_destroy_resources(glsl);
if (driver->video_shader_data)
free(driver->video_shader_data);
driver->video_shader_data = NULL;
}
static bool gl_glsl_init(void *data, const char *path)
static void *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));
glsl_shader_data_t *glsl = (glsl_shader_data_t*)
calloc(1, sizeof(glsl_shader_data_t));
if (!glsl)
return false;
return NULL;
#ifndef HAVE_OPENGLES2
RARCH_LOG("Checking GLSL shader support ...\n");
@ -756,17 +747,13 @@ static bool gl_glsl_init(void *data, const char *path)
if (!shader_support)
{
RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
free(glsl);
return false;
goto error;
}
#endif
glsl->shader = (struct video_shader*)calloc(1, sizeof(*glsl->shader));
if (!glsl->shader)
{
free(glsl);
return false;
}
goto error;
if (path)
{
@ -798,9 +785,7 @@ static bool gl_glsl_init(void *data, const char *path)
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
free(glsl->shader);
free(glsl);
return false;
goto error;
}
}
else
@ -934,9 +919,7 @@ static bool gl_glsl_init(void *data, const char *path)
glGenBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
}
driver->video_shader_data = glsl;
return true;
return glsl;
error:
gl_glsl_destroy_resources(glsl);
@ -944,10 +927,11 @@ error:
if (glsl)
free(glsl);
return false;
return NULL;
}
static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
static void gl_glsl_set_params(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_count,
@ -967,8 +951,7 @@ 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 *fbo_info = (const struct gfx_tex_info*)_fbo_info;
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;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
if (!glsl)
return;
@ -1182,11 +1165,10 @@ 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, void *shader_data, const math_matrix_4x4 *mat)
{
int loc;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
(void)data;
@ -1203,7 +1185,7 @@ static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat)
return true;
}
static bool gl_glsl_set_coords(const void *data)
static bool gl_glsl_set_coords(void *handle_data, void *shader_data, const void *data)
{
/* Avoid hitting malloc on every single regular quad draw. */
GLfloat short_buffer[4 * (2 + 2 + 4 + 2)];
@ -1213,8 +1195,7 @@ static bool gl_glsl_set_coords(const void *data)
struct glsl_attrib *attr = NULL;
const struct shader_uniforms *uni = NULL;
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;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
if (!glsl || !glsl->shader->modern || !coords)
{
@ -1304,10 +1285,9 @@ static bool gl_glsl_set_coords(const void *data)
return true;
}
static void gl_glsl_use(void *data, unsigned idx)
static void gl_glsl_use(void *data, void *shader_data, unsigned idx)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
(void)data;
@ -1320,19 +1300,17 @@ static void gl_glsl_use(void *data, unsigned idx)
glUseProgram(glsl->gl_program[idx]);
}
static unsigned gl_glsl_num(void)
static unsigned gl_glsl_num(void *data)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && glsl->shader)
return glsl->shader->passes;
return 0;
}
static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
static bool gl_glsl_filter_type(void *data, unsigned idx, bool *smooth)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && idx
&& (glsl->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
)
@ -1343,31 +1321,28 @@ static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
return false;
}
static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx)
static enum gfx_wrap_type gl_glsl_wrap_type(void *data, unsigned idx)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && idx)
return glsl->shader->pass[idx - 1].wrap;
return RARCH_WRAP_BORDER;
}
static void gl_glsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
static void gl_glsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && idx)
*scale = glsl->shader->pass[idx - 1].fbo;
else
scale->valid = false;
}
static unsigned gl_glsl_get_prev_textures(void)
static unsigned gl_glsl_get_prev_textures(void *data)
{
unsigned i, j;
unsigned max_prev = 0;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (!glsl)
return 0;
@ -1380,19 +1355,17 @@ static unsigned gl_glsl_get_prev_textures(void)
return max_prev;
}
static bool gl_glsl_mipmap_input(unsigned idx)
static bool gl_glsl_mipmap_input(void *data, unsigned idx)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && idx)
return glsl->shader->pass[idx - 1].mipmap;
return false;
}
static bool gl_glsl_get_feedback_pass(unsigned *index)
static bool gl_glsl_get_feedback_pass(void *data, unsigned *index)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (!glsl || glsl->shader->feedback_pass < 0)
return false;
@ -1400,10 +1373,9 @@ static bool gl_glsl_get_feedback_pass(unsigned *index)
return true;
}
static struct video_shader *gl_glsl_get_current_shader(void)
static struct video_shader *gl_glsl_get_current_shader(void *data)
{
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (!glsl)
return NULL;
return glsl->shader;

54
gfx/drivers_shader/shader_hlsl.c
View File

@ -82,17 +82,18 @@ struct hlsl_program
XMMATRIX mvp_val; /* TODO: Move to D3DXMATRIX here */
};
typedef struct hlsl_shader_data
typedef struct hlsl_shader_data hlsl_shader_data_t;
struct hlsl_shader_data
{
struct hlsl_program prg[RARCH_HLSL_MAX_SHADERS];
unsigned active_idx;
struct video_shader *cg_shader;
} hlsl_shader_data_t;
};
static hlsl_shader_data_t *hlsl_data;
void hlsl_set_proj_matrix(XMMATRIX rotation_value)
void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)data;
if (hlsl_data)
hlsl_data->prg[hlsl_data->active_idx].mvp_val = rotation_value;
}
@ -102,7 +103,8 @@ void hlsl_set_proj_matrix(XMMATRIX rotation_value)
#define set_param_1f(param, x, constanttable) \
if (param) constanttable->SetFloat(d3d_device_ptr, param, x)
static void hlsl_set_params(void *data, unsigned width, unsigned height,
static void hlsl_set_params(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_counter,
@ -117,7 +119,7 @@ static void hlsl_set_params(void *data, unsigned width, unsigned height,
const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_info;
(void)_feedback_info;
const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info;
hlsl_shader_data_t *hlsl = hlsl_data;
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)shader_data;
if (!hlsl)
return;
@ -352,14 +354,15 @@ static bool hlsl_load_preset(hlsl_shader_data_t *hlsl, void *data, const char *p
return true;
}
static bool hlsl_init(void *data, const char *path)
static void *hlsl_init(void *data, const char *path)
{
unsigned i;
d3d_video_t *d3d = (d3d_video_t*)data;
hlsl_data = (hlsl_shader_data_t*)calloc(1, sizeof(hlsl_shader_data_t));
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)
calloc(1, sizeof(hlsl_shader_data_t));
if (!hlsl_data)
return false;
return NULL;
if (path && !strcmp(path_get_extension(path), ".cgp"))
{
@ -378,27 +381,28 @@ static bool hlsl_init(void *data, const char *path)
d3d_set_vertex_shader(d3d->dev, 1, hlsl_data->prg[1].vprg);
d3d->dev->SetPixelShader(hlsl_data->prg[1].fprg);
return true;
return hlsl_data;
error:
if (hlsl_data)
free(hlsl_data);
hlsl_data = NULL;
return false;
return NULL;
}
static void hlsl_deinit(void)
static void hlsl_deinit(void *data)
{
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
hlsl_deinit_state(hlsl_data);
if (hlsl_data)
free(hlsl_data);
hlsl_data = NULL;
}
static void hlsl_use(void *data, unsigned idx)
static void hlsl_use(void *data, void *shader_data, unsigned idx)
{
d3d_video_t *d3d = (d3d_video_t*)data;
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)shader_data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
if (hlsl_data && hlsl_data->prg[idx].vprg && hlsl_data->prg[idx].fprg)
@ -413,15 +417,17 @@ static void hlsl_use(void *data, unsigned idx)
}
}
static unsigned hlsl_num(void)
static unsigned hlsl_num(void *data)
{
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
if (hlsl_data)
return hlsl_data->cg_shader->passes;
return 0;
}
static bool hlsl_filter_type(unsigned idx, bool *smooth)
static bool hlsl_filter_type(void *data, unsigned idx, bool *smooth)
{
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
if (hlsl_data && idx
&& (hlsl_data->cg_shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC))
{
@ -431,18 +437,20 @@ static bool hlsl_filter_type(unsigned idx, bool *smooth)
return false;
}
static void hlsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
static void hlsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
{
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
if (hlsl_data && idx)
*scale = hlsl_data->cg_shader->pass[idx - 1].fbo;
else
scale->valid = false;
}
static bool hlsl_set_mvp(void *data, const math_matrix_4x4 *mat)
static bool hlsl_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3d_device_ptr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)shader_data;
if(hlsl_data && hlsl_data->prg[hlsl_data->active_idx].mvp)
{
@ -454,19 +462,19 @@ static bool hlsl_set_mvp(void *data, const math_matrix_4x4 *mat)
return false;
}
static bool hlsl_mipmap_input(unsigned idx)
static bool hlsl_mipmap_input(void *data, unsigned idx)
{
(void)idx;
return false;
}
static bool hlsl_get_feedback_pass(unsigned *idx)
static bool hlsl_get_feedback_pass(void *data, unsigned *idx)
{
(void)idx;
return false;
}
static struct video_shader *hlsl_get_current_shader(void)
static struct video_shader *hlsl_get_current_shader(void *data)
{
return NULL;
}

2
gfx/drivers_shader/shader_hlsl.h
View File

@ -21,7 +21,7 @@
#include "../video_shader_driver.h"
#include <stdint.h>
void hlsl_set_proj_matrix(XMMATRIX rotation_value);
void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value);
#define RARCH_HLSL_MAX_SHADERS 16

53
gfx/drivers_shader/shader_null.c
View File

@ -36,10 +36,33 @@
#include "../video_shader_driver.h"
static void shader_null_deinit(void) { }
static bool shader_null_init(void *data, const char *path) { return true; }
typedef struct null_shader_data
{
void *empty;
} null_shader_data_t;
static void shader_null_set_params(void *data, unsigned width, unsigned height,
static void shader_null_deinit(void *data)
{
null_shader_data_t *null_shader = (null_shader_data_t*)data;
if (!null_shader)
return;
free(null_shader);
}
static void *shader_null_init(void *data, const char *path)
{
null_shader_data_t *null_shader = (null_shader_data_t*)
calloc(1, sizeof(*null_shader));
if (!null_shader)
return NULL;
return null_shader;
}
static void shader_null_set_params(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_count,
@ -50,7 +73,7 @@ static void shader_null_set_params(void *data, unsigned width, unsigned height,
{
}
static bool shader_null_set_mvp(void *data, const math_matrix_4x4 *mat)
static bool shader_null_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
@ -61,7 +84,7 @@ static bool shader_null_set_mvp(void *data, const math_matrix_4x4 *mat)
return false;
}
static bool shader_null_set_coords(const void *data)
static bool shader_null_set_coords(void *handle_data, void *shader_data, const void *data)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
@ -75,55 +98,55 @@ static bool shader_null_set_coords(const void *data)
return false;
}
static void shader_null_use(void *data, unsigned idx)
static void shader_null_use(void *data, void *shader_data, unsigned idx)
{
(void)data;
(void)idx;
}
static unsigned shader_null_num(void)
static unsigned shader_null_num(void *data)
{
return 0;
}
static bool shader_null_filter_type(unsigned idx, bool *smooth)
static bool shader_null_filter_type(void *data, unsigned idx, bool *smooth)
{
(void)idx;
(void)smooth;
return false;
}
static enum gfx_wrap_type shader_null_wrap_type(unsigned idx)
static enum gfx_wrap_type shader_null_wrap_type(void *data, unsigned idx)
{
(void)idx;
return RARCH_WRAP_BORDER;
}
static void shader_null_shader_scale(unsigned idx,
struct gfx_fbo_scale *scale)
static void shader_null_shader_scale(void *data,
unsigned idx, struct gfx_fbo_scale *scale)
{
(void)idx;
(void)scale;
}
static unsigned shader_null_get_prev_textures(void)
static unsigned shader_null_get_prev_textures(void *data)
{
return 0;
}
static bool shader_null_mipmap_input(unsigned idx)
static bool shader_null_mipmap_input(void *data, unsigned idx)
{
(void)idx;
return false;
}
static bool shader_null_get_feedback_pass(unsigned *idx)
static bool shader_null_get_feedback_pass(void *data, unsigned *idx)
{
(void)idx;
return false;
}
static struct video_shader *shader_null_get_current_shader(void)
static struct video_shader *shader_null_get_current_shader(void *data)
{
return NULL;
}

53
gfx/video_shader_driver.c
View File

@ -32,6 +32,8 @@ static const shader_backend_t *shader_ctx_drivers[] = {
NULL
};
static void *shader_data;
/**
* shader_ctx_find_driver:
* @ident : Identifier of shader context driver to find.
@ -72,13 +74,12 @@ const shader_backend_t *shader_ctx_init_first(void)
struct video_shader *video_shader_driver_get_current_shader(void)
{
void *video_driver = video_driver_get_ptr(true);
const video_poke_interface_t *video_poke = video_driver_get_poke();
if (!video_poke || !video_driver)
if (!video_poke)
return NULL;
if (!video_poke->get_current_shader)
return NULL;
return video_poke->get_current_shader(video_driver);
return video_poke->get_current_shader(shader_data);
}
void video_shader_scale(unsigned idx,
@ -90,28 +91,41 @@ void video_shader_scale(unsigned idx,
scale->valid = false;
if (shader->shader_scale)
shader->shader_scale(idx, scale);
shader->shader_scale(shader_data, idx, scale);
}
bool video_shader_driver_init(const shader_backend_t *shader, void *data, const char *path)
{
void *tmp = NULL;
if (!shader || !shader->init)
return false;
return shader->init(data, path);
tmp = shader->init(data, path);
if (!tmp)
return false;
shader_data = tmp;
return true;
}
void video_shader_driver_deinit(const shader_backend_t *shader)
{
if (!shader)
return;
shader->deinit();
shader->deinit(shader_data);
shader_data = NULL;
}
void video_shader_driver_use(const shader_backend_t *shader, void *data, unsigned index)
{
if (!shader)
return;
shader->use(data, index);
shader->use(data, shader_data, index);
}
const char *video_shader_driver_get_ident(const shader_backend_t *shader)
@ -125,61 +139,61 @@ bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned i
{
if (!shader)
return false;
return shader->mipmap_input(index);
return shader->mipmap_input(shader_data, index);
}
unsigned video_shader_driver_num_shaders(const shader_backend_t *shader)
{
if (!shader)
return 0;
return shader->num_shaders();
return shader->num_shaders(shader_data);
}
unsigned video_shader_driver_get_prev_textures(const shader_backend_t *shader)
{
if (!shader)
return 0;
return shader->get_prev_textures();
return shader->get_prev_textures(shader_data);
}
bool video_shader_driver_set_coords(const shader_backend_t *shader, const void *data)
bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data)
{
if (!shader || !shader->set_coords)
return false;
return shader->set_coords(data);
return shader->set_coords(handle_data, shader_data, data);
}
bool video_shader_driver_set_mvp(const shader_backend_t *shader, void *data, const math_matrix_4x4 *mat)
{
if (!shader || !shader->set_mvp)
return false;
return shader->set_mvp(data, mat);
return shader->set_mvp(data, shader_data, mat);
}
bool video_shader_driver_filter_type(const shader_backend_t *shader, unsigned index, bool *smooth)
{
if (!shader || !shader->filter_type)
return false;
return shader->filter_type(index, smooth);
return shader->filter_type(shader_data, index, smooth);
}
enum gfx_wrap_type video_shader_driver_wrap_type(const shader_backend_t *shader, unsigned index)
{
return shader->wrap_type(index);
return shader->wrap_type(shader_data, index);
}
bool video_shader_driver_get_feedback_pass(const shader_backend_t *shader, unsigned *pass)
{
if (!shader || !shader->get_feedback_pass)
return false;
return shader->get_feedback_pass(pass);
return shader->get_feedback_pass(shader_data, pass);
}
struct video_shader *video_shader_driver_direct_get_current_shader(const shader_backend_t *shader)
{
if (!shader || !shader->get_current_shader)
return NULL;
return shader->get_current_shader();
return shader->get_current_shader(shader_data);
}
void video_shader_driver_set_params(const shader_backend_t *shader,
@ -193,8 +207,9 @@ void video_shader_driver_set_params(const shader_backend_t *shader,
const void *fbo_info, unsigned fbo_info_cnt)
{
if (!shader || !shader->set_params)
return NULL;
return shader->set_params(data, width, height, tex_width, tex_height,
return;
return shader->set_params(data, shader_data,
width, height, tex_width, tex_height,
out_width, out_height, frame_counter, info, prev_info, feedback_info,
fbo_info, fbo_info_cnt);
}

31
gfx/video_shader_driver.h
View File

@ -32,9 +32,10 @@ extern "C" {
typedef struct shader_backend
{
bool (*init)(void *data, const char *path);
void (*deinit)(void);
void (*set_params)(void *data, unsigned width, unsigned height,
void *(*init)(void *data, const char *path);
void (*deinit)(void *data);
void (*set_params)(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_counter,
@ -43,18 +44,18 @@ typedef struct shader_backend
const void *feedback_info,
const void *fbo_info, unsigned fbo_info_cnt);
void (*use)(void *data, unsigned index);
unsigned (*num_shaders)(void);
bool (*filter_type)(unsigned index, bool *smooth);
enum gfx_wrap_type (*wrap_type)(unsigned index);
void (*shader_scale)(unsigned index, struct gfx_fbo_scale *scale);
bool (*set_coords)(const void *data);
bool (*set_mvp)(void *data, const math_matrix_4x4 *mat);
unsigned (*get_prev_textures)(void);
bool (*get_feedback_pass)(unsigned *pass);
bool (*mipmap_input)(unsigned index);
void (*use)(void *data, void *shader_data, unsigned index);
unsigned (*num_shaders)(void *data);
bool (*filter_type)(void *data, unsigned index, bool *smooth);
enum gfx_wrap_type (*wrap_type)(void *data, unsigned index);
void (*shader_scale)(void *data, unsigned index, struct gfx_fbo_scale *scale);
bool (*set_coords)(void *handle_data, void *shader_data, const void *data);
bool (*set_mvp)(void *data, void *shader_data, const math_matrix_4x4 *mat);
unsigned (*get_prev_textures)(void *data);
bool (*get_feedback_pass)(void *data, unsigned *pass);
bool (*mipmap_input)(void *data, unsigned index);
struct video_shader *(*get_current_shader)(void);
struct video_shader *(*get_current_shader)(void *data);
enum rarch_shader_type type;
@ -127,7 +128,7 @@ bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned i
unsigned video_shader_driver_num_shaders(const shader_backend_t *shader);
bool video_shader_driver_set_coords(const shader_backend_t *shader, const void *data);
bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data);
bool video_shader_driver_set_mvp(const shader_backend_t *shader, void *data, const math_matrix_4x4 *mat);

7
menu/drivers_display/menu_display_gl.c
View File

@ -82,8 +82,7 @@ static void menu_display_gl_blend_begin(void)
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (gl->shader && gl->shader->use)
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
}
static void menu_display_gl_blend_end(void)
@ -122,8 +121,8 @@ static void menu_display_gl_draw(
glViewport(x, y, width, height);
glBindTexture(GL_TEXTURE_2D, (GLuint)texture);
gl->shader->set_coords(coords);
gl->shader->set_mvp(video_driver_get_ptr(false), mat);
video_shader_driver_set_coords(gl->shader, gl, coords);
video_shader_driver_set_mvp(gl->shader, video_driver_get_ptr(false), mat);
glDrawArrays(menu_display_prim_to_gl_enum(prim_type), 0, coords->vertices);