mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-29 13:20:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Expand functionality of set_shader callback function

Browse Source
This commit is contained in:
twinaphex 2013-01-07 16:46:26 +01:00
parent fa8ccf412c
commit 3a5d056b95
11 changed files with 174 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
360/frontend-xdk/menu.cpp
View File

@ -859,6 +859,15 @@ HRESULT CRetroArchShaderBrowser::OnInit(XUIMessageInit * pInitData, BOOL& bHandl
return 0;
}
unsigned get_shader_type(void)
{
#if defined(HAVE_HLSL)
return RARCH_SHADER_HLSL;
#else
return RARCH_SHADER_NONE;
#endif
}
HRESULT CRetroArchShaderBrowser::OnNotifyPress( HXUIOBJ hObjPressed, BOOL& bHandled )
{
char path[PATH_MAX];
@ -869,16 +878,31 @@ HRESULT CRetroArchShaderBrowser::OnNotifyPress( HXUIOBJ hObjPressed, BOOL& bHand
if(path_file_exists(tmp_browser.current_dir.list->elems[index].data))
{
convert_wchar_to_char(str_buffer, (const wchar_t *)m_shaderlist.GetText(index), sizeof(str_buffer));
unsigned shader_type = get_shader_type();
switch(set_shader)
{
case 1:
snprintf(g_settings.video.cg_shader_path, sizeof(g_settings.video.cg_shader_path), "%s\\%s", filebrowser_get_current_dir(&tmp_browser), str_buffer);
rarch_load_shader(set_shader, g_settings.video.cg_shader_path);
if (shader_type != RARCH_SHADER_NONE)
{
device_ptr->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, g_settings.video.cg_shader_path, (1ULL << RARCH_SHADER_PASS0));
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
break;
case 2:
snprintf (g_settings.video.second_pass_shader, sizeof(g_settings.video.second_pass_shader), "%s\\%s", filebrowser_get_current_dir(&tmp_browser), str_buffer);
rarch_load_shader(set_shader, g_settings.video.second_pass_shader);
if (shader_type != RARCH_SHADER_NONE)
{
device_ptr->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, g_settings.video.second_pass_shader, (1ULL << RARCH_SHADER_PASS1));
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
break;
default:
break;

2
command.c
View File

@ -229,7 +229,7 @@ static bool cmd_set_shader(const char *arg)
msg_queue_push(g_extern.msg_queue, msg, 1, 120);
RARCH_LOG("Applying shader \"%s\".\n", arg);
return video_set_shader_func(type, arg);
return video_set_shader_func(type, arg, (1ULL << RARCH_SHADER_MULTIPASS));
}
static const struct cmd_action_map action_map[] = {

16
console/rarch_console_video.c
View File

@ -91,19 +91,3 @@ void rarch_set_core_viewport(void)
else
aspectratio_lut[ASPECT_RATIO_CORE].value = g_extern.system.av_info.geometry.aspect_ratio;
}
#if defined(HAVE_HLSL) || defined(HAVE_CG) || defined(HAVE_GLSL)
void rarch_load_shader(unsigned slot, const char *path)
{
#if defined(HAVE_HLSL)
hlsl_load_shader(slot, path);
#elif defined(HAVE_CG) && defined(HAVE_OPENGL)
gl_cg_load_shader(slot, path);
#else
RARCH_WARN("Shader support is not implemented for this build.\n");
#endif
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
#endif

1
console/rarch_console_video.h
View File

@ -103,6 +103,5 @@ extern struct aspect_ratio_elem aspectratio_lut[ASPECT_RATIO_END];
extern void rarch_set_auto_viewport(unsigned width, unsigned height);
extern void rarch_set_core_viewport(void);
extern void rarch_load_shader(unsigned slot, const char *path);
#endif

57
console/rmenu/rmenu.c
View File

@ -615,6 +615,19 @@ void browser_render(void *data)
}
}
unsigned get_shader_type(void)
{
#if defined(HAVE_GLSL)
return RARCH_SHADER_BSNES;
#elif defined(HAVE_CG)
return RARCH_SHADER_CG;
#elif defined(HAVE_HLSL)
return RARCH_SHADER_HLSL;
#else
return RARCH_SHADER_NONE;
#endif
}
int select_file(void *data, void *state)
{
menu *current_menu = (menu*)data;
@ -663,20 +676,42 @@ int select_file(void *data, void *state)
ret = filebrowser_iterate(filebrowser, FILEBROWSER_ACTION_OK);
else
{
unsigned shader_type = 0;
(void)shader_type;
snprintf(path, sizeof(path), filebrowser_get_current_path(filebrowser));
switch(current_menu->enum_id)
{
#if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL)
case SHADER_CHOICE:
rarch_load_shader(set_shader+1, path);
switch(set_shader+1)
{
case 1:
strlcpy(g_settings.video.cg_shader_path, path, sizeof(g_settings.video.cg_shader_path));
shader_type = get_shader_type();
if (shader_type != RARCH_SHADER_NONE)
{
driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, path, 1ULL << RARCH_SHADER_PASS0);
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
break;
case 2:
strlcpy(g_settings.video.second_pass_shader, path, sizeof(g_settings.video.second_pass_shader));
shader_type = get_shader_type();
if (shader_type != RARCH_SHADER_NONE)
{
driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, path, 1ULL << RARCH_SHADER_PASS1);
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
break;
}
break;
@ -1066,8 +1101,16 @@ static void set_setting_action(void *data, unsigned switchvalue, uint64_t input)
}
if(input & (1ULL << RMENU_DEVICE_NAV_START))
{
rarch_load_shader(1, NULL);
strlcpy(g_settings.video.cg_shader_path, default_paths.shader_file, sizeof(g_settings.video.cg_shader_path));
unsigned shader_type = get_shader_type();
if (shader_type != RARCH_SHADER_NONE)
{
driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, NULL, (1ULL << RARCH_SHADER_PASS0) | (1ULL << RARCH_SHADER_PASS0_STOCK));
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
}
break;
case SETTING_SHADER_2:
@ -1079,8 +1122,16 @@ static void set_setting_action(void *data, unsigned switchvalue, uint64_t input)
}
if(input & (1ULL << RMENU_DEVICE_NAV_START))
{
rarch_load_shader(2, NULL);
strlcpy(g_settings.video.second_pass_shader, default_paths.shader_file, sizeof(g_settings.video.second_pass_shader));
unsigned shader_type = get_shader_type();
if (shader_type != RARCH_SHADER_NONE)
{
driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, NULL, (1ULL << RARCH_SHADER_PASS1) | (1ULL << RARCH_SHADER_PASS1_STOCK));
if (g_extern.console.rmenu.state.msg_info.enable)
rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
}
else
RARCH_ERR("Shaders are unsupported on this platform.\n");
}
break;
#endif

12
driver.h
View File

@ -130,11 +130,21 @@ struct retro_keybind
enum rarch_shader_type
{
RARCH_SHADER_CG,
RARCH_SHADER_HLSL,
RARCH_SHADER_BSNES,
RARCH_SHADER_AUTO,
RARCH_SHADER_NONE
};
enum rarch_shader_mask
{
RARCH_SHADER_MULTIPASS = 1,
RARCH_SHADER_PASS0,
RARCH_SHADER_PASS0_STOCK,
RARCH_SHADER_PASS1,
RARCH_SHADER_PASS1_STOCK
};
typedef struct video_info
{
unsigned width;
@ -223,7 +233,7 @@ typedef struct video_driver
// Is the window still active?
bool (*alive)(void *data);
bool (*focus)(void *data); // Does the window have focus?
bool (*set_shader)(void *data, enum rarch_shader_type type, const char *path); // Sets shader. Might not be implemented.
bool (*set_shader)(void *data, enum rarch_shader_type type, const char *path, unsigned mask); // Sets shader. Might not be implemented.
void (*free)(void *data);
const char *ident;

4
driver_funcs.h
View File

@ -37,7 +37,7 @@
#define video_set_nonblock_state_func(state) driver.video->set_nonblock_state(driver.video_data, state)
#define video_alive_func() driver.video->alive(driver.video_data)
#define video_focus_func() driver.video->focus(driver.video_data)
#define video_set_shader_func(type, path) driver.video->set_shader(driver.video_data, type, path)
#define video_set_shader_func(type, path, mask) driver.video->set_shader(driver.video_data, type, path, mask)
#define video_set_rotation_func(rotate) driver.video->set_rotation(driver.video_data, rotate)
#define video_set_aspect_ratio_func(aspect_idx) driver.video->set_aspect_ratio(driver.video_data, aspect_idx)
#define video_viewport_info_func(info) driver.video->viewport_info(driver.video_data, info)
@ -147,7 +147,7 @@ static inline bool input_key_pressed_func(int key)
#define video_set_rotation_func(rotation) MAKENAME_VIDEO(_set_rotation)(driver.video_data, rotation)
#define video_stop_func() MAKENAME_VIDEO(_stop)()
#define video_start_func() MAKENAME_VIDEO(_start)()
#define video_set_shader_func(type, path) MAKENAME_VIDEO(_set_shader)(driver.video_data, type, path)
#define video_set_shader_func(type, path, mask) MAKENAME_VIDEO(_set_shader)(driver.video_data, type, path, mask)
#define video_xml_shader_func(path) driver.video->xml_shader(driver.video_data, path)
/*============================================================

58
gfx/gl.c
View File

@ -1709,30 +1709,59 @@ static bool gl_focus(void *data)
}
#if defined(HAVE_GLSL) || defined(HAVE_CG)
static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *path)
static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
{
gl_t *gl = (gl_t*)data;
if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
{
#ifdef HAVE_FBO
gl_deinit_fbo(gl);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
gl_deinit_fbo(gl);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
#endif
gl_shader_deinit(gl);
gl_shader_deinit(gl);
}
switch (type)
{
#ifdef HAVE_GLSL
case RARCH_SHADER_BSNES:
if (!gl_glsl_init(path))
return false;
if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
{
if (!gl_glsl_init(path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS0))
{
if (!gl_glsl_load_shader(1, (mask & (1ULL << RARCH_SHADER_PASS0_STOCK)) ? NULL : path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS1))
{
if (!gl_glsl_load_shader(2, (mask & (1ULL << RARCH_SHADER_PASS1_STOCK)) ? NULL : path))
return false;
}
break;
#endif
#ifdef HAVE_CG
case RARCH_SHADER_CG:
if (!gl_cg_init(path))
return false;
if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
{
if (!gl_cg_init(path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS0))
{
if (!gl_cg_load_shader(1, (mask & (1ULL << RARCH_SHADER_PASS0_STOCK)) ? NULL : path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS1))
{
if (!gl_cg_load_shader(2, (mask & (1ULL << RARCH_SHADER_PASS1_STOCK)) ? NULL : path))
return false;
}
break;
#endif
@ -1741,14 +1770,17 @@ static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *p
return false;
}
if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
{
#ifdef HAVE_FBO
// Set up render to texture again.
gl_init_fbo(gl, gl->tex_w, gl->tex_h);
// Set up render to texture again.
gl_init_fbo(gl, gl->tex_w, gl->tex_h);
#endif
// Apparently need to set viewport for passes when we aren't using FBOs.
gl_set_shader_viewport(gl, 0);
gl_set_shader_viewport(gl, 1);
// Apparently need to set viewport for passes when we aren't using FBOs.
gl_set_shader_viewport(gl, 0);
gl_set_shader_viewport(gl, 1);
}
return true;
}

5
gx/gx_video.c
View File

@ -999,11 +999,14 @@ static void gx_apply_state_changes(void)
gx->should_resize = true;
}
static bool gx_set_shader(void *data, enum rarch_shader_type type, const char *path)
static bool gx_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
{
(void)data;
(void)type;
(void)path;
(void)mask;
RARCH_WARN("Shader support is not implemented for GX.\n");
return false;
}

2
retroarch.c
View File

@ -2342,7 +2342,7 @@ static void check_shader_dir(void)
msg_queue_push(g_extern.msg_queue, msg, 1, 120);
RARCH_LOG("Applying shader \"%s\".\n", shader);
if (!video_set_shader_func(type, shader))
if (!video_set_shader_func(type, shader, (1ULL << RARCH_SHADER_MULTIPASS)))
RARCH_WARN("Failed to apply shader.\n");
}

32
xdk/xdk_d3d.cpp
View File

@ -327,13 +327,41 @@ void xdk_d3d_init_fbo(void *data)
}
#endif
static bool xdk_d3d_set_shader(void *data, enum rarch_shader_type type, const char *path)
static bool xdk_d3d_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
{
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)data;
(void)data;
(void)type;
(void)path;
return false;
switch (type)
{
#if defined(HAVE_HLSL)
case RARCH_SHADER_HLSL:
if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
{
if (!gl_hlsl_init(path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS0))
{
if (!gl_hlsl_load_shader(1, (mask & RARCH_SHADER_PASS0_STOCK) ? NULL : path))
return false;
}
else if (mask & (1ULL << RARCH_SHADER_PASS1))
{
if (!gl_hlsl_load_shader(2, (mask & RARCH_SHADER_PASS1_STOCK) ? NULL : path))
return false;
}
break;
#endif
default:
RARCH_ERR("Invalid shader type in gl_set_shader().\n");
return false;
}
return true;
}
void xdk_d3d_generate_pp(D3DPRESENT_PARAMETERS *d3dpp, const video_info_t *video)