mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-02 14:54:10 +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.data = d3d;
mvp.matrix = NULL; mvp.matrix = NULL;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp); video_shadser_driver_set_mvp(&mvp);
#elif defined(HAVE_D3D8) #elif defined(HAVE_D3D8)
D3DXMATRIX p_out, p_rotate, mat; D3DXMATRIX p_out, p_rotate, mat;
D3DXMatrixOrthoOffCenterLH(&mat, 0, vp_width, vp_height, 0, 0.0f, 1.0f); 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.idx = pass;
shader_info.set_active = true; shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info); video_shader_driver_use(&shader_info);
params.data = d3d; params.data = d3d;
params.width = vert_width; params.width = vert_width;
@ -240,7 +240,7 @@ static void renderchain_set_vertices(void *data, unsigned pass,
params.fbo_info = NULL; params.fbo_info = NULL;
params.fbo_info_cnt = 0; params.fbo_info_cnt = 0;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params); video_shader_driver_set_parameters(&params);
#endif #endif
#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.data = gl;
init_data.path = shader_path; init_data.path = shader_path;
if (video_shader_driver_ctl(SHADER_CTL_INIT, &init_data)) if (video_shader_driver_init(&init_data))
return true; return true;
RARCH_ERR("[GL]: Failed to initialize shader, falling back to stock.\n"); 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.shader = NULL;
init_data.path = NULL; init_data.path = NULL;
return video_shader_driver_ctl(SHADER_CTL_INIT, &init_data); return video_shader_driver_init(&init_data);
}
static void gl_shader_deinit(gl_t *gl)
{
video_shader_driver_ctl(SHADER_CTL_DEINIT, NULL);
} }
#ifndef NO_GL_FF_VERTEX #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); glBindTexture(GL_TEXTURE_2D, texture);
mip_level = i + 2; 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; min_filter = mipmapped ? base_mip_filt : base_filt;
filter_type.index = i + 2; filter_type.index = i + 2;
filter_type.smooth = &smooth; 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 ? min_filter = mipmapped ? (smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) 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); mag_filter = min_filter_to_mag(min_filter);
wrap.idx = i + 2; 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); 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; video_shader_ctx_info_t shader_info;
struct gfx_fbo_scale scale, scale_last; 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; return;
if (!gl || shader_info.num == 0) 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.idx = 1;
scaler.scale = &scale; scaler.scale = &scale;
video_shader_driver_ctl(SHADER_CTL_SCALE, &scaler); video_shader_driver_scale(&scaler);
scaler.idx = shader_info.num; scaler.idx = shader_info.num;
scaler.scale = &scale_last; 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 */ /* we always want FBO to be at least initialized on startup for consoles */
if (shader_info.num == 1 && !scale.valid) 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.idx = i + 1;
scaler.scale = &gl->fbo_scale[i]; 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) 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_rect[i].width, gl->fbo_rect[i].height);
} }
gl->fbo_feedback_enable = video_shader_driver_ctl( gl->fbo_feedback_enable = video_shader_driver_get_feedback_pass(
SHADER_CTL_GET_FEEDBACK_PASS, &gl->fbo_feedback_pass); &gl->fbo_feedback_pass);
if (gl->fbo_feedback_enable && gl->fbo_feedback_pass if (gl->fbo_feedback_enable && gl->fbo_feedback_pass
< (unsigned)gl->fbo_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.idx = i + 1;
shader_info.set_active = true; 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]); glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
mip_level = 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); glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT); 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 = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt; 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; gl->coords.vertices = 4;
coords.handle_data = NULL; coords.handle_data = NULL;
coords.data = &gl->coords; coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = &gl->mvp; 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); 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.idx = gl->fbo_pass + 1;
shader_info.set_active = true; 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]); glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
mip_level = 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); glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT); 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 = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt; 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; 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.handle_data = NULL;
coords.data = &gl->coords; coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = &gl->mvp; 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); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl->coords.tex_coord = gl->tex_info.coord; 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.idx = idx;
shader_info.set_active = true; 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); 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.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true; shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info); video_shader_driver_use(&shader_info);
gl->coords.vertices = 4; gl->coords.vertices = 4;
coords.handle_data = NULL; coords.handle_data = NULL;
coords.data = &gl->coords; coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = &gl->mvp_no_rot; mvp.matrix = &gl->mvp_no_rot;
video_shader_driver_ctl(SHADER_CTL_SET_MVP, &mvp); video_shader_driver_set_mvp(&mvp);
glEnable(GL_BLEND); glEnable(GL_BLEND);
@ -1767,7 +1762,7 @@ static bool gl_frame(void *data, const void *frame,
shader_info.idx = 1; shader_info.idx = 1;
shader_info.set_active = true; shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info); video_shader_driver_use(&shader_info);
#ifdef IOS #ifdef IOS
/* Apparently the viewport is lost each frame, thanks Apple. */ /* 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 = NULL;
params.fbo_info_cnt = 0; params.fbo_info_cnt = 0;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMS, &params); video_shader_driver_set_parameters(&params);
gl->coords.vertices = 4; gl->coords.vertices = 4;
coords.handle_data = NULL; coords.handle_data = NULL;
coords.data = &gl->coords; coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = &gl->mvp; 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); 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.idx = 0;
shader_info.set_active = true; 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); glBindTexture(GL_TEXTURE_2D, 0);
#ifndef NO_GL_FF_VERTEX #ifndef NO_GL_FF_VERTEX
@ -2076,7 +2071,7 @@ static void gl_free(void *data)
if (font_driver_has_render_msg()) if (font_driver_has_render_msg())
font_driver_free(NULL); font_driver_free(NULL);
gl_shader_deinit(gl); video_shader_driver_deinit();
#ifndef NO_GL_FF_VERTEX #ifndef NO_GL_FF_VERTEX
gl_disable_client_arrays(gl); 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); hwr->version_major, hwr->version_minor);
#endif #endif
if (!video_shader_driver_ctl(SHADER_CTL_INIT_FIRST, NULL)) if (!video_shader_driver_init_first())
goto error; 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); 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; unsigned minimum;
video_shader_ctx_texture_t texture_info; 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; minimum = texture_info.id;
gl->textures = MAX(minimum + 1, gl->textures); 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; goto error;
RARCH_LOG("[GL]: Using %u textures.\n", gl->textures); 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); gl_set_shader_viewport(gl, 1);
mip_level = 1; mip_level = 1;
gl->tex_mipmap = video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT, gl->tex_mipmap = video_shader_driver_mipmap_input(&mip_level);
&mip_level);
shader_filter.index = 1; shader_filter.index = 1;
shader_filter.smooth = &force_smooth; 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->tex_min_filter = gl->tex_mipmap ? (force_smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST)
: (force_smooth ? GL_LINEAR : GL_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; 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); 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.index = 1;
shader_filter.smooth = &smooth; 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; smooth = settings->video.smooth;
mip_level = 1; mip_level = 1;
wrap_info.idx = 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); wrap_mode = gl_wrap_type_to_enum(wrap_info.type);
gl->tex_mipmap = video_shader_driver_mipmap_input(&mip_level);
gl->tex_mipmap = video_shader_driver_ctl(SHADER_CTL_MIPMAP_INPUT,
&mip_level);
gl->video_info.smooth = smooth; gl->video_info.smooth = smooth;
new_filt = gl->tex_mipmap ? (smooth ? new_filt = gl->tex_mipmap ? (smooth ?
@ -2984,7 +2975,7 @@ static bool gl_set_shader(void *data,
if (type == RARCH_SHADER_NONE) if (type == RARCH_SHADER_NONE)
return false; return false;
gl_shader_deinit(gl); video_shader_driver_deinit();
switch (type) switch (type)
{ {
@ -3013,11 +3004,11 @@ static bool gl_set_shader(void *data,
init_data.data = gl; init_data.data = gl;
init_data.path = path; 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; 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"); 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); 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; 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.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true; 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.vertex = gl->overlay_vertex_coord;
gl->coords.tex_coord = gl->overlay_tex_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.handle_data = NULL;
coords.data = &gl->coords; coords.data = &gl->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = &gl->mvp_no_rot; 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++) 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_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; 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.handle_data = NULL;
coords_data.data = coords; 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.data = gl;
mvp.matrix = &gl->mvp_no_rot; 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); 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.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true; 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) 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 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) static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type type)
{ {
switch (type) switch (type)
@ -72,35 +75,28 @@ static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type t
return NULL; 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) if (!!texture || !current_shader)
{ {
texture->id = 0; texture->id = 0;
return false; return false;
} }
texture->id = current_shader->get_prev_textures(shader_data); texture->id = current_shader->get_prev_textures(shader_data);
}
break; return true;
case SHADER_CTL_GET_IDENT: }
{
video_shader_ctx_ident_t *ident = (video_shader_ctx_ident_t*)data; bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident)
{
if (!current_shader || !ident) if (!current_shader || !ident)
return false; return false;
ident->ident = current_shader->ident; ident->ident = current_shader->ident;
} return true;
break; }
case SHADER_CTL_GET_CURRENT_SHADER:
{ bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader)
video_shader_ctx_t *shader = (video_shader_ctx_t*)data; {
void *video_driver = video_driver_get_ptr(false); void *video_driver = video_driver_get_ptr(false);
const video_poke_interface_t *video_poke = video_driver_get_poke(); 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) if (!video_poke->get_current_shader)
return false; return false;
shader->data = video_poke->get_current_shader(video_driver); shader->data = video_poke->get_current_shader(video_driver);
} return true;
break; }
case SHADER_CTL_DIRECT_GET_CURRENT_SHADER:
{
video_shader_ctx_t *shader = (video_shader_ctx_t*)data;
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader)
{
shader->data = NULL; shader->data = NULL;
if (!current_shader || !current_shader->get_current_shader) if (!current_shader || !current_shader->get_current_shader)
return false; return false;
shader->data = current_shader->get_current_shader(shader_data); shader->data = current_shader->get_current_shader(shader_data);
} return true;
break; }
case SHADER_CTL_DEINIT:
bool video_shader_driver_deinit(void)
{
if (!current_shader) if (!current_shader)
return false; return false;
@ -132,22 +129,20 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
shader_data = NULL; shader_data = NULL;
current_shader = NULL; current_shader = NULL;
break; return true;
case SHADER_CTL_SET_PARAMETER: }
{
struct uniform_info *param = (struct uniform_info*)data;
bool video_shader_driver_set_parameter(struct uniform_info *param)
{
if (!current_shader || !param) if (!current_shader || !param)
return false; return false;
current_shader->set_uniform_parameter(shader_data, current_shader->set_uniform_parameter(shader_data,
param, NULL); param, NULL);
} return true;
break; }
case SHADER_CTL_SET_PARAMS:
{
video_shader_ctx_params_t *params =
(video_shader_ctx_params_t*)data;
bool video_shader_driver_set_parameters(video_shader_ctx_params_t *params)
{
if (!current_shader || !current_shader->set_params) if (!current_shader || !current_shader->set_params)
return false; return false;
current_shader->set_params( 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->feedback_info,
params->fbo_info, params->fbo_info,
params->fbo_info_cnt); params->fbo_info_cnt);
} return true;
break; }
/* Finds first suitable shader context driver. */
case SHADER_CTL_INIT_FIRST: /* Finds first suitable shader context driver. */
{ bool video_shader_driver_init_first(void)
{
unsigned i; unsigned i;
for (i = 0; shader_ctx_drivers[i]; 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]; current_shader = shader_ctx_drivers[i];
return true; return true;
} }
}
return false; 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; void *tmp = NULL;
if (!init->shader || !init->shader->init) 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; shader_data = tmp;
current_shader = init->shader; current_shader = init->shader;
}
break; return true;
case SHADER_CTL_GET_FEEDBACK_PASS: }
bool video_shader_driver_get_feedback_pass(unsigned *data)
{
if (!current_shader || !current_shader->get_feedback_pass) if (!current_shader || !current_shader->get_feedback_pass)
return false; return false;
if (!current_shader->get_feedback_pass(shader_data, if (!current_shader->get_feedback_pass(shader_data, data))
(unsigned*)data))
return false; return false;
break; return true;
case SHADER_CTL_MIPMAP_INPUT: }
bool video_shader_driver_mipmap_input(unsigned *index)
{
if (!current_shader) if (!current_shader)
return false; return false;
{
unsigned *index = (unsigned*)data;
if (!current_shader->mipmap_input(shader_data, *index)) if (!current_shader->mipmap_input(shader_data, *index))
return false; return false;
} return true;
break; }
case SHADER_CTL_SET_COORDS:
{ bool video_shader_driver_set_coords(video_shader_ctx_coords_t *coords)
video_shader_ctx_coords_t *coords = (video_shader_ctx_coords_t*) {
data;
if (!current_shader || !current_shader->set_coords) if (!current_shader || !current_shader->set_coords)
return false; return false;
if (!current_shader->set_coords(coords->handle_data, if (!current_shader->set_coords(coords->handle_data,
shader_data, (const struct gfx_coords*)coords->data)) shader_data, (const struct gfx_coords*)coords->data))
return false; return false;
} return true;
break; }
case SHADER_CTL_SCALE:
{ bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler)
video_shader_ctx_scale_t *scaler = (video_shader_ctx_scale_t*)data; {
if (!scaler || !scaler->scale) if (!scaler || !scaler->scale)
return false; return false;
@ -240,70 +238,61 @@ bool video_shader_driver_ctl(enum video_shader_driver_ctl_state state, void *dat
return false; return false;
current_shader->shader_scale(shader_data, scaler->idx, scaler->scale); current_shader->shader_scale(shader_data, scaler->idx, scaler->scale);
} return true;
break; }
case SHADER_CTL_INFO:
{ bool video_shader_driver_info(video_shader_ctx_info_t *shader_info)
video_shader_ctx_info_t *shader_info = {
(video_shader_ctx_info_t*)data;
if (!shader_info || !current_shader) if (!shader_info || !current_shader)
return false; return false;
shader_info->num = 0; shader_info->num = 0;
if (current_shader->num_shaders) if (current_shader->num_shaders)
shader_info->num = current_shader->num_shaders(shader_data); shader_info->num = current_shader->num_shaders(shader_data);
} return true;
break; }
case SHADER_CTL_SET_MVP:
{ bool video_shader_driver_set_mvp(video_shader_ctx_mvp_t *mvp)
video_shader_ctx_mvp_t *mvp = (video_shader_ctx_mvp_t*)data; {
if (!current_shader || !current_shader->set_mvp) if (!current_shader || !current_shader->set_mvp)
return false; return false;
if (!mvp || !mvp->matrix) if (!mvp || !mvp->matrix)
return false; return false;
if (!current_shader->set_mvp(mvp->data, shader_data, mvp->matrix)) if (!current_shader->set_mvp(mvp->data, shader_data, mvp->matrix))
return false; return false;
} return true;
break; }
case SHADER_CTL_FILTER_TYPE:
{ bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter)
video_shader_ctx_filter_t *filter = {
(video_shader_ctx_filter_t*)data;
if (!current_shader || !current_shader->filter_type || !filter) if (!current_shader || !current_shader->filter_type || !filter)
return false; return false;
if (!current_shader->filter_type(shader_data, if (!current_shader->filter_type(shader_data,
filter->index, filter->smooth)) filter->index, filter->smooth))
return false; return false;
} return true;
break; }
case SHADER_CTL_COMPILE_PROGRAM:
{ bool video_shader_driver_compile_program(struct shader_program_info *program_info)
struct shader_program_info *program_info = (struct shader_program_info*)data; {
if (!current_shader || !program_info) if (!current_shader || !program_info)
return false; return false;
return current_shader->compile_program(program_info->data, return current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info); program_info->idx, NULL, program_info);
} }
case SHADER_CTL_USE:
{ bool video_shader_driver_use(video_shader_ctx_info_t *shader_info)
video_shader_ctx_info_t *shader_info = (video_shader_ctx_info_t*)data; {
if (!current_shader || !shader_info) if (!current_shader || !shader_info)
return false; return false;
current_shader->use(shader_info->data, shader_data, shader_info->idx, shader_info->set_active); current_shader->use(shader_info->data, shader_data, shader_info->idx, shader_info->set_active);
} return true;
break; }
case SHADER_CTL_WRAP_TYPE:
{ bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
video_shader_ctx_wrap_t *wrap = (video_shader_ctx_wrap_t*)data; {
if (!current_shader || !current_shader->wrap_type) if (!current_shader || !current_shader->wrap_type)
return false; return false;
wrap->type = current_shader->wrap_type(shader_data, wrap->idx); wrap->type = current_shader->wrap_type(shader_data, wrap->idx);
}
break;
case SHADER_CTL_NONE:
default:
break;
}
return true; return true;
} }

65
gfx/video_shader_driver.h
View File

@ -55,31 +55,6 @@
extern "C" { extern "C" {
#endif #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 enum shader_uniform_type
{ {
UNIFORM_1F = 0, UNIFORM_1F = 0,
@ -283,13 +258,49 @@ typedef struct video_shader_ctx_texture
unsigned id; unsigned id;
} video_shader_ctx_texture_t; } 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 gl_glsl_backend;
extern const shader_backend_t hlsl_backend; extern const shader_backend_t hlsl_backend;
extern const shader_backend_t gl_cg_backend; extern const shader_backend_t gl_cg_backend;
extern const shader_backend_t shader_null_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 #ifdef __cplusplus
} }
#endif #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); strlcpy(s2, path, len2);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_HLSL) #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) if (!shader_info.data)
return; 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; video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL; 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]; param = &shader_info.data->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0];
return generic_shader_action_parameter_left(shader_info.data, param, type, label, wraparound); 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; video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL; 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]; param = &shader_info.data->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0];
return generic_shader_action_parameter_right(shader_info.data, param, type, label, wraparound); 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; video_shader_ctx_t shader_info;
struct video_shader_parameter *param = NULL; 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) if (!shader_info.data)
return 0; 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.data = NULL;
shader_info.idx = dev->prog; shader_info.idx = dev->prog;
shader_info.set_active = false; 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) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]); 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.data = NULL;
shader_info.idx = (GLint)last_prog; shader_info.idx = (GLint)last_prog;
shader_info.set_active = false; 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) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
glBindTexture(GL_TEXTURE_2D, (GLuint)last_tex); 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); 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) 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.idx = draw->pipeline.id;
shader_info.set_active = true; shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info); video_shader_driver_use(&shader_info);
t += 0.01; t += 0.01;
@ -214,7 +214,7 @@ static void menu_display_d3d_draw_pipeline(void *data)
uniform_param.lookup.ident = "time"; uniform_param.lookup.ident = "time";
uniform_param.result.f.v0 = t; uniform_param.result.f.v0 = t;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMETER, &uniform_param); video_shader_driver_set_parameter(&uniform_param);
break; break;
} }
#endif #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.idx = VIDEO_SHADER_STOCK_BLEND;
shader_info.set_active = true; 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) 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.handle_data = gl;
coords.data = draw->coords; coords.data = draw->coords;
video_shader_driver_ctl(SHADER_CTL_SET_COORDS, &coords); video_shader_driver_set_coords(&coords);
mvp.data = gl; mvp.data = gl;
mvp.matrix = draw->matrix_data ? (math_matrix_4x4*)draw->matrix_data mvp.matrix = draw->matrix_data ? (math_matrix_4x4*)draw->matrix_data
: (math_matrix_4x4*)menu_display_gl_get_default_mvp(); : (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( glDrawArrays(menu_display_prim_to_gl_enum(
draw->prim_type), 0, draw->coords->vertices); 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.idx = draw->pipeline.id;
shader_info.set_active = true; shader_info.set_active = true;
video_shader_driver_ctl(SHADER_CTL_USE, &shader_info); video_shader_driver_use(&shader_info);
t += 0.01; t += 0.01;
@ -188,7 +188,7 @@ static void menu_display_gl_draw_pipeline(void *data)
uniform_param.lookup.ident = "time"; uniform_param.lookup.ident = "time";
uniform_param.result.f.v0 = t; uniform_param.result.f.v0 = t;
video_shader_driver_ctl(SHADER_CTL_SET_PARAMETER, &uniform_param); video_shader_driver_set_parameter(&uniform_param);
break; break;
} }
#endif #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:
case DISPLAYLIST_SHADER_PARAMETERS_PRESET: case DISPLAYLIST_SHADER_PARAMETERS_PRESET:
#ifdef HAVE_SHADER_MANAGER #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) if (shader_info.data)
ret = deferred_push_video_shader_parameters_common( 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; video_shader_ctx_t shader_info;
char val_buffer[32] = {0}; 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) if (floorf(shader_info.data->parameters[index].current)
== 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; int i;
video_shader_ctx_t shader_info; 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++) for (i = 0; i < GFX_MAX_PARAMETERS; i++)
{ {
@ -218,7 +218,7 @@ void shader_dlg_params_reload(void)
int i, pos_x, pos_y; int i, pos_x, pos_y;
video_shader_ctx_t shader_info; 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(); shader_dlg_params_clear();
@ -353,7 +353,7 @@ static LRESULT CALLBACK ShaderDlgWndProc(HWND hwnd, UINT message,
int i, pos; int i, pos;
video_shader_ctx_t shader_info; 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) switch (message)
{ {