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; }