mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-02 05:54:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove video_shader_driver_ctl

Browse Source
This commit is contained in:
twinaphex 2016-05-08 21:11:27 +02:00
parent ed5954420b
commit 1b8e8ac22a
15 changed files with 331 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gfx/d3d/render_chain_xdk.cpp
View File

@ -50,7 +50,7 @@ static void renderchain_set_mvp(void *data, unsigned vp_width,
mvp.data = d3d;
mvp.matrix = NULL;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shadser_driver_set_mvp(&mvp);
#elif defined(HAVE_D3D8)
D3DXMATRIX p_out, p_rotate, mat;
D3DXMatrixOrthoOffCenterLH(&mat, 0, vp_width, vp_height, 0, 0.0f, 1.0f);
@ -224,7 +224,7 @@ static void renderchain_set_vertices(void *data, unsigned pass,
shader_info.idx = pass;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
params.data = d3d;
params.width = vert_width;
@ -240,7 +240,7 @@ static void renderchain_set_vertices(void *data, unsigned pass,
params.fbo_info = NULL;
params.fbo_info_cnt = 0;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params);
video_shader_driver_set_parameters(&params);
#endif
#endif
}

107
gfx/drivers/gl.c
View File

@ -275,7 +275,7 @@ static bool gl_shader_init(gl_t *gl)
init_data.data = gl;
init_data.path = shader_path;
if (video_shader_driver_ctl(SHADER_CTL_INIT, &init_data))
if (video_shader_driver_init(&init_data))
return true;
RARCH_ERR("[GL]: Failed to initialize shader, falling back to stock.\n");
@ -283,12 +283,7 @@ static bool gl_shader_init(gl_t *gl)
init_data.shader = NULL;
init_data.path = NULL;
return video_shader_driver_ctl(SHADER_CTL_INIT, &init_data);
}
static void gl_shader_deinit(gl_t *gl)
{
video_shader_driver_ctl(SHADER_CTL_DEINIT, NULL);
return video_shader_driver_init(&init_data);
}
#ifndef NO_GL_FF_VERTEX
@ -441,12 +436,12 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
glBindTexture(GL_TEXTURE_2D, texture);
mip_level = i + 2;
mipmapped = video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT, &mip_level);
mipmapped = video_shader_driver_mipmap_input(&mip_level);
min_filter = mipmapped ? base_mip_filt : base_filt;
filter_type.index = i + 2;
filter_type.smooth = &smooth;
if (video_shader_driver_ctl(SHADER_CTL_FILTER_TYPE, &filter_type))
if (video_shader_driver_filter_type(&filter_type))
{
min_filter = mipmapped ? (smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST)
@ -456,7 +451,7 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
mag_filter = min_filter_to_mag(min_filter);
wrap.idx = i + 2;
video_shader_driver_ctl(SHADER_CTL_WRAP_TYPE, &wrap);
video_shader_driver_wrap_type(&wrap);
wrap_enum = gl_wrap_type_to_enum(wrap.type);
@ -635,7 +630,7 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
video_shader_ctx_info_t shader_info;
struct gfx_fbo_scale scale, scale_last;
if (!video_shader_driver_ctl(SHADER_CTL_INFO, &shader_info))
if (!video_shader_driver_info(&shader_info))
return;
if (!gl || shader_info.num == 0)
@ -646,12 +641,12 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
scaler.idx = 1;
scaler.scale = &scale;
video_shader_driver_ctl(SHADER_CTL_SCALE, &scaler);
video_shader_driver_scale(&scaler);
scaler.idx = shader_info.num;
scaler.scale = &scale_last;
video_shader_driver_ctl(SHADER_CTL_SCALE, &scaler);
video_shader_driver_scale(&scaler);
/* we always want FBO to be at least initialized on startup for consoles */
if (shader_info.num == 1 && !scale.valid)
@ -682,7 +677,7 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
scaler.idx = i + 1;
scaler.scale = &gl->fbo_scale[i];
video_shader_driver_ctl(SHADER_CTL_SCALE, &scaler);
video_shader_driver_scale(&scaler);
if (!gl->fbo_scale[i].valid)
{
@ -703,8 +698,8 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
gl->fbo_rect[i].width, gl->fbo_rect[i].height);
}
gl->fbo_feedback_enable = video_shader_driver_ctl(
SHADER_CTL_GET_FEEDBACK_PASS, &gl->fbo_feedback_pass);
gl->fbo_feedback_enable = video_shader_driver_get_feedback_pass(
&gl->fbo_feedback_pass);
if (gl->fbo_feedback_enable && gl->fbo_feedback_pass
< (unsigned)gl->fbo_pass)
@ -1157,12 +1152,12 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
shader_info.idx = i + 1;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
mip_level = i + 1;
if (video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT, &mip_level))
if (video_shader_driver_mipmap_input(&mip_level))
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
@ -1184,19 +1179,19 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
params.fbo_info = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params);
video_shader_driver_set_parameters(&params);
gl->coords.vertices = 4;
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@ -1231,13 +1226,13 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
shader_info.idx = gl->fbo_pass + 1;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
mip_level = gl->fbo_pass + 1;
if (video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT, &mip_level))
if (video_shader_driver_mipmap_input(&mip_level))
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
@ -1257,7 +1252,7 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
params.fbo_info = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params);
video_shader_driver_set_parameters(&params);
gl->coords.vertex = gl->vertex_ptr;
@ -1266,12 +1261,12 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl->coords.tex_coord = gl->tex_info.coord;
@ -1617,7 +1612,7 @@ static INLINE void gl_set_shader_viewport(gl_t *gl, unsigned idx)
shader_info.idx = idx;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
gl_set_viewport(gl, width, height, false, true);
}
@ -1696,19 +1691,19 @@ static INLINE void gl_draw_texture(gl_t *gl)
shader_info.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
gl->coords.vertices = 4;
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp_no_rot;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glEnable(GL_BLEND);
@ -1767,7 +1762,7 @@ static bool gl_frame(void *data, const void *frame,
shader_info.idx = 1;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
#ifdef IOS
/* Apparently the viewport is lost each frame, thanks Apple. */
@ -1899,18 +1894,18 @@ static bool gl_frame(void *data, const void *frame,
params.fbo_info = NULL;
params.fbo_info_cnt = 0;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params);
video_shader_driver_set_parameters(&params);
gl->coords.vertices = 4;
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@ -1950,7 +1945,7 @@ static bool gl_frame(void *data, const void *frame,
shader_info.idx = 0;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
glBindTexture(GL_TEXTURE_2D, 0);
#ifndef NO_GL_FF_VERTEX
@ -2076,7 +2071,7 @@ static void gl_free(void *data)
if (font_driver_has_render_msg())
font_driver_free(NULL);
gl_shader_deinit(gl);
video_shader_driver_deinit();
#ifndef NO_GL_FF_VERTEX
gl_disable_client_arrays(gl);
@ -2727,10 +2722,10 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
hwr->version_major, hwr->version_minor);
#endif
if (!video_shader_driver_ctl(SHADER_CTL_INIT_FIRST, NULL))
if (!video_shader_driver_init_first())
goto error;
video_shader_driver_ctl(SHADER_CTL_GET_IDENT, &ident_info);
video_shader_driver_get_ident(&ident_info);
RARCH_LOG("[GL]: Default shader backend found: %s.\n", ident_info.ident);
@ -2744,13 +2739,13 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
unsigned minimum;
video_shader_ctx_texture_t texture_info;
video_shader_driver_ctl(SHADER_CTL_GET_PREV_TEXTURES, &texture_info);
video_shader_driver_get_prev_textures(&texture_info);
minimum = texture_info.id;
gl->textures = MAX(minimum + 1, gl->textures);
}
if (!video_shader_driver_ctl(SHADER_CTL_INFO, &shader_info))
if (!video_shader_driver_info(&shader_info))
goto error;
RARCH_LOG("[GL]: Using %u textures.\n", gl->textures);
@ -2766,13 +2761,11 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
gl_set_shader_viewport(gl, 1);
mip_level = 1;
gl->tex_mipmap = video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT,
&mip_level);
gl->tex_mipmap = video_shader_driver_mipmap_input(&mip_level);
shader_filter.index = 1;
shader_filter.smooth = &force_smooth;
if (video_shader_driver_ctl(SHADER_CTL_FILTER_TYPE, &shader_filter))
if (video_shader_driver_filter_type(&shader_filter))
gl->tex_min_filter = gl->tex_mipmap ? (force_smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST)
: (force_smooth ? GL_LINEAR : GL_NEAREST);
@ -2785,7 +2778,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
wrap_info.idx = 1;
video_shader_driver_ctl(SHADER_CTL_WRAP_TYPE, &wrap_info);
video_shader_driver_wrap_type(&wrap_info);
gl->wrap_mode = gl_wrap_type_to_enum(wrap_info.type);
@ -2926,18 +2919,16 @@ static void gl_update_tex_filter_frame(gl_t *gl)
shader_filter.index = 1;
shader_filter.smooth = &smooth;
if (!video_shader_driver_ctl(SHADER_CTL_FILTER_TYPE, &shader_filter))
if (!video_shader_driver_filter_type(&shader_filter))
smooth = settings->video.smooth;
mip_level = 1;
wrap_info.idx = 1;
video_shader_driver_ctl(SHADER_CTL_WRAP_TYPE, &wrap_info);
video_shader_driver_wrap_type(&wrap_info);
wrap_mode = gl_wrap_type_to_enum(wrap_info.type);
gl->tex_mipmap = video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT,
&mip_level);
gl->tex_mipmap = video_shader_driver_mipmap_input(&mip_level);
gl->video_info.smooth = smooth;
new_filt = gl->tex_mipmap ? (smooth ?
@ -2984,7 +2975,7 @@ static bool gl_set_shader(void *data,
if (type == RARCH_SHADER_NONE)
return false;
gl_shader_deinit(gl);
video_shader_driver_deinit();
switch (type)
{
@ -3013,11 +3004,11 @@ static bool gl_set_shader(void *data,
init_data.data = gl;
init_data.path = path;
if (!video_shader_driver_ctl(SHADER_CTL_INIT, &init_data))
if (!video_shader_driver_init(&init_data))
{
init_data.path = NULL;
video_shader_driver_ctl(SHADER_CTL_INIT, &init_data);
video_shader_driver_init(&init_data);
RARCH_WARN("[GL]: Failed to set multipass shader. Falling back to stock.\n");
@ -3026,7 +3017,7 @@ static bool gl_set_shader(void *data,
gl_update_tex_filter_frame(gl);
video_shader_driver_ctl(SHADER_CTL_GET_PREV_TEXTURES, &texture_info);
video_shader_driver_get_prev_textures(&texture_info);
textures = texture_info.id + 1;
@ -3514,7 +3505,7 @@ static void gl_render_overlay(gl_t *gl)
shader_info.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
gl->coords.vertex = gl->overlay_vertex_coord;
gl->coords.tex_coord = gl->overlay_tex_coord;
@ -3524,12 +3515,12 @@ static void gl_render_overlay(gl_t *gl)
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp_no_rot;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
for (i = 0; i < gl->overlays; i++)
{
@ -3684,7 +3675,7 @@ static struct video_shader *gl_get_current_shader(void *data)
{
video_shader_ctx_t shader_info;
video_shader_driver_ctl(SHADER_CTL_DIRECT_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_direct_get_current_shader(&shader_info);
return shader_info.data;
}

6
gfx/drivers_font/gl_raster_font.c
View File

@ -237,12 +237,12 @@ static void gl_raster_font_draw_vertices(gl_t *gl, const gfx_coords_t *coords)
coords_data.handle_data = NULL;
coords_data.data = coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords_data);
video_shader_driver_set_coords(&coords_data);
mvp.data = gl;
mvp.matrix = &gl->mvp_no_rot;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
}
@ -406,7 +406,7 @@ static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
shader_info.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
}
static void gl_raster_font_restore_viewport(gl_t *gl)

197
gfx/video_shader_driver.c
View File

@ -34,6 +34,9 @@ static const shader_backend_t *shader_ctx_drivers[] = {
NULL
};
static const shader_backend_t *current_shader = NULL;
static void *shader_data = NULL;
static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type type)
{
switch (type)
@ -72,35 +75,28 @@ static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type t
return NULL;
}
bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *data)
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture)
{
static const shader_backend_t *current_shader = NULL;
static void *shader_data = NULL;
switch (state)
{
case SHADER_CTL_GET_PREV_TEXTURES:
{
video_shader_ctx_texture_t *texture = (video_shader_ctx_texture_t*)data;
if (!!texture || !current_shader)
{
texture->id = 0;
return false;
}
texture->id = current_shader->get_prev_textures(shader_data);
}
break;
case SHADER_CTL_GET_IDENT:
{
video_shader_ctx_ident_t *ident = (video_shader_ctx_ident_t*)data;
return true;
}
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident)
{
if (!current_shader || !ident)
return false;
ident->ident = current_shader->ident;
}
break;
case SHADER_CTL_GET_CURRENT_SHADER:
{
video_shader_ctx_t *shader = (video_shader_ctx_t*)data;
return true;
}
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader)
{
void *video_driver = video_driver_get_ptr(false);
const video_poke_interface_t *video_poke = video_driver_get_poke();
@ -110,20 +106,21 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
if (!video_poke->get_current_shader)
return false;
shader->data = video_poke->get_current_shader(video_driver);
}
break;
case SHADER_CTL_DIRECT_GET_CURRENT_SHADER:
{
video_shader_ctx_t *shader = (video_shader_ctx_t*)data;
return true;
}
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader)
{
shader->data = NULL;
if (!current_shader || !current_shader->get_current_shader)
return false;
shader->data = current_shader->get_current_shader(shader_data);
}
break;
case SHADER_CTL_DEINIT:
return true;
}
bool video_shader_driver_deinit(void)
{
if (!current_shader)
return false;
@ -132,22 +129,20 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
shader_data = NULL;
current_shader = NULL;
break;
case SHADER_CTL_SET_PARAMETER:
{
struct uniform_info *param = (struct uniform_info*)data;
return true;
}
bool video_shader_driver_set_parameter(struct uniform_info *param)
{
if (!current_shader || !param)
return false;
current_shader->set_uniform_parameter(shader_data,
param, NULL);
}
break;
case SHADER_CTL_SET_PARAMS:
{
video_shader_ctx_params_t *params =
(video_shader_ctx_params_t*)data;
return true;
}
bool video_shader_driver_set_parameters(video_shader_ctx_params_t *params)
{
if (!current_shader || !current_shader->set_params)
return false;
current_shader->set_params(
@ -165,11 +160,12 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
params->feedback_info,
params->fbo_info,
params->fbo_info_cnt);
}
break;
/* Finds first suitable shader context driver. */
case SHADER_CTL_INIT_FIRST:
{
return true;
}
/* Finds first suitable shader context driver. */
bool video_shader_driver_init_first(void)
{
unsigned i;
for (i = 0; shader_ctx_drivers[i]; i++)
@ -177,11 +173,11 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
current_shader = shader_ctx_drivers[i];
return true;
}
}
return false;
case SHADER_CTL_INIT:
{
video_shader_ctx_init_t *init = (video_shader_ctx_init_t*)data;
}
bool video_shader_driver_init(video_shader_ctx_init_t *init)
{
void *tmp = NULL;
if (!init->shader || !init->shader->init)
@ -199,38 +195,40 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
shader_data = tmp;
current_shader = init->shader;
}
break;
case SHADER_CTL_GET_FEEDBACK_PASS:
return true;
}
bool video_shader_driver_get_feedback_pass(unsigned *data)
{
if (!current_shader || !current_shader->get_feedback_pass)
return false;
if (!current_shader->get_feedback_pass(shader_data,
(unsigned*)data))
if (!current_shader->get_feedback_pass(shader_data, data))
return false;
break;
case SHADER_CTL_MIPMAP_INPUT:
return true;
}
bool video_shader_driver_mipmap_input(unsigned *index)
{
if (!current_shader)
return false;
{
unsigned *index = (unsigned*)data;
if (!current_shader->mipmap_input(shader_data, *index))
return false;
}
break;
case SHADER_CTL_SET_COORDS:
{
video_shader_ctx_coords_t *coords = (video_shader_ctx_coords_t*)
data;
return true;
}
bool video_shader_driver_set_coords(video_shader_ctx_coords_t *coords)
{
if (!current_shader || !current_shader->set_coords)
return false;
if (!current_shader->set_coords(coords->handle_data,
shader_data, (const struct gfx_coords*)coords->data))
return false;
}
break;
case SHADER_CTL_SCALE:
{
video_shader_ctx_scale_t *scaler = (video_shader_ctx_scale_t*)data;
return true;
}
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler)
{
if (!scaler || !scaler->scale)
return false;
@ -240,70 +238,61 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
return false;
current_shader->shader_scale(shader_data, scaler->idx, scaler->scale);
}
break;
case SHADER_CTL_INFO:
{
video_shader_ctx_info_t *shader_info =
(video_shader_ctx_info_t*)data;
return true;
}
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info)
{
if (!shader_info || !current_shader)
return false;
shader_info->num = 0;
if (current_shader->num_shaders)
shader_info->num = current_shader->num_shaders(shader_data);
}
break;
case SHADER_CTL_SET_MVP:
{
video_shader_ctx_mvp_t *mvp = (video_shader_ctx_mvp_t*)data;
return true;
}
bool video_shader_driver_set_mvp(video_shader_ctx_mvp_t *mvp)
{
if (!current_shader || !current_shader->set_mvp)
return false;
if (!mvp || !mvp->matrix)
return false;
if (!current_shader->set_mvp(mvp->data, shader_data, mvp->matrix))
return false;
}
break;
case SHADER_CTL_FILTER_TYPE:
{
video_shader_ctx_filter_t *filter =
(video_shader_ctx_filter_t*)data;
return true;
}
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter)
{
if (!current_shader || !current_shader->filter_type || !filter)
return false;
if (!current_shader->filter_type(shader_data,
filter->index, filter->smooth))
return false;
}
break;
case SHADER_CTL_COMPILE_PROGRAM:
{
struct shader_program_info *program_info = (struct shader_program_info*)data;
return true;
}
bool video_shader_driver_compile_program(struct shader_program_info *program_info)
{
if (!current_shader || !program_info)
return false;
return current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info);
}
case SHADER_CTL_USE:
{
video_shader_ctx_info_t *shader_info = (video_shader_ctx_info_t*)data;
}
bool video_shader_driver_use(video_shader_ctx_info_t *shader_info)
{
if (!current_shader || !shader_info)
return false;
current_shader->use(shader_info->data, shader_data, shader_info->idx, shader_info->set_active);
}
break;
case SHADER_CTL_WRAP_TYPE:
{
video_shader_ctx_wrap_t *wrap = (video_shader_ctx_wrap_t*)data;
return true;
}
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
{
if (!current_shader || !current_shader->wrap_type)
return false;
wrap->type = current_shader->wrap_type(shader_data, wrap->idx);
}
break;
case SHADER_CTL_NONE:
default:
break;
}
return true;
}

