static void draw_frame(bool enable)
{
if (driver.video_data && driver.video_poke &&
driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data,
enable, MENU_TEXTURE_FULLSCREEN);
if (!enable)
return;
if (driver.video)
rarch_render_cached_frame();
}
static void check_slowmotion(bool pressed)
{
g_extern.is_slowmotion = pressed;
if (!g_extern.is_slowmotion)
return;
if (g_settings.video.black_frame_insertion)
rarch_render_cached_frame();
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, g_extern.frame_is_reverse ?
"Slow motion rewind." : "Slow motion.", 0, 30);
}
void menu_loop(void)
{
g_console.menu_enable = true;
HRESULT hr;
xdk360_video_t *vid = (xdk360_video_t*)g_d3d;
if(g_console.emulator_initialized)
video_xdk360.set_swap_block_state(NULL, true);
do
{
g_frame_count++;
if(g_console.emulator_initialized)
{
rarch_render_cached_frame();
}
else
vid->d3d_render_device->Clear(0, NULL, D3DCLEAR_TARGET,
D3DCOLOR_ARGB(255, 32, 32, 64), 1.0f, 0);
XINPUT_STATE state;
XInputGetState(0, &state);
g_console.menu_enable = !((state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB)
&& (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) && (g_console.emulator_initialized)
&& IS_TIMER_EXPIRED());
g_console.mode_switch = g_console.menu_enable ? MODE_MENU : MODE_EMULATION;
app.RunFrame(); /* Update XUI */
hr = app.Render(); /* Render XUI */
hr = XuiTimersRun(); /* Update XUI timers */
if(g_console.mode_switch == MODE_EMULATION && !g_console.frame_advance_enable)
{
SET_TIMER_EXPIRATION(30);
}
video_xdk360.swap(NULL);
}while(g_console.menu_enable);
if(g_console.emulator_initialized)
video_xdk360.set_swap_block_state(NULL, false);
g_console.ingame_menu_enable = false;
}
void load_menu_game_prepare(void *data)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
if (*g_extern.fullpath || (rgui && rgui->load_no_rom))
{
if (*g_extern.fullpath)
{
char tmp[PATH_MAX];
char str[PATH_MAX];
fill_pathname_base(tmp, g_extern.fullpath, sizeof(tmp));
snprintf(str, sizeof(str), "INFO - Loading %s ...", tmp);
msg_queue_push(g_extern.msg_queue, str, 1, 1);
}
#ifdef RARCH_CONSOLE
if (g_extern.system.no_game || *g_extern.fullpath)
#endif
menu_rom_history_push(rgui, *g_extern.fullpath ? g_extern.fullpath : NULL,
g_settings.libretro,
rgui->info.library_name ? rgui->info.library_name : "");
}
#ifdef HAVE_MENU
// redraw RGUI frame
rgui->old_input_state = rgui->trigger_state = 0;
rgui->do_held = false;
rgui->msg_force = true;
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->iterate)
driver.menu_ctx->backend->iterate(rgui, RGUI_ACTION_NOOP);
#endif
// Draw frame for loading message
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, rgui->frame_buf_show, MENU_TEXTURE_FULLSCREEN);
if (driver.video)
rarch_render_cached_frame();
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, false,
MENU_TEXTURE_FULLSCREEN);
}
static void load_menu_content_prepare(void)
{
if (!driver.menu)
return;
if (*g_extern.fullpath || driver.menu->load_no_content)
{
if (*g_extern.fullpath)
{
char tmp[PATH_MAX];
char str[PATH_MAX];
fill_pathname_base(tmp, g_extern.fullpath, sizeof(tmp));
snprintf(str, sizeof(str), "INFO - Loading %s ...", tmp);
msg_queue_push(g_extern.msg_queue, str, 1, 1);
}
content_playlist_push(g_extern.history,
*g_extern.fullpath ? g_extern.fullpath : NULL,
g_settings.libretro,
driver.menu->info.library_name ? driver.menu->info.library_name : "");
}
/* redraw menu frame */
driver.menu->old_input_state = driver.menu->trigger_state = 0;
driver.menu->do_held = false;
driver.menu->msg_force = true;
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->iterate)
driver.menu_ctx->backend->iterate(MENU_ACTION_NOOP);
/* Draw frame for loading message */
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, driver.menu->frame_buf_show, MENU_TEXTURE_FULLSCREEN);
if (driver.video)
rarch_render_cached_frame();
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, false,
MENU_TEXTURE_FULLSCREEN);
}
static int do_pause_state_checks(
retro_input_t input, retro_input_t old_input,
retro_input_t trigger_input)
{
check_pause_func(trigger_input);
if (!g_extern.is_paused)
return 0;
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
{
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
rarch_render_cached_frame();
}
if (!check_oneshot_func(trigger_input))
return 1;
return 0;
}
static void system_process_args(int argc, char *argv[])
{
if (argc > 2 && argv[1] != NULL && argv[2] != NULL)
{
char rom[PATH_MAX];
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXTLAUNCH_CHANNEL);
snprintf(rom, sizeof(rom), "%s%s", argv[1], argv[2]);
strlcpy(g_extern.fullpath, rom, sizeof(g_extern.fullpath));
g_extern.lifecycle_mode_state |= (1ULL << MODE_LOAD_GAME);
rgui_iterate(rgui, RGUI_ACTION_MESSAGE);
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_DRAW);
rarch_render_cached_frame();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU_DRAW);
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
g_extern.lifecycle_mode_state |= (1ULL << MODE_INIT);
}
else
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXTLAUNCH_SALAMANDER);
}
/**
** menu_display_fb:
*
* Draws menu graphics onscreen.
**/
void menu_display_fb(void)
{
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
video_driver_set_texture_enable(true, false);
if (!settings->menu.pause_libretro)
{
if (global->main_is_init && !global->libretro_dummy)
{
bool block_libretro_input = driver->block_libretro_input;
driver->block_libretro_input = true;
pretro_run();
driver->block_libretro_input = block_libretro_input;
return;
}
}
rarch_render_cached_frame();
}
void load_menu_game_prepare(void)
{
if (*g_extern.fullpath || rgui->load_no_rom)
{
if (*g_extern.fullpath &&
g_extern.lifecycle_mode_state & (1ULL << MODE_INFO_DRAW))
{
char tmp[PATH_MAX];
char str[PATH_MAX];
fill_pathname_base(tmp, g_extern.fullpath, sizeof(tmp));
snprintf(str, sizeof(str), "INFO - Loading %s ...", tmp);
msg_queue_push(g_extern.msg_queue, str, 1, 1);
}
menu_rom_history_push(*g_extern.fullpath ? g_extern.fullpath : NULL,
g_settings.libretro,
rgui->info.library_name ? rgui->info.library_name : "");
}
#ifdef HAVE_RGUI
// redraw RGUI frame
rgui->old_input_state = rgui->trigger_state = 0;
rgui->do_held = false;
rgui->msg_force = true;
rgui_iterate(rgui);
#endif
// Draw frame for loading message
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, rgui->frame_buf_show, MENU_TEXTURE_FULLSCREEN);
if (driver.video)
rarch_render_cached_frame();
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, false,
MENU_TEXTURE_FULLSCREEN);
}
static bool sdl2_gfx_read_viewport(void *data, uint8_t *buffer)
{
sdl2_video_t *vid = (sdl2_video_t*)data;
RARCH_PERFORMANCE_INIT(sdl2_gfx_read_viewport);
RARCH_PERFORMANCE_START(sdl2_gfx_read_viewport);
rarch_render_cached_frame();
SDL_Surface *surf = SDL_GetWindowSurface(vid->window);
SDL_Surface *bgr24 = SDL_ConvertSurfaceFormat(surf, SDL_PIXELFORMAT_BGR24, 0);
if (!bgr24)
{
RARCH_WARN("Failed to convert viewport data to BGR24: %s", SDL_GetError());
return false;
}
memcpy(buffer, bgr24->pixels, bgr24->h * bgr24->pitch);
RARCH_PERFORMANCE_STOP(sdl2_gfx_read_viewport);
return true;
}
int main(int argc, char *argv[])
{
#ifdef HW_RVL
IOS_ReloadIOS(IOS_GetVersion());
L2Enhance();
gx_init_mem2();
#endif
fatInitDefault();
#ifdef HAVE_LOGGER
g_extern.verbose = true;
logger_init();
devoptab_list[STD_OUT] = &dotab_stdout;
devoptab_list[STD_ERR] = &dotab_stdout;
dotab_stdout.write_r = gx_logger_net;
#elif defined(HAVE_FILE_LOGGER)
g_extern.verbose = true;
log_fp = fopen("/retroarch-log.txt", "w");
devoptab_list[STD_OUT] = &dotab_stdout;
devoptab_list[STD_ERR] = &dotab_stdout;
dotab_stdout.write_r = gx_logger_file;
#endif
#ifdef HW_RVL
lwp_t gx_device_thread;
gx_devices[GX_DEVICE_SD].interface = &__io_wiisd;
gx_devices[GX_DEVICE_SD].name = "sd";
gx_devices[GX_DEVICE_SD].mounted = fatMountSimple(gx_devices[GX_DEVICE_SD].name, gx_devices[GX_DEVICE_SD].interface);
gx_devices[GX_DEVICE_USB].interface = &__io_usbstorage;
gx_devices[GX_DEVICE_USB].name = "usb";
gx_devices[GX_DEVICE_USB].mounted = fatMountSimple(gx_devices[GX_DEVICE_USB].name, gx_devices[GX_DEVICE_USB].interface);
LWP_MutexInit(&gx_device_mutex, false);
LWP_CreateThread(&gx_device_thread, gx_devthread, NULL, NULL, 0, 66);
#endif
get_environment_settings();
make_directories();
config_set_defaults();
input_gx.init();
video_gx.start();
driver.video = &video_gx;
gx_video_t *gx = (gx_video_t*)driver.video_data;
gx->menu_data = (uint32_t *) menu_framebuf;
char tmp_path[PATH_MAX];
const char *extension = default_paths.executable_extension;
snprintf(tmp_path, sizeof(tmp_path), "%s/", default_paths.core_dir);
const char *path_prefix = tmp_path;
char full_path[1024];
snprintf(full_path, sizeof(full_path), "%sCORE%s", path_prefix, extension);
bool find_libretro_file = rarch_configure_libretro_core(full_path, path_prefix, path_prefix,
default_paths.config_file, extension);
rarch_settings_set_default(&input_gx);
rarch_config_load(default_paths.config_file, path_prefix, extension, find_libretro_file);
char core_name[64];
rarch_console_name_from_id(core_name, sizeof(core_name));
char input_path[1024];
snprintf(input_path, sizeof(input_path), "%s/%s.cfg", default_paths.input_presets_dir, core_name);
config_read_keybinds(input_path);
init_libretro_sym();
input_gx.post_init();
menu_init();
if (argc > 2 && argv[1] != NULL && argv[2] != NULL)
{
char rom[PATH_MAX];
g_console.external_launcher_support = EXTERN_LAUNCHER_CHANNEL;
snprintf(rom, sizeof(rom), "%s%s", argv[1], argv[2]);
g_console.zip_extract_mode = ZIP_EXTRACT_TO_CURRENT_DIR_AND_LOAD_FIRST_FILE;
rarch_console_load_game_wrap(rom, g_console.zip_extract_mode, S_DELAY_1);
rgui_iterate(rgui, RGUI_ACTION_MESSAGE);
gx->menu_render = true;
rarch_render_cached_frame();
gx->menu_render = false;
rarch_startup(default_paths.config_file);
}
else
{
g_console.external_launcher_support = EXTERN_LAUNCHER_SALAMANDER;
}
begin_loop:
if(g_console.mode_switch == MODE_EMULATION)
{
bool repeat = false;
input_gx.poll(NULL);
video_set_aspect_ratio_func(g_console.aspect_ratio_index);
audio_start_func();
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
audio_stop_func();
}
else if(g_console.mode_switch == MODE_MENU)
{
menu_loop();
if (g_console.mode_switch != MODE_EXIT)
rarch_startup(default_paths.config_file);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
rarch_config_save(default_paths.config_file);
config_save_keybinds(input_path);
if(g_console.emulator_initialized)
rarch_main_deinit();
input_gx.free(NULL);
video_gx.stop();
menu_free();
#ifdef HAVE_LOGGER
logger_shutdown();
#elif defined(HAVE_FILE_LOGGER)
fclose(log_fp);
#endif
if(g_console.return_to_launcher)
rarch_console_exec(g_console.launch_app_on_exit);
exit(0);
}
static void menu_loop(void)
{
gx_video_t *gx = (gx_video_t*)driver.video_data;
uint16_t old_input_state = 0;
bool first = true;
bool first_held = false;
bool initial_held = true;
g_console.menu_enable = true;
gx->menu_render = true;
do
{
uint16_t input_state = 0;
input_gx.poll(NULL);
for (unsigned i = 0; i < GX_DEVICE_NAV_LAST; i++)
{
input_state |= input_gx.input_state(NULL, gx_nav_binds, 0,
RETRO_DEVICE_JOYPAD, 0, i) ? (1 << i) : 0;
}
uint16_t trigger_state = input_state & ~old_input_state;
bool do_held = (input_state & ((1 << GX_DEVICE_NAV_UP) | (1 << GX_DEVICE_NAV_DOWN) | (1 << GX_DEVICE_NAV_LEFT) | (1 << GX_DEVICE_NAV_RIGHT))) && !(input_state & ((1 << GX_DEVICE_NAV_MENU) | (1 << GX_DEVICE_NAV_QUIT)));
if(do_held)
{
if(!first_held)
{
first_held = true;
SET_TIMER_EXPIRATION(gx, (initial_held) ? 15 : 7);
}
if(IS_TIMER_EXPIRED(gx))
{
first_held = false;
trigger_state = input_state; //second input frame set as current frame
}
initial_held = false;
}
else
{
first_held = false;
initial_held = true;
}
rgui_action_t action = RGUI_ACTION_NOOP;
// don't run anything first frame, only capture held inputs for old_input_state
if (!first)
{
if (trigger_state & (1 << GX_DEVICE_NAV_UP))
action = RGUI_ACTION_UP;
else if (trigger_state & (1 << GX_DEVICE_NAV_DOWN))
action = RGUI_ACTION_DOWN;
else if (trigger_state & (1 << GX_DEVICE_NAV_LEFT))
action = RGUI_ACTION_LEFT;
else if (trigger_state & (1 << GX_DEVICE_NAV_RIGHT))
action = RGUI_ACTION_RIGHT;
else if (trigger_state & (1 << GX_DEVICE_NAV_B))
action = RGUI_ACTION_CANCEL;
else if (trigger_state & (1 << GX_DEVICE_NAV_A))
action = RGUI_ACTION_OK;
else if (trigger_state & (1 << GX_DEVICE_NAV_START))
action = RGUI_ACTION_START;
else if (trigger_state & (1 << GX_DEVICE_NAV_SELECT))
action = RGUI_ACTION_SETTINGS;
}
else
{
first = false;
}
rgui_iterate(rgui, action);
rarch_render_cached_frame();
old_input_state = input_state;
bool goto_menu_key_pressed = (trigger_state & (1 << GX_DEVICE_NAV_MENU));
bool quit_key_pressed = (trigger_state & (1 << GX_DEVICE_NAV_QUIT));
if(IS_TIMER_EXPIRED(gx))
{
// if we want to force goto the emulation loop, skip this
if(g_console.mode_switch != MODE_EMULATION)
{
if(goto_menu_key_pressed)
{
g_console.menu_enable = (goto_menu_key_pressed && g_console.emulator_initialized) ? false : true;
g_console.mode_switch = g_console.menu_enable ? MODE_MENU : MODE_EMULATION;
}
}
}
if(quit_key_pressed)
{
g_console.menu_enable = false;
g_console.mode_switch = MODE_EXIT;
}
// set a timer delay so that we don't instantly switch back to the menu when
// press and holding QUIT in the emulation loop (lasts for 30 frame ticks)
if(g_console.mode_switch == MODE_EMULATION)
{
SET_TIMER_EXPIRATION(gx, 30);
}
}while(g_console.menu_enable);
gx->menu_render = false;
g_console.ingame_menu_enable = false;
}
static void *android_app_entry(void *data)
{
struct android_app* android_app = (struct android_app*)data;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL, NULL);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
memset(&g_android, 0, sizeof(g_android));
g_android = android_app;
RARCH_LOG("Native Activity started.\n");
rarch_main_clear_state();
while (!android_app->window)
{
if (!android_run_events(android_app))
goto exit;
}
rarch_init_msg_queue();
if (!android_app_start_main(android_app))
{
g_settings.input.overlay[0] = 0;
// threaded video doesn't work right for just displaying one frame
g_settings.video.threaded = false;
init_drivers();
driver.video_poke->set_aspect_ratio(driver.video_data, ASPECT_RATIO_SQUARE);
rarch_render_cached_frame();
sleep(2);
goto exit;
}
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#ifdef RARCH_CONSOLE
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
return NULL;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
driver.input->poll(NULL);
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_start_func();
// Main loop
while (rarch_main_iterate());
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_stop_func();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if(g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_PREINIT);
while((input_key_pressed_func(RARCH_PAUSE_TOGGLE)) ?
android_run_events(android_app) : menu_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
exit:
android_app->activityState = APP_CMD_DEAD;
RARCH_LOG("Deinitializing RetroArch...\n");
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
if (g_extern.main_is_init)
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
rarch_main_clear_state();
RARCH_LOG("android_app_destroy!");
if (android_app->inputQueue != NULL)
AInputQueue_detachLooper(android_app->inputQueue);
AConfiguration_delete(android_app->config);
// exit() here is nasty.
// pthread_exit(NULL) or return NULL; causes hanging ...
// Should probably called ANativeActivity_finsih(), but it's bugged, it will hang our app.
exit(0);
}
bool menu_iterate(void *data)
{
unsigned action;
static bool initial_held = true;
static bool first_held = false;
uint64_t input_state;
int32_t input_entry_ret, ret;
rgui_handle_t *rgui;
input_state = 0;
input_entry_ret = 0;
ret = 0;
rgui = (rgui_handle_t*)data;
if (!rgui)
return false;
if (g_extern.lifecycle_state & (1ULL << MODE_MENU_PREINIT))
{
rgui->need_refresh = true;
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU_PREINIT);
rgui->old_input_state |= 1ULL << RARCH_MENU_TOGGLE;
}
rarch_input_poll();
rarch_check_block_hotkey();
#ifdef HAVE_OVERLAY
rarch_check_overlay();
#endif
rarch_check_fullscreen();
if (input_key_pressed_func(RARCH_QUIT_KEY) || !video_alive_func())
{
g_extern.lifecycle_state |= (1ULL << MODE_GAME);
return false;
}
input_state = menu_input(rgui);
if (rgui->do_held)
{
if (!first_held)
{
first_held = true;
rgui->delay_timer = initial_held ? 12 : 6;
rgui->delay_count = 0;
}
if (rgui->delay_count >= rgui->delay_timer)
{
first_held = false;
rgui->trigger_state = input_state;
rgui->scroll_accel = min(rgui->scroll_accel + 1, 64);
}
initial_held = false;
}
else
{
first_held = false;
initial_held = true;
rgui->scroll_accel = 0;
}
rgui->delay_count++;
rgui->old_input_state = input_state;
if (driver.block_input)
rgui->trigger_state = 0;
action = RGUI_ACTION_NOOP;
// don't run anything first frame, only capture held inputs for old_input_state
if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_UP))
action = RGUI_ACTION_UP;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN))
action = RGUI_ACTION_DOWN;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT))
action = RGUI_ACTION_LEFT;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT))
action = RGUI_ACTION_RIGHT;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_L))
action = RGUI_ACTION_SCROLL_UP;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_R))
action = RGUI_ACTION_SCROLL_DOWN;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_B))
action = RGUI_ACTION_CANCEL;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_A))
action = RGUI_ACTION_OK;
else if (rgui->trigger_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_START))
action = RGUI_ACTION_START;
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->iterate)
input_entry_ret = driver.menu_ctx->backend->iterate(rgui, action);
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, rgui->frame_buf_show, MENU_TEXTURE_FULLSCREEN);
rarch_render_cached_frame();
// Throttle in case VSync is broken (avoid 1000+ FPS RGUI).
rgui->time = rarch_get_time_usec();
rgui->delta = (rgui->time - rgui->last_time) / 1000;
rgui->target_msec = 750 / g_settings.video.refresh_rate; // Try to sleep less, so we can hopefully rely on FPS logger.
rgui->sleep_msec = rgui->target_msec - rgui->delta;
if (rgui->sleep_msec > 0)
rarch_sleep((unsigned int)rgui->sleep_msec);
rgui->last_time = rarch_get_time_usec();
if (driver.video_data && driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, false,
MENU_TEXTURE_FULLSCREEN);
if (driver.menu_ctx && driver.menu_ctx->input_postprocess)
ret = driver.menu_ctx->input_postprocess(rgui, rgui->old_input_state);
if (ret < 0)
{
unsigned type = 0;
file_list_get_last(rgui->menu_stack, NULL, &type);
while (type != RGUI_SETTINGS)
{
file_list_pop(rgui->menu_stack, &rgui->selection_ptr);
file_list_get_last(rgui->menu_stack, NULL, &type);
}
}
if (ret || input_entry_ret)
return false;
return true;
}
void menu_loop(void)
{
HRESULT hr;
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
g_extern.console.rmenu.state.rmenu.enable = true;
d3d->block_swap = true;
g_extern.console.rmenu.input_loop = INPUT_LOOP_MENU;
do
{
if(g_extern.console.emulator_initialized)
rarch_render_cached_frame();
else
{
d3d->d3d_render_device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
d3d->frame_count++;
}
XINPUT_STATE state;
XInputGetState(0, &state);
g_extern.console.rmenu.state.rmenu.enable = !((state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB)
&& (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) && (g_extern.console.emulator_initialized)
&& IS_TIMER_EXPIRED(d3d));
g_extern.console.rmenu.mode = g_extern.console.rmenu.state.rmenu.enable ? MODE_MENU : MODE_EMULATION;
switch(g_extern.console.rmenu.input_loop)
{
case INPUT_LOOP_FILEBROWSER:
/*
if(((state.Gamepad.wButtons & XINPUT_GAMEPAD_Y) && hCur != app.hMainScene))
{
uint64_t action = (1 << RMENU_DEVICE_NAV_A);
browser_update(browser, action, rarch_console_get_rom_ext());
SET_TIMER_EXPIRATION(d3d, 15);
}
*/
case INPUT_LOOP_MENU:
app.RunFrame(); /* Update XUI */
if((state.Gamepad.wButtons & XINPUT_GAMEPAD_B) && hCur != app.hMainScene)
XuiSceneNavigateBack(hCur, app.hMainScene, XUSER_INDEX_ANY);
break;
case INPUT_LOOP_RESIZE_MODE:
ingame_menu_resize();
break;
default:
break;
}
hr = app.Render(); /* Render XUI */
hr = XuiTimersRun(); /* Update XUI timers */
if(g_extern.console.rmenu.mode == MODE_EMULATION && !g_extern.console.screen.state.frame_advance.enable)
{
SET_TIMER_EXPIRATION(d3d, 30);
}
const char *message = msg_queue_pull(g_extern.msg_queue);
if (message)
{
xdk360_console_format(message);
xdk360_console_draw();
}
context->swap_buffers();
}while(g_extern.console.rmenu.state.rmenu.enable);
d3d->block_swap = false;
g_extern.console.rmenu.state.ingame_menu.enable = false;
}
bool menu_iterate(void)
{
rarch_time_t time, delta, target_msec, sleep_msec;
static bool initial_held = true;
static bool first_held = false;
uint64_t input_state = 0;
int input_entry_ret;
if (g_extern.lifecycle_mode_state & (1ULL << MODE_MENU_PREINIT))
{
rgui->need_refresh = true;
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU_PREINIT);
rgui->old_input_state |= 1ULL << DEVICE_NAV_MENU;
}
rarch_input_poll();
#ifdef HAVE_OVERLAY
rarch_check_overlay();
#endif
if (input_key_pressed_func(RARCH_QUIT_KEY) || !video_alive_func())
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
goto deinit;
}
input_state = rgui_input();
if (rgui->do_held)
{
if (!first_held)
{
first_held = true;
rgui->delay_timer = initial_held ? 12 : 6;
rgui->delay_count = 0;
}
if (rgui->delay_count >= rgui->delay_timer)
{
first_held = false;
rgui->trigger_state = input_state;
}
initial_held = false;
}
else
{
first_held = false;
initial_held = true;
}
rgui->delay_count++;
rgui->old_input_state = input_state;
input_entry_ret = rgui_iterate(rgui);
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, rgui->frame_buf_show, MENU_TEXTURE_FULLSCREEN);
rarch_render_cached_frame();
// Throttle in case VSync is broken (avoid 1000+ FPS RGUI).
time = rarch_get_time_usec();
delta = (time - rgui->last_time) / 1000;
target_msec = 750 / g_settings.video.refresh_rate; // Try to sleep less, so we can hopefully rely on FPS logger.
sleep_msec = target_msec - delta;
if (sleep_msec > 0)
rarch_sleep(sleep_msec);
rgui->last_time = rarch_get_time_usec();
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data, false,
MENU_TEXTURE_FULLSCREEN);
if (rgui_input_postprocess(rgui, rgui->old_input_state) || input_entry_ret)
goto deinit;
return true;
deinit:
return false;
}
bool rmenu_iterate(void)
{
static uint16_t old_input_state = 0;
static bool initial_held = true;
static bool first_held = false;
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_DRAW);
driver.video->apply_state_changes();
g_extern.frame_count++;
uint16_t input_state = 0;
driver.input->poll(NULL);
for (unsigned i = 0; i < RMENU_DEVICE_NAV_LAST; i++)
input_state |= driver.input->input_state(NULL, rmenu_nav_binds, 0,
RETRO_DEVICE_JOYPAD, 0, i) ? (1ULL << i) : 0;
trigger_state = input_state & ~old_input_state;
bool do_held = (input_state & ((1ULL << GX_DEVICE_NAV_UP) | (1ULL << GX_DEVICE_NAV_DOWN) | (1ULL << GX_DEVICE_NAV_LEFT) | (1ULL << GX_DEVICE_NAV_RIGHT))) && !(input_state & ((1ULL << GX_DEVICE_NAV_MENU) | (1ULL << GX_DEVICE_NAV_QUIT)));
if(do_held)
{
if(!first_held)
{
first_held = true;
g_extern.delay_timer[1] = g_extern.frame_count + (initial_held ? 15 : 7);
}
if (!(g_extern.frame_count < g_extern.delay_timer[1]))
{
first_held = false;
trigger_state = input_state; //second input frame set as current frame
}
initial_held = false;
}
else
{
first_held = false;
initial_held = true;
}
old_input_state = input_state;
rgui_action_t action = RGUI_ACTION_NOOP;
// don't run anything first frame, only capture held inputs for old_input_state
if (trigger_state & (1ULL << GX_DEVICE_NAV_UP))
action = RGUI_ACTION_UP;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_DOWN))
action = RGUI_ACTION_DOWN;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_LEFT))
action = RGUI_ACTION_LEFT;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_RIGHT))
action = RGUI_ACTION_RIGHT;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_B))
action = RGUI_ACTION_CANCEL;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_A))
action = RGUI_ACTION_OK;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_START))
action = RGUI_ACTION_START;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_SELECT))
action = RGUI_ACTION_SETTINGS;
else if (trigger_state & (1ULL << GX_DEVICE_NAV_QUIT))
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXIT);
goto deinit;
}
int input_entry_ret = 0;
int input_process_ret = 0;
input_entry_ret = rgui_iterate(rgui, action);
// draw last frame for loading messages
rarch_render_cached_frame();
input_process_ret = rmenu_input_process(NULL, NULL);
if (input_entry_ret != 0 || input_process_ret != 0)
goto deinit;
return true;
deinit:
// set a timer delay so that we don't instantly switch back to the menu when
// press and holding QUIT in the emulation loop (lasts for 30 frame ticks)
if (!(g_extern.lifecycle_state & (1ULL << RARCH_FRAMEADVANCE)))
g_extern.delay_timer[0] = g_extern.frame_count + 30;
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU_DRAW);
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU_INGAME);
return false;
}
static int do_state_checks(
retro_input_t input, retro_input_t old_input,
retro_input_t trigger_input)
{
if (BIT64_GET(trigger_input, RARCH_SCREENSHOT))
rarch_main_command(RARCH_CMD_TAKE_SCREENSHOT);
if (BIT64_GET(trigger_input, RARCH_MUTE))
rarch_main_command(RARCH_CMD_AUDIO_MUTE_TOGGLE);
if (BIT64_GET(input, RARCH_VOLUME_UP))
set_volume(0.5f);
else if (BIT64_GET(input, RARCH_VOLUME_DOWN))
set_volume(-0.5f);
if (BIT64_GET(trigger_input, RARCH_GRAB_MOUSE_TOGGLE))
rarch_main_command(RARCH_CMD_GRAB_MOUSE_TOGGLE);
if (BIT64_GET(trigger_input, RARCH_OVERLAY_NEXT))
rarch_main_command(RARCH_CMD_OVERLAY_NEXT);
if (!g_extern.is_paused)
{
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
}
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
{
if (BIT64_GET(trigger_input, RARCH_NETPLAY_FLIP))
rarch_main_command(RARCH_CMD_NETPLAY_FLIP_PLAYERS);
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
return 0;
}
#endif
if (check_pause_func(trigger_input))
rarch_main_command(RARCH_CMD_PAUSE_TOGGLE);
if (g_extern.is_paused)
{
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
{
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
rarch_render_cached_frame();
}
if (!check_oneshot_func(trigger_input))
return 1;
}
check_fast_forward_button_func(input, old_input, trigger_input);
check_stateslots_func(trigger_input);
if (BIT64_GET(trigger_input, RARCH_SAVE_STATE_KEY))
rarch_main_command(RARCH_CMD_SAVE_STATE);
else if (BIT64_GET(trigger_input, RARCH_LOAD_STATE_KEY))
rarch_main_command(RARCH_CMD_LOAD_STATE);
check_rewind_func(input);
check_slowmotion_func(input);
if (BIT64_GET(trigger_input, RARCH_MOVIE_RECORD_TOGGLE))
check_movie();
check_shader_dir_func(trigger_input);
if (BIT64_GET(trigger_input, RARCH_CHEAT_INDEX_PLUS))
cheat_manager_index_next(g_extern.cheat);
else if (BIT64_GET(trigger_input, RARCH_CHEAT_INDEX_MINUS))
cheat_manager_index_prev(g_extern.cheat);
else if (BIT64_GET(trigger_input, RARCH_CHEAT_TOGGLE))
cheat_manager_toggle(g_extern.cheat);
if (BIT64_GET(trigger_input, RARCH_DISK_EJECT_TOGGLE))
rarch_main_command(RARCH_CMD_DISK_EJECT_TOGGLE);
else if (BIT64_GET(trigger_input, RARCH_DISK_NEXT))
rarch_main_command(RARCH_CMD_DISK_NEXT);
else if (BIT64_GET(trigger_input, RARCH_DISK_PREV))
rarch_main_command(RARCH_CMD_DISK_PREV);
if (BIT64_GET(trigger_input, RARCH_RESET))
rarch_main_command(RARCH_CMD_RESET);
return 0;
}
bool rmenu_iterate(void)
{
static bool preinit = true;
const char *msg;
xdk_d3d_video_t *device_ptr = (xdk_d3d_video_t*)driver.video_data;
if(preinit)
{
g_extern.console.rmenu.input_loop = INPUT_LOOP_MENU;
g_extern.draw_menu = true;
preinit = false;
}
g_extern.frame_count++;
XINPUT_STATE state;
XInputGetState(0, &state);
bool rmenu_enable = !((state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB)
&& (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) && (g_extern.console.emulator_initialized)
&& IS_TIMER_EXPIRED(0));
rarch_render_cached_frame();
g_extern.console.rmenu.mode = rmenu_enable ? MODE_MENU : MODE_EMULATION;
switch(g_extern.console.rmenu.input_loop)
{
case INPUT_LOOP_FILEBROWSER:
case INPUT_LOOP_MENU:
app.RunFrame(); /* Update XUI */
if((state.Gamepad.wButtons & XINPUT_GAMEPAD_B) && hCur != app.hMainScene)
XuiSceneNavigateBack(hCur, app.hMainScene, XUSER_INDEX_ANY);
break;
case INPUT_LOOP_RESIZE_MODE:
ingame_menu_resize();
break;
default:
break;
}
if(g_extern.console.rmenu.mode == MODE_EMULATION || g_extern.console.rmenu.mode == MODE_EXIT)
goto deinit;
msg = msg_queue_pull(g_extern.msg_queue);
if (msg)
{
device_ptr->font_ctx->render_msg(device_ptr, msg);
}
device_ptr->ctx_driver->swap_buffers();
return true;
deinit:
if(!(g_extern.lifecycle_state & (1ULL << RARCH_FRAMEADVANCE)))
{
// set a timer delay so that we don't instantly switch back to the menu when
// press and holding L3 + R3 in the emulation loop (lasts for 30 frame ticks)
SET_TIMER_EXPIRATION(0, 30);
}
g_extern.console.rmenu.state.ingame_menu.enable = false;
g_extern.draw_menu = false;
preinit = true;
return false;
}
void menu_loop(void)
{
HRESULT hr;
xdk360_video_t *d3d9 = (xdk360_video_t*)driver.video_data;
g_console.menu_enable = true;
d3d9->block_swap = true;
g_console.input_loop = INPUT_LOOP_MENU;
do
{
if(g_console.emulator_initialized)
{
rarch_render_cached_frame();
}
else
{
d3d9->d3d_render_device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
d3d9->frame_count++;
}
XINPUT_STATE state;
XInputGetState(0, &state);
g_console.menu_enable = !((state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB)
&& (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) && (g_console.emulator_initialized)
&& IS_TIMER_EXPIRED(d3d9));
g_console.mode_switch = g_console.menu_enable ? MODE_MENU : MODE_EMULATION;
switch(g_console.input_loop)
{
case INPUT_LOOP_MENU:
app.RunFrame(); /* Update XUI */
if(state.Gamepad.wButtons & XINPUT_GAMEPAD_B && hCur != app.hMainScene)
XuiSceneNavigateBack(hCur, app.hMainScene, XUSER_INDEX_ANY);
break;
case INPUT_LOOP_RESIZE_MODE:
ingame_menu_resize();
break;
default:
break;
}
hr = app.Render(); /* Render XUI */
hr = XuiTimersRun(); /* Update XUI timers */
if(g_console.mode_switch == MODE_EMULATION && !g_console.frame_advance_enable)
{
SET_TIMER_EXPIRATION(d3d9, 30);
}
const char *message = msg_queue_pull(g_extern.msg_queue);
if (message)
{
if(IS_TIMER_EXPIRED(d3d9))
{
xdk360_console_format(message);
SET_TIMER_EXPIRATION(d3d9, 30);
}
xdk360_console_draw();
}
gfx_ctx_swap_buffers();
}while(g_console.menu_enable);
d3d9->block_swap = false;
g_console.ingame_menu_enable = false;
}