unsigned menu_shader_manager_get_type(const struct gfx_shader *shader)
{
/* All shader types must be the same, or we cannot use it. */
unsigned i = 0, type = 0;
if (!shader)
{
RARCH_ERR("Cannot get shader type, shader handle is not initialized.\n");
return RARCH_SHADER_NONE;
}
for (i = 0; i < shader->passes; i++)
{
enum rarch_shader_type pass_type = gfx_shader_parse_type(shader->pass[i].source.path,
RARCH_SHADER_NONE);
switch (pass_type)
{
case RARCH_SHADER_CG:
case RARCH_SHADER_GLSL:
if (type == RARCH_SHADER_NONE)
type = pass_type;
else if (type != pass_type)
return RARCH_SHADER_NONE;
break;
default:
return RARCH_SHADER_NONE;
}
}
return type;
}
static bool d3d_init_shader(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
const gl_shader_backend_t *backend = NULL;
const char *shader_path = g_settings.video.shader_path;
enum rarch_shader_type type = gfx_shader_parse_type(shader_path, DEFAULT_SHADER_TYPE);
switch (type)
{
case RARCH_SHADER_HLSL:
#ifdef HAVE_HLSL
RARCH_LOG("[D3D]: Using HLSL shader backend.\n");
backend = &hlsl_backend;
#endif
break;
}
if (!backend)
{
RARCH_ERR("[GL]: Didn't find valid shader backend. Continuing without shaders.\n");
return true;
}
d3d->shader = backend;
return d3d->shader->init(d3d, shader_path);
}
static enum rarch_shader_type shader_manager_get_type(const struct gfx_shader *shader)
{
unsigned i;
// All shader types must be the same, or we cannot use it.
enum rarch_shader_type type = RARCH_SHADER_NONE;
for (i = 0; i < shader->passes; i++)
{
enum rarch_shader_type pass_type = gfx_shader_parse_type(shader->pass[i].source.cg,
RARCH_SHADER_NONE);
switch (pass_type)
{
case RARCH_SHADER_CG:
case RARCH_SHADER_GLSL:
if (type == RARCH_SHADER_NONE)
type = pass_type;
else if (type != pass_type)
return RARCH_SHADER_NONE;
break;
default:
return RARCH_SHADER_NONE;
}
}
return type;
}
static int menu_action_ok(const char *menu_path,
const char *menu_label, unsigned menu_type)
{
const char *label = NULL;
const char *path = NULL;
unsigned type = 0;
rarch_setting_t *setting_data = (rarch_setting_t *)driver.menu->list_settings;
rarch_setting_t *setting = (rarch_setting_t*)
setting_data_find_setting(setting_data, menu_label);
(void)hack_shader_pass;
if (file_list_get_size(driver.menu->selection_buf) == 0)
return 0;
file_list_get_at_offset(driver.menu->selection_buf,
driver.menu->selection_ptr, &path, &label, &type);
#if 0
RARCH_LOG("menu label: %s\n", menu_label);
RARCH_LOG("type : %d\n", type == MENU_FILE_USE_DIRECTORY);
RARCH_LOG("type id : %d\n", type);
#endif
while (true)
{
switch (type)
{
case MENU_FILE_PLAYLIST_ENTRY:
rarch_playlist_load_content(g_defaults.history,
driver.menu->selection_ptr);
menu_flush_stack_type(driver.menu->menu_stack, MENU_SETTINGS);
return -1;
#ifdef HAVE_COMPRESSION
case MENU_FILE_IN_CARCHIVE:
#endif
case MENU_FILE_PLAIN:
if (!strcmp(menu_label, "detect_core_list"))
{
int ret = rarch_defer_core(g_extern.core_info,
menu_path, path, driver.menu->deferred_path,
sizeof(driver.menu->deferred_path));
if (ret == -1)
{
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_common_load_content();
return -1;
}
else if (ret == 0)
menu_entries_push(driver.menu->menu_stack,
g_settings.libretro_directory, "deferred_core_list",
0, driver.menu->selection_ptr);
}
else if ((setting && setting->type == ST_PATH))
{
menu_action_setting_set_current_string_path(setting, menu_path, path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
}
else if (!strcmp(menu_label, "disk_image_append"))
{
char image[PATH_MAX];
fill_pathname_join(image, menu_path, path, sizeof(image));
rarch_disk_control_append_image(image);
rarch_main_command(RARCH_CMD_RESUME);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
return -1;
}
else
{
if (type == MENU_FILE_IN_CARCHIVE)
{
fill_pathname_join_delim(g_extern.fullpath, menu_path, path,
'#',sizeof(g_extern.fullpath));
}
else
{
fill_pathname_join(g_extern.fullpath, menu_path, path,
sizeof(g_extern.fullpath));
}
menu_common_load_content();
rarch_main_command(RARCH_CMD_LOAD_CONTENT_PERSIST);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
driver.menu->msg_force = true;
return -1;
}
return 0;
case MENU_FILE_CONFIG:
{
char config[PATH_MAX];
fill_pathname_join(config, menu_path, path, sizeof(config));
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
driver.menu->msg_force = true;
if (rarch_replace_config(config))
{
menu_clear_navigation(driver.menu);
return -1;
}
}
return 0;
case MENU_FILE_FONT:
case MENU_FILE_OVERLAY:
case MENU_FILE_AUDIOFILTER:
case MENU_FILE_VIDEOFILTER:
menu_action_setting_set_current_string_path(setting, menu_path, path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
return 0;
case MENU_FILE_SHADER_PRESET:
#ifdef HAVE_SHADER_MANAGER
{
char shader_path[PATH_MAX];
fill_pathname_join(shader_path, menu_path, path, sizeof(shader_path));
menu_shader_manager_set_preset(driver.menu->shader,
gfx_shader_parse_type(shader_path, RARCH_SHADER_NONE),
shader_path);
menu_flush_stack_label(driver.menu->menu_stack, "Shader Options");
}
#endif
return 0;
case MENU_FILE_SHADER:
#ifdef HAVE_SHADER_MANAGER
fill_pathname_join(driver.menu->shader->pass[hack_shader_pass].source.path,
menu_path, path,
sizeof(driver.menu->shader->pass[hack_shader_pass].source.path));
/* This will reset any changed parameters. */
gfx_shader_resolve_parameters(NULL, driver.menu->shader);
menu_flush_stack_label(driver.menu->menu_stack, "Shader Options");
#endif
return 0;
case MENU_FILE_CORE:
if (!strcmp(menu_label, "deferred_core_list"))
{
strlcpy(g_settings.libretro, path, sizeof(g_settings.libretro));
strlcpy(g_extern.fullpath, driver.menu->deferred_path,
sizeof(g_extern.fullpath));
menu_common_load_content();
return -1;
}
else if (!strcmp(menu_label, "core_list"))
{
fill_pathname_join(g_settings.libretro, menu_path, path,
sizeof(g_settings.libretro));
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
#if defined(HAVE_DYNAMIC)
/* No content needed for this core, load core immediately. */
if (driver.menu->load_no_content)
{
*g_extern.fullpath = '\0';
menu_common_load_content();
return -1;
}
/* Core selection on non-console just updates directory listing.
* Will take effect on new content load. */
#elif defined(RARCH_CONSOLE)
rarch_main_command(RARCH_CMD_RESTART_RETROARCH);
return -1;
#endif
}
return 0;
case MENU_FILE_USE_DIRECTORY:
if (setting && setting->type == ST_DIR)
{
menu_action_setting_set_current_string(setting, menu_path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
}
return 0;
case MENU_FILE_DIRECTORY:
case MENU_FILE_CARCHIVE:
{
char cat_path[PATH_MAX];
if (type == MENU_FILE_CARCHIVE && !strcmp(menu_label, "detect_core_list"))
{
file_list_push(driver.menu->menu_stack, path, "load_open_zip",
0, driver.menu->selection_ptr);
return 0;
}
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_entries_push(driver.menu->menu_stack,
cat_path, menu_label, type, driver.menu->selection_ptr);
}
return 0;
}
break;
}
if (menu_parse_check(label, type) == 0)
{
char cat_path[PATH_MAX];
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_entries_push(driver.menu->menu_stack,
cat_path, menu_label, type, driver.menu->selection_ptr);
}
return 0;
}
int menu_set_settings(unsigned setting, unsigned action)
{
unsigned port = rgui->current_pad;
switch (setting)
{
case RGUI_START_SCREEN:
if (action == RGUI_ACTION_OK)
rgui_list_push(rgui->menu_stack, "", RGUI_START_SCREEN, 0);
break;
case RGUI_SETTINGS_REWIND_ENABLE:
if (action == RGUI_ACTION_OK ||
action == RGUI_ACTION_LEFT ||
action == RGUI_ACTION_RIGHT)
{
settings_set(1ULL << S_REWIND);
if (g_settings.rewind_enable)
rarch_init_rewind();
else
rarch_deinit_rewind();
}
else if (action == RGUI_ACTION_START)
{
g_settings.rewind_enable = false;
rarch_deinit_rewind();
}
break;
#ifdef HAVE_SCREENSHOTS
case RGUI_SETTINGS_GPU_SCREENSHOT:
if (action == RGUI_ACTION_OK ||
action == RGUI_ACTION_LEFT ||
action == RGUI_ACTION_RIGHT)
g_settings.video.gpu_screenshot = !g_settings.video.gpu_screenshot;
else if (action == RGUI_ACTION_START)
g_settings.video.gpu_screenshot = true;
break;
#endif
case RGUI_SETTINGS_REWIND_GRANULARITY:
if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT)
settings_set(1ULL << S_REWIND_GRANULARITY_INCREMENT);
else if (action == RGUI_ACTION_LEFT)
settings_set(1ULL << S_REWIND_GRANULARITY_DECREMENT);
else if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_REWIND_GRANULARITY);
break;
case RGUI_SETTINGS_CONFIG_SAVE_ON_EXIT:
if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT
|| action == RGUI_ACTION_LEFT)
{
g_extern.config_save_on_exit = !g_extern.config_save_on_exit;
}
else if (action == RGUI_ACTION_START)
g_extern.config_save_on_exit = true;
break;
#if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE)
case RGUI_SETTINGS_SRAM_AUTOSAVE:
if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_LEFT)
{
rarch_deinit_autosave();
g_settings.autosave_interval = (!g_settings.autosave_interval) * 10;
if (g_settings.autosave_interval)
rarch_init_autosave();
}
else if (action == RGUI_ACTION_START)
{
rarch_deinit_autosave();
g_settings.autosave_interval = 0;
}
break;
#endif
case RGUI_SETTINGS_SAVESTATE_SAVE:
case RGUI_SETTINGS_SAVESTATE_LOAD:
if (action == RGUI_ACTION_OK)
{
if (setting == RGUI_SETTINGS_SAVESTATE_SAVE)
rarch_save_state();
else
rarch_load_state();
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
return -1;
}
else if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_SAVE_STATE);
else if (action == RGUI_ACTION_LEFT)
settings_set(1ULL << S_SAVESTATE_DECREMENT);
else if (action == RGUI_ACTION_RIGHT)
settings_set(1ULL << S_SAVESTATE_INCREMENT);
break;
#ifdef HAVE_SCREENSHOTS
case RGUI_SETTINGS_SCREENSHOT:
if (action == RGUI_ACTION_OK)
rarch_take_screenshot();
break;
#endif
case RGUI_SETTINGS_RESTART_GAME:
if (action == RGUI_ACTION_OK)
{
rarch_game_reset();
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
return -1;
}
break;
case RGUI_SETTINGS_AUDIO_MUTE:
if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_AUDIO_MUTE);
else
settings_set(1ULL << S_AUDIO_MUTE);
break;
case RGUI_SETTINGS_AUDIO_CONTROL_RATE_DELTA:
if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_AUDIO_CONTROL_RATE);
else if (action == RGUI_ACTION_LEFT)
settings_set(1ULL << S_AUDIO_CONTROL_RATE_DECREMENT);
else if (action == RGUI_ACTION_RIGHT)
settings_set(1ULL << S_AUDIO_CONTROL_RATE_INCREMENT);
break;
case RGUI_SETTINGS_DEBUG_TEXT:
if (action == RGUI_ACTION_START)
g_settings.fps_show = false;
else if (action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT)
g_settings.fps_show = !g_settings.fps_show;
break;
case RGUI_SETTINGS_DISK_INDEX:
{
const struct retro_disk_control_callback *control = &g_extern.system.disk_control;
unsigned num_disks = control->get_num_images();
unsigned current = control->get_image_index();
int step = 0;
if (action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_OK)
step = 1;
else if (action == RGUI_ACTION_LEFT)
step = -1;
if (step)
{
unsigned next_index = (current + num_disks + 1 + step) % (num_disks + 1);
rarch_disk_control_set_eject(true, false);
rarch_disk_control_set_index(next_index);
rarch_disk_control_set_eject(false, false);
}
break;
}
case RGUI_SETTINGS_RESTART_EMULATOR:
if (action == RGUI_ACTION_OK)
{
#if defined(GEKKO) && defined(HW_RVL)
fill_pathname_join(g_extern.fullpath, default_paths.core_dir, SALAMANDER_FILE,
sizeof(g_extern.fullpath));
#endif
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXITSPAWN);
return -1;
}
break;
case RGUI_SETTINGS_RESUME_GAME:
if (action == RGUI_ACTION_OK)
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
return -1;
}
break;
case RGUI_SETTINGS_QUIT_RARCH:
if (action == RGUI_ACTION_OK)
{
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
return -1;
}
break;
case RGUI_SETTINGS_SAVE_CONFIG:
if (action == RGUI_ACTION_OK)
menu_save_new_config();
break;
#ifdef HAVE_OVERLAY
case RGUI_SETTINGS_OVERLAY_PRESET:
switch (action)
{
case RGUI_ACTION_OK:
rgui_list_push(rgui->menu_stack, g_extern.overlay_dir, setting, rgui->selection_ptr);
rgui->selection_ptr = 0;
rgui->need_refresh = true;
break;
#ifndef __QNX__ // FIXME: Why ifndef QNX?
case RGUI_ACTION_START:
if (driver.overlay)
input_overlay_free(driver.overlay);
driver.overlay = NULL;
*g_settings.input.overlay = '\0';
break;
#endif
default:
break;
}
break;
case RGUI_SETTINGS_OVERLAY_OPACITY:
{
bool changed = true;
switch (action)
{
case RGUI_ACTION_LEFT:
settings_set(1ULL << S_INPUT_OVERLAY_OPACITY_DECREMENT);
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
settings_set(1ULL << S_INPUT_OVERLAY_OPACITY_INCREMENT);
break;
case RGUI_ACTION_START:
settings_set(1ULL << S_DEF_INPUT_OVERLAY_OPACITY);
break;
default:
changed = false;
break;
}
if (changed && driver.overlay)
input_overlay_set_alpha_mod(driver.overlay,
g_settings.input.overlay_opacity);
break;
}
case RGUI_SETTINGS_OVERLAY_SCALE:
{
bool changed = true;
switch (action)
{
case RGUI_ACTION_LEFT:
settings_set(1ULL << S_INPUT_OVERLAY_SCALE_DECREMENT);
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
settings_set(1ULL << S_INPUT_OVERLAY_SCALE_INCREMENT);
break;
case RGUI_ACTION_START:
settings_set(1ULL << S_DEF_INPUT_OVERLAY_SCALE);
break;
default:
changed = false;
break;
}
if (changed && driver.overlay)
input_overlay_set_scale_factor(driver.overlay,
g_settings.input.overlay_scale);
break;
}
#endif
// controllers
case RGUI_SETTINGS_BIND_PLAYER:
if (action == RGUI_ACTION_START)
rgui->current_pad = 0;
else if (action == RGUI_ACTION_LEFT)
{
if (rgui->current_pad != 0)
rgui->current_pad--;
}
else if (action == RGUI_ACTION_RIGHT)
{
if (rgui->current_pad < MAX_PLAYERS - 1)
rgui->current_pad++;
}
#ifdef HAVE_RGUI
if (port != rgui->current_pad)
rgui->need_refresh = true;
#endif
port = rgui->current_pad;
break;
case RGUI_SETTINGS_BIND_DEVICE:
// If set_keybinds is supported, we do it more fancy, and scroll through
// a list of supported devices directly.
if (driver.input->set_keybinds)
{
g_settings.input.device[port] += DEVICE_LAST;
if (action == RGUI_ACTION_START)
g_settings.input.device[port] = 0;
else if (action == RGUI_ACTION_LEFT)
g_settings.input.device[port]--;
else if (action == RGUI_ACTION_RIGHT)
g_settings.input.device[port]++;
// DEVICE_LAST can be 0, avoid modulo.
if (g_settings.input.device[port] >= DEVICE_LAST)
g_settings.input.device[port] -= DEVICE_LAST;
unsigned keybind_action = (1ULL << KEYBINDS_ACTION_SET_DEFAULT_BINDS);
driver.input->set_keybinds(driver.input_data, g_settings.input.device[port], port, 0,
keybind_action);
}
else
{
// When only straight g_settings.input.joypad_map[] style
// mapping is supported.
int *p = &g_settings.input.joypad_map[port];
if (action == RGUI_ACTION_START)
*p = port;
else if (action == RGUI_ACTION_LEFT)
(*p)--;
else if (action == RGUI_ACTION_RIGHT)
(*p)++;
if (*p < -1)
*p = -1;
else if (*p >= MAX_PLAYERS)
*p = MAX_PLAYERS - 1;
}
break;
case RGUI_SETTINGS_BIND_DEVICE_TYPE:
{
static const unsigned device_types[] = {
RETRO_DEVICE_NONE,
RETRO_DEVICE_JOYPAD,
RETRO_DEVICE_ANALOG,
RETRO_DEVICE_MOUSE,
RETRO_DEVICE_JOYPAD_MULTITAP,
RETRO_DEVICE_LIGHTGUN_SUPER_SCOPE,
RETRO_DEVICE_LIGHTGUN_JUSTIFIER,
RETRO_DEVICE_LIGHTGUN_JUSTIFIERS,
};
unsigned current_device, current_index, i;
current_device = g_settings.input.libretro_device[port];
current_index = 0;
for (i = 0; i < ARRAY_SIZE(device_types); i++)
{
if (current_device == device_types[i])
{
current_index = i;
break;
}
}
bool updated = true;
switch (action)
{
case RGUI_ACTION_START:
current_device = RETRO_DEVICE_JOYPAD;
break;
case RGUI_ACTION_LEFT:
current_device = device_types[(current_index + ARRAY_SIZE(device_types) - 1) % ARRAY_SIZE(device_types)];
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
current_device = device_types[(current_index + 1) % ARRAY_SIZE(device_types)];
break;
default:
updated = false;
}
if (updated)
{
g_settings.input.libretro_device[port] = current_device;
pretro_set_controller_port_device(port, current_device);
}
break;
}
case RGUI_SETTINGS_CUSTOM_BIND_ALL:
if (action == RGUI_ACTION_OK)
{
rgui->binds.target = &g_settings.input.binds[port][0];
rgui->binds.begin = RGUI_SETTINGS_BIND_BEGIN;
rgui->binds.last = RGUI_SETTINGS_BIND_LAST;
rgui_list_push(rgui->menu_stack, "", RGUI_SETTINGS_CUSTOM_BIND, rgui->selection_ptr);
menu_poll_bind_get_rested_axes(&rgui->binds);
menu_poll_bind_state(&rgui->binds);
}
break;
case RGUI_SETTINGS_CUSTOM_BIND_DEFAULT_ALL:
if (action == RGUI_ACTION_OK)
{
unsigned i;
struct retro_keybind *target = &g_settings.input.binds[port][0];
rgui->binds.begin = RGUI_SETTINGS_BIND_BEGIN;
rgui->binds.last = RGUI_SETTINGS_BIND_LAST;
for (i = RGUI_SETTINGS_BIND_BEGIN; i <= RGUI_SETTINGS_BIND_LAST; i++, target++)
{
target->joykey = NO_BTN;
target->joyaxis = AXIS_NONE;
}
}
break;
case RGUI_SETTINGS_BIND_UP:
case RGUI_SETTINGS_BIND_DOWN:
case RGUI_SETTINGS_BIND_LEFT:
case RGUI_SETTINGS_BIND_RIGHT:
case RGUI_SETTINGS_BIND_A:
case RGUI_SETTINGS_BIND_B:
case RGUI_SETTINGS_BIND_X:
case RGUI_SETTINGS_BIND_Y:
case RGUI_SETTINGS_BIND_START:
case RGUI_SETTINGS_BIND_SELECT:
case RGUI_SETTINGS_BIND_L:
case RGUI_SETTINGS_BIND_R:
case RGUI_SETTINGS_BIND_L2:
case RGUI_SETTINGS_BIND_R2:
case RGUI_SETTINGS_BIND_L3:
case RGUI_SETTINGS_BIND_R3:
case RGUI_SETTINGS_BIND_ANALOG_LEFT_X_PLUS:
case RGUI_SETTINGS_BIND_ANALOG_LEFT_X_MINUS:
case RGUI_SETTINGS_BIND_ANALOG_LEFT_Y_PLUS:
case RGUI_SETTINGS_BIND_ANALOG_LEFT_Y_MINUS:
case RGUI_SETTINGS_BIND_ANALOG_RIGHT_X_PLUS:
case RGUI_SETTINGS_BIND_ANALOG_RIGHT_X_MINUS:
case RGUI_SETTINGS_BIND_ANALOG_RIGHT_Y_PLUS:
case RGUI_SETTINGS_BIND_ANALOG_RIGHT_Y_MINUS:
case RGUI_SETTINGS_BIND_MENU_TOGGLE:
if (driver.input->set_keybinds)
{
unsigned keybind_action = KEYBINDS_ACTION_NONE;
if (action == RGUI_ACTION_START)
keybind_action = (1ULL << KEYBINDS_ACTION_SET_DEFAULT_BIND);
// FIXME: The array indices here look totally wrong ... Fixed it so it looks kind of sane for now.
if (keybind_action != KEYBINDS_ACTION_NONE)
driver.input->set_keybinds(driver.input_data, g_settings.input.device[port], port,
setting - RGUI_SETTINGS_BIND_BEGIN, keybind_action);
}
else
{
struct retro_keybind *bind = &g_settings.input.binds[port][setting - RGUI_SETTINGS_BIND_BEGIN];
if (action == RGUI_ACTION_OK)
{
rgui->binds.begin = setting;
rgui->binds.last = setting;
rgui->binds.target = bind;
rgui->binds.player = port;
rgui_list_push(rgui->menu_stack, "", RGUI_SETTINGS_CUSTOM_BIND, rgui->selection_ptr);
menu_poll_bind_get_rested_axes(&rgui->binds);
menu_poll_bind_state(&rgui->binds);
}
else if (action == RGUI_ACTION_START)
{
bind->joykey = NO_BTN;
bind->joyaxis = AXIS_NONE;
}
}
break;
case RGUI_BROWSER_DIR_PATH:
if (action == RGUI_ACTION_START)
{
*g_settings.rgui_browser_directory = '\0';
*rgui->base_path = '\0';
}
break;
#ifdef HAVE_SCREENSHOTS
case RGUI_SCREENSHOT_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_settings.screenshot_directory = '\0';
break;
#endif
case RGUI_SAVEFILE_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_extern.savefile_dir = '\0';
break;
#ifdef HAVE_OVERLAY
case RGUI_OVERLAY_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_extern.overlay_dir = '\0';
break;
#endif
case RGUI_SAVESTATE_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_extern.savestate_dir = '\0';
break;
#ifdef HAVE_DYNAMIC
case RGUI_LIBRETRO_DIR_PATH:
if (action == RGUI_ACTION_START)
{
*rgui->libretro_dir = '\0';
menu_init_core_info(rgui);
}
break;
#endif
case RGUI_LIBRETRO_INFO_DIR_PATH:
if (action == RGUI_ACTION_START)
{
*g_settings.libretro_info_path = '\0';
menu_init_core_info(rgui);
}
break;
case RGUI_CONFIG_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_settings.rgui_config_directory = '\0';
break;
case RGUI_SHADER_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_settings.video.shader_dir = '\0';
break;
case RGUI_SYSTEM_DIR_PATH:
if (action == RGUI_ACTION_START)
*g_settings.system_directory = '\0';
break;
case RGUI_SETTINGS_VIDEO_ROTATION:
if (action == RGUI_ACTION_START)
{
settings_set(1ULL << S_DEF_ROTATION);
video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4);
}
else if (action == RGUI_ACTION_LEFT)
{
settings_set(1ULL << S_ROTATION_DECREMENT);
video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4);
}
else if (action == RGUI_ACTION_RIGHT)
{
settings_set(1ULL << S_ROTATION_INCREMENT);
video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4);
}
break;
case RGUI_SETTINGS_VIDEO_FILTER:
if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_HW_TEXTURE_FILTER);
else
settings_set(1ULL << S_HW_TEXTURE_FILTER);
if (driver.video_poke->set_filtering)
driver.video_poke->set_filtering(driver.video_data, 1, g_settings.video.smooth);
break;
case RGUI_SETTINGS_VIDEO_GAMMA:
if (action == RGUI_ACTION_START)
{
g_extern.console.screen.gamma_correction = 0;
if (driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
}
else if (action == RGUI_ACTION_LEFT)
{
if(g_extern.console.screen.gamma_correction > 0)
{
g_extern.console.screen.gamma_correction--;
if (driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
}
}
else if (action == RGUI_ACTION_RIGHT)
{
if(g_extern.console.screen.gamma_correction < MAX_GAMMA_SETTING)
{
g_extern.console.screen.gamma_correction++;
if (driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
}
}
break;
case RGUI_SETTINGS_VIDEO_INTEGER_SCALE:
if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_SCALE_INTEGER);
else if (action == RGUI_ACTION_LEFT ||
action == RGUI_ACTION_RIGHT ||
action == RGUI_ACTION_OK)
settings_set(1ULL << S_SCALE_INTEGER_TOGGLE);
if (driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
break;
case RGUI_SETTINGS_VIDEO_ASPECT_RATIO:
if (action == RGUI_ACTION_START)
settings_set(1ULL << S_DEF_ASPECT_RATIO);
else if (action == RGUI_ACTION_LEFT)
settings_set(1ULL << S_ASPECT_RATIO_DECREMENT);
else if (action == RGUI_ACTION_RIGHT)
settings_set(1ULL << S_ASPECT_RATIO_INCREMENT);
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
break;
case RGUI_SETTINGS_TOGGLE_FULLSCREEN:
if (action == RGUI_ACTION_OK)
rarch_set_fullscreen(!g_settings.video.fullscreen);
break;
#if defined(GEKKO)
case RGUI_SETTINGS_VIDEO_RESOLUTION:
if (action == RGUI_ACTION_LEFT)
{
if(rgui_current_gx_resolution > 0)
{
rgui_current_gx_resolution--;
gx_set_video_mode(rgui_gx_resolutions[rgui_current_gx_resolution][0], rgui_gx_resolutions[rgui_current_gx_resolution][1]);
}
}
else if (action == RGUI_ACTION_RIGHT)
{
if (rgui_current_gx_resolution < GX_RESOLUTIONS_LAST - 1)
{
#ifdef HW_RVL
if ((rgui_current_gx_resolution + 1) > GX_RESOLUTIONS_640_480)
if (CONF_GetVideo() != CONF_VIDEO_PAL)
return 0;
#endif
rgui_current_gx_resolution++;
gx_set_video_mode(rgui_gx_resolutions[rgui_current_gx_resolution][0],
rgui_gx_resolutions[rgui_current_gx_resolution][1]);
}
}
break;
#elif defined(__CELLOS_LV2__)
case RGUI_SETTINGS_VIDEO_RESOLUTION:
if (action == RGUI_ACTION_LEFT)
settings_set(1ULL << S_RESOLUTION_PREVIOUS);
else if (action == RGUI_ACTION_RIGHT)
settings_set(1ULL << S_RESOLUTION_NEXT);
else if (action == RGUI_ACTION_OK)
{
if (g_extern.console.screen.resolutions.list[g_extern.console.screen.resolutions.current.idx] == CELL_VIDEO_OUT_RESOLUTION_576)
{
if (g_extern.console.screen.pal_enable)
g_extern.lifecycle_mode_state |= (1ULL<< MODE_VIDEO_PAL_ENABLE);
}
else
{
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_PAL_ENABLE);
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_PAL_TEMPORAL_ENABLE);
}
driver.video->restart();
rgui_init_textures();
}
break;
#endif
#ifdef HW_RVL
case RGUI_SETTINGS_VIDEO_SOFT_FILTER:
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE))
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE);
else
g_extern.lifecycle_mode_state |= (1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE);
if (driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
break;
#endif
case RGUI_SETTINGS_VIDEO_VSYNC:
switch (action)
{
case RGUI_ACTION_START:
settings_set(1ULL << S_DEF_VIDEO_VSYNC);
break;
case RGUI_ACTION_LEFT:
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
settings_set(1ULL << S_VIDEO_VSYNC_TOGGLE);
break;
default:
break;
}
break;
case RGUI_SETTINGS_VIDEO_HARD_SYNC:
switch (action)
{
case RGUI_ACTION_START:
g_settings.video.hard_sync = false;
break;
case RGUI_ACTION_LEFT:
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
g_settings.video.hard_sync = !g_settings.video.hard_sync;
break;
default:
break;
}
break;
case RGUI_SETTINGS_VIDEO_BLACK_FRAME_INSERTION:
switch (action)
{
case RGUI_ACTION_START:
g_settings.video.black_frame_insertion = false;
break;
case RGUI_ACTION_LEFT:
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
g_settings.video.black_frame_insertion = !g_settings.video.black_frame_insertion;
break;
default:
break;
}
break;
case RGUI_SETTINGS_VIDEO_CROP_OVERSCAN:
switch (action)
{
case RGUI_ACTION_START:
g_settings.video.crop_overscan = true;
break;
case RGUI_ACTION_LEFT:
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
g_settings.video.crop_overscan = !g_settings.video.crop_overscan;
break;
default:
break;
}
break;
case RGUI_SETTINGS_VIDEO_WINDOW_SCALE_X:
case RGUI_SETTINGS_VIDEO_WINDOW_SCALE_Y:
{
float *scale = setting == RGUI_SETTINGS_VIDEO_WINDOW_SCALE_X ? &g_settings.video.xscale : &g_settings.video.yscale;
float old_scale = *scale;
switch (action)
{
case RGUI_ACTION_START:
*scale = 3.0f;
break;
case RGUI_ACTION_LEFT:
*scale -= 1.0f;
break;
case RGUI_ACTION_RIGHT:
*scale += 1.0f;
break;
default:
break;
}
*scale = roundf(*scale);
*scale = max(*scale, 1.0f);
if (old_scale != *scale && !g_settings.video.fullscreen)
rarch_set_fullscreen(g_settings.video.fullscreen); // Reinit video driver.
break;
}
#ifdef HAVE_THREADS
case RGUI_SETTINGS_VIDEO_THREADED:
{
bool old = g_settings.video.threaded;
if (action == RGUI_ACTION_OK ||
action == RGUI_ACTION_LEFT ||
action == RGUI_ACTION_RIGHT)
g_settings.video.threaded = !g_settings.video.threaded;
else if (action == RGUI_ACTION_START)
g_settings.video.threaded = false;
if (g_settings.video.threaded != old)
rarch_set_fullscreen(g_settings.video.fullscreen); // Reinit video driver.
break;
}
#endif
case RGUI_SETTINGS_VIDEO_SWAP_INTERVAL:
{
unsigned old = g_settings.video.swap_interval;
switch (action)
{
case RGUI_ACTION_START:
g_settings.video.swap_interval = 1;
break;
case RGUI_ACTION_LEFT:
g_settings.video.swap_interval--;
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
g_settings.video.swap_interval++;
break;
default:
break;
}
g_settings.video.swap_interval = min(g_settings.video.swap_interval, 4);
g_settings.video.swap_interval = max(g_settings.video.swap_interval, 1);
if (old != g_settings.video.swap_interval && driver.video && driver.video_data)
video_set_nonblock_state_func(false); // This will update the current swap interval. Since we're in RGUI now, always apply VSync.
break;
}
case RGUI_SETTINGS_VIDEO_HARD_SYNC_FRAMES:
switch (action)
{
case RGUI_ACTION_START:
g_settings.video.hard_sync_frames = 0;
break;
case RGUI_ACTION_LEFT:
if (g_settings.video.hard_sync_frames > 0)
g_settings.video.hard_sync_frames--;
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
if (g_settings.video.hard_sync_frames < 3)
g_settings.video.hard_sync_frames++;
break;
default:
break;
}
break;
case RGUI_SETTINGS_VIDEO_REFRESH_RATE_AUTO:
switch (action)
{
case RGUI_ACTION_START:
g_extern.measure_data.frame_time_samples_count = 0;
break;
case RGUI_ACTION_OK:
{
double refresh_rate = 0.0;
double deviation = 0.0;
unsigned sample_points = 0;
if (driver_monitor_fps_statistics(&refresh_rate, &deviation, &sample_points))
{
driver_set_monitor_refresh_rate(refresh_rate);
// Incase refresh rate update forced non-block video.
video_set_nonblock_state_func(false);
}
break;
}
default:
break;
}
break;
#ifdef HAVE_SHADER_MANAGER
case RGUI_SETTINGS_SHADER_PASSES:
switch (action)
{
case RGUI_ACTION_START:
rgui->shader.passes = 0;
break;
case RGUI_ACTION_LEFT:
if (rgui->shader.passes)
rgui->shader.passes--;
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
if (rgui->shader.passes < RGUI_MAX_SHADERS)
rgui->shader.passes++;
break;
default:
break;
}
#ifndef HAVE_RMENU
rgui->need_refresh = true;
#endif
break;
case RGUI_SETTINGS_SHADER_APPLY:
{
if (!driver.video->set_shader || action != RGUI_ACTION_OK)
return 0;
RARCH_LOG("Applying shader ...\n");
enum rarch_shader_type type = shader_manager_get_type(&rgui->shader);
if (rgui->shader.passes && type != RARCH_SHADER_NONE)
{
const char *conf_path = type == RARCH_SHADER_GLSL ? rgui->default_glslp : rgui->default_cgp;
char config_directory[PATH_MAX];
if (*g_extern.config_path)
fill_pathname_basedir(config_directory, g_extern.config_path, sizeof(config_directory));
else
*config_directory = '\0';
char cgp_path[PATH_MAX];
const char *dirs[] = {
g_settings.video.shader_dir,
g_settings.rgui_config_directory,
config_directory,
};
config_file_t *conf = config_file_new(NULL);
if (!conf)
return 0;
gfx_shader_write_conf_cgp(conf, &rgui->shader);
bool ret = false;
unsigned d;
for (d = 0; d < ARRAY_SIZE(dirs); d++)
{
if (!*dirs[d])
continue;
fill_pathname_join(cgp_path, dirs[d], conf_path, sizeof(cgp_path));
if (config_file_write(conf, cgp_path))
{
RARCH_LOG("Saved shader preset to %s.\n", cgp_path);
shader_manager_set_preset(NULL, type, cgp_path);
ret = true;
break;
}
else
RARCH_LOG("Failed writing shader preset to %s.\n", cgp_path);
}
config_file_free(conf);
if (!ret)
RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n");
}
else
{
type = gfx_shader_parse_type("", DEFAULT_SHADER_TYPE);
if (type == RARCH_SHADER_NONE)
{
#if defined(HAVE_GLSL)
type = RARCH_SHADER_GLSL;
#elif defined(HAVE_CG) || defined(HAVE_HLSL)
type = RARCH_SHADER_CG;
#endif
}
shader_manager_set_preset(NULL, type, NULL);
}
}
break;
#endif
default:
break;
}
return 0;
}