65
gfx/video_shader_driver.h
View File

@ -55,31 +55,6 @@
extern "C" {
#endif
enum video_shader_driver_ctl_state
{
SHADER_CTL_NONE = 0,
SHADER_CTL_DEINIT,
SHADER_CTL_INIT,
/* Finds first suitable shader context driver. */
SHADER_CTL_INIT_FIRST,
SHADER_CTL_SET_PARAMETER,
SHADER_CTL_SET_PARAMS,
SHADER_CTL_GET_FEEDBACK_PASS,
SHADER_CTL_MIPMAP_INPUT,
SHADER_CTL_SET_COORDS,
SHADER_CTL_COMPILE_PROGRAM,
SHADER_CTL_SCALE,
SHADER_CTL_INFO,
SHADER_CTL_SET_MVP,
SHADER_CTL_FILTER_TYPE,
SHADER_CTL_USE,
SHADER_CTL_WRAP_TYPE,
SHADER_CTL_GET_CURRENT_SHADER,
SHADER_CTL_DIRECT_GET_CURRENT_SHADER,
SHADER_CTL_GET_IDENT,
SHADER_CTL_GET_PREV_TEXTURES
};
enum shader_uniform_type
{
UNIFORM_1F = 0,
@ -283,13 +258,49 @@ typedef struct video_shader_ctx_texture
unsigned id;
} video_shader_ctx_texture_t;
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture);
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident);
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_deinit(void);
bool video_shader_driver_set_parameter(struct uniform_info *param);
bool video_shader_driver_set_parameters(video_shader_ctx_params_t *params);
bool video_shader_driver_init_first(void);
bool video_shader_driver_init(video_shader_ctx_init_t *init);
bool video_shader_driver_get_feedback_pass(unsigned *data);
bool video_shader_driver_mipmap_input(unsigned *index);
bool video_shader_driver_set_coords(video_shader_ctx_coords_t *coords);
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler);
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info);
bool video_shader_driver_set_mvp(video_shader_ctx_mvp_t *mvp);
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter);
bool video_shader_driver_compile_program(struct shader_program_info *program_info);
bool video_shader_driver_use(video_shader_ctx_info_t *shader_info);
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap);
extern const shader_backend_t gl_glsl_backend;
extern const shader_backend_t hlsl_backend;
extern const shader_backend_t gl_cg_backend;
extern const shader_backend_t shader_null_backend;
bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *data);
#ifdef __cplusplus
}
#endif

2
menu/cbs/menu_cbs_get_value.c
View File

@ -296,7 +296,7 @@ static void menu_action_setting_disp_set_label_shader_parameter(
strlcpy(s2, path, len2);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_HLSL)
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
if (!shader_info.data)
return;

2
menu/cbs/menu_cbs_left.c
View File

@ -56,7 +56,7 @@ static int shader_action_parameter_left(unsigned type, const char *label,
video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
param = &shader_info.data->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0];
return generic_shader_action_parameter_left(shader_info.data, param, type, label, wraparound);

2
menu/cbs/menu_cbs_right.c
View File

@ -59,7 +59,7 @@ int shader_action_parameter_right(unsigned type, const char *label, bool wraparo
video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
param = &shader_info.data->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0];
return generic_shader_action_parameter_right(shader_info.data, param, type, label, wraparound);

2
menu/cbs/menu_cbs_start.c
View File

@ -119,7 +119,7 @@ static int action_start_shader_action_parameter(unsigned type, const char *label
video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
if (!shader_info.data)
return 0;

4
menu/drivers/nk_common.c
View File

@ -190,7 +190,7 @@ void nk_common_device_draw(struct nk_device *dev,
shader_info.data = NULL;
shader_info.idx = dev->prog;
shader_info.set_active = false;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]);
@ -253,7 +253,7 @@ void nk_common_device_draw(struct nk_device *dev,
shader_info.data = NULL;
shader_info.idx = (GLint)last_prog;
shader_info.set_active = false;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
glBindTexture(GL_TEXTURE_2D, (GLuint)last_tex);

2
menu/drivers/nk_menu.c
View File

@ -314,7 +314,7 @@ void nk_menu_wnd_shader_parameters(nk_menu_handle_t *zr)
nk_layout_row_dynamic(ctx, 30, 1);
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
if (shader_info.data)
{

4
menu/drivers_display/menu_display_d3d.cpp
View File

@ -201,7 +201,7 @@ static void menu_display_d3d_draw_pipeline(void *data)
shader_info.idx = draw->pipeline.id;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
t += 0.01;
@ -214,7 +214,7 @@ static void menu_display_d3d_draw_pipeline(void *data)
uniform_param.lookup.ident = "time";
uniform_param.result.f.v0 = t;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMETER, &uniform_param);
video_shader_driver_set_parameter(&uniform_param);
break;
}
#endif

10
menu/drivers_display/menu_display_gl.c
View File

@ -86,7 +86,7 @@ static void menu_display_gl_blend_begin(void)
shader_info.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
}
static void menu_display_gl_blend_end(void)
@ -137,13 +137,13 @@ static void menu_display_gl_draw(void *data)
coords.handle_data = gl;
coords.data = draw->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords);
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = draw->matrix_data ? (math_matrix_4x4*)draw->matrix_data
: (math_matrix_4x4*)menu_display_gl_get_default_mvp();
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp);
video_shader_driver_set_mvp(&mvp);
glDrawArrays(menu_display_prim_to_gl_enum(
draw->prim_type), 0, draw->coords->vertices);
@ -175,7 +175,7 @@ static void menu_display_gl_draw_pipeline(void *data)
shader_info.idx = draw->pipeline.id;
shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info);
video_shader_driver_use(&shader_info);
t += 0.01;
@ -188,7 +188,7 @@ static void menu_display_gl_draw_pipeline(void *data)
uniform_param.lookup.ident = "time";
uniform_param.result.f.v0 = t;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMETER, &uniform_param);
video_shader_driver_set_parameter(&uniform_param);
break;
}
#endif

2
menu/menu_displaylist.c
View File

@ -3620,7 +3620,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type, void *data)
case DISPLAYLIST_SHADER_PARAMETERS:
case DISPLAYLIST_SHADER_PARAMETERS_PRESET:
#ifdef HAVE_SHADER_MANAGER
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
if (shader_info.data)
ret = deferred_push_video_shader_parameters_common(

8
ui/drivers/ui_win32.c
View File

@ -121,7 +121,7 @@ static void shader_dlg_refresh_trackbar_label(int index)
video_shader_ctx_t shader_info;
char val_buffer[32] = {0};
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
if (floorf(shader_info.data->parameters[index].current)
== shader_info.data->parameters[index].current)
@ -141,7 +141,7 @@ static void shader_dlg_params_refresh(void)
int i;
video_shader_ctx_t shader_info;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
for (i = 0; i < GFX_MAX_PARAMETERS; i++)
{
@ -218,7 +218,7 @@ void shader_dlg_params_reload(void)
int i, pos_x, pos_y;
video_shader_ctx_t shader_info;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
shader_dlg_params_clear();
@ -353,7 +353,7 @@ static LRESULT CALLBACK ShaderDlgWndProc(HWND hwnd, UINT message,
int i, pos;
video_shader_ctx_t shader_info;
video_shader_driver_ctl(SHADER_CTL_GET_CURRENT_SHADER, &shader_info);
video_shader_driver_get_current_shader(&shader_info);
switch (message)
{