From 8a81d39437757bd167944f754031fb71da9dfb01 Mon Sep 17 00:00:00 2001 From: nfore Date: Sat, 8 Jul 2023 08:43:25 -0500 Subject: [PATCH] Overlay Caching Adds overlay_cache_ptr to keep a disabled overlay in memory when it's expected to be shown again. Most input_overlay_deinit calls are replaced with input_overlay_unload, which caches the overlay unless initing/deiniting core or disabling overlays. Loading a cached overlay is done as a swap, intended for osk_toggle. Related updates: - Fewer parameters for the overlay loading task. Use current settings when enabling an overlay - Add input_overlay_check_mouse_cursor() to preserve show/hide mouse behavior - Don't apply input_overlay_show_mouse_cursor in windowed mode (controlled by mouse grab only) - Remove some dead code --- command.h | 4 +- gfx/video_driver.c | 8 +- input/input_driver.c | 384 ++++++++++++++++++++++++----------------- input/input_driver.h | 5 +- input/input_overlay.h | 11 +- menu/menu_driver.c | 2 +- menu/menu_setting.c | 47 +---- retroarch.c | 7 +- runloop.c | 2 +- tasks/task_overlay.c | 39 +---- tasks/tasks_internal.h | 5 - 11 files changed, 263 insertions(+), 251 deletions(-) diff --git a/command.h b/command.h index e31bc7e16a..fbfc1d262e 100644 --- a/command.h +++ b/command.h @@ -109,8 +109,8 @@ enum event_command CMD_EVENT_STATISTICS_TOGGLE, /* Initializes overlay. */ CMD_EVENT_OVERLAY_INIT, - /* Deinitializes overlay. */ - CMD_EVENT_OVERLAY_DEINIT, + /* Frees or caches overlay. */ + CMD_EVENT_OVERLAY_UNLOAD, /* Sets current scale factor for overlay. */ CMD_EVENT_OVERLAY_SET_SCALE_FACTOR, /* Sets current alpha modulation for overlay. */ diff --git a/gfx/video_driver.c b/gfx/video_driver.c index 3251d59477..df07b154c3 100644 --- a/gfx/video_driver.c +++ b/gfx/video_driver.c @@ -1461,7 +1461,7 @@ void video_driver_free_internal(void) bool is_threaded = VIDEO_DRIVER_IS_THREADED_INTERNAL(video_st); #endif - command_event(CMD_EVENT_OVERLAY_DEINIT, NULL); + command_event(CMD_EVENT_OVERLAY_UNLOAD, NULL); if (!(video_st->flags & VIDEO_FLAG_CACHE_CONTEXT)) video_driver_free_hw_context(); @@ -3178,7 +3178,7 @@ bool video_driver_init_internal(bool *video_is_threaded, bool verbosity_enabled) return false; #ifdef HAVE_OVERLAY - input_overlay_deinit(); + input_overlay_unload(); input_overlay_init(); #endif @@ -3225,6 +3225,10 @@ bool video_driver_init_internal(bool *video_is_threaded, bool verbosity_enabled) input_st->flags |= INP_FLAG_GRAB_MOUSE_STATE; } +#ifdef HAVE_OVERLAY + input_overlay_check_mouse_cursor(); +#endif + return true; } diff --git a/input/input_driver.c b/input/input_driver.c index 510949de5c..89d4a5c6f2 100644 --- a/input/input_driver.c +++ b/input/input_driver.c @@ -2574,9 +2574,15 @@ static void input_overlay_free(input_overlay_t *ol) input_overlay_free_overlays(ol); - if (ol->iface->enable) + if (ol->iface && ol->iface->enable) ol->iface->enable(ol->iface_data, false); + if (ol->path) + { + free(ol->path); + ol->path = NULL; + } + free(ol); } @@ -4319,10 +4325,132 @@ void input_game_focus_free(void) } #ifdef HAVE_OVERLAY -void input_overlay_deinit(void) +static bool video_driver_overlay_interface( + const video_overlay_interface_t **iface) +{ + video_driver_state_t *video_st = video_state_get_ptr(); + if (!video_st->current_video || !video_st->current_video->overlay_interface) + return false; + video_st->current_video->overlay_interface(video_st->data, iface); + return true; +} + +static void input_overlay_enable_(bool enable) +{ + settings_t *settings = config_get_ptr(); + video_driver_state_t *video_st = video_state_get_ptr(); + input_driver_state_t *input_st = &input_driver_st; + input_overlay_t *ol = input_st->overlay_ptr; + float opacity = settings->floats.input_overlay_opacity; + bool auto_rotate = settings->bools.input_overlay_auto_rotate; + bool hide_mouse_cursor = !settings->bools.input_overlay_show_mouse_cursor + && (input_st->flags & INP_FLAG_GRAB_MOUSE_STATE); + + if (!ol) + return; + + if (enable) + { + /* Set video interface */ + ol->iface_data = video_st->data; + if (!video_driver_overlay_interface(&ol->iface) || !ol->iface) + { + RARCH_ERR("Overlay interface is not present in video driver.\n"); + ol->flags &= ~INPUT_OVERLAY_ALIVE; + return; + } + + /* Load last-active overlay */ + input_overlay_load_active(input_st->overlay_visibility, ol, opacity); + + /* Adjust to current settings */ + command_event(CMD_EVENT_OVERLAY_SET_SCALE_FACTOR, NULL); + + if (auto_rotate) + input_overlay_auto_rotate_( + video_st->width, video_st->height, true, ol); + + /* Enable */ + if (ol->iface->enable) + ol->iface->enable(ol->iface_data, true); + + ol->flags |= (INPUT_OVERLAY_ENABLE | INPUT_OVERLAY_BLOCKED); + + if ( hide_mouse_cursor + && video_st->poke + && video_st->poke->show_mouse) + video_st->poke->show_mouse(video_st->data, false); + } + else + { + /* Disable and clear input state */ + ol->flags &= ~INPUT_OVERLAY_ENABLE; + + if (ol->iface && ol->iface->enable) + ol->iface->enable(ol->iface_data, false); + ol->iface = NULL; + + memset(&ol->overlay_state, 0, sizeof(input_overlay_state_t)); + } +} + +static void input_overlay_deinit(void) { input_overlay_free(input_driver_st.overlay_ptr); input_driver_st.overlay_ptr = NULL; + + input_overlay_free(input_driver_st.overlay_cache_ptr); + input_driver_st.overlay_cache_ptr = NULL; +} + +static void input_overlay_move_to_cache(void) +{ + input_driver_state_t *input_st = &input_driver_st; + input_overlay_t *ol = input_st->overlay_ptr; + + if (!ol) + return; + + /* Free existing cache */ + input_overlay_free(input_driver_st.overlay_cache_ptr); + + /* Disable current overlay */ + input_overlay_enable_(false); + + /* Move to cache */ + input_st->overlay_cache_ptr = ol; + input_st->overlay_ptr = NULL; +} + +static void input_overlay_swap_with_cached(void) +{ + input_driver_state_t *input_st = &input_driver_st; + input_overlay_t *ol; + + /* Disable current overlay */ + input_overlay_enable_(false); + + /* Swap with cached */ + ol = input_st->overlay_cache_ptr; + input_st->overlay_cache_ptr = input_st->overlay_ptr; + input_st->overlay_ptr = ol; + + /* Enable and update to current settings */ + input_overlay_enable_(true); +} + +void input_overlay_unload(void) +{ + settings_t *settings = config_get_ptr(); + runloop_state_t *runloop_st = runloop_state_get_ptr(); + + /* Free if overlays disabled or initing/deiniting core */ + if ( !settings->bools.input_overlay_enable + || !(runloop_st->flags & RUNLOOP_FLAG_IS_INITED) + || (runloop_st->flags & RUNLOOP_FLAG_SHUTDOWN_INITIATED)) + input_overlay_deinit(); + else + input_overlay_move_to_cache(); } void input_overlay_set_visibility(int overlay_idx, @@ -4349,14 +4477,37 @@ void input_overlay_set_visibility(int overlay_idx, ol->iface->set_alpha(ol->iface_data, overlay_idx, 0.0); } -static bool video_driver_overlay_interface( - const video_overlay_interface_t **iface) +static bool input_overlay_want_hidden(void) { + settings_t *settings = config_get_ptr(); + bool hide = false; + +#ifdef HAVE_MENU + if (settings->bools.input_overlay_hide_in_menu) + hide = (menu_state_get_ptr()->flags & MENU_ST_FLAG_ALIVE) != 0; +#endif + if (settings->bools.input_overlay_hide_when_gamepad_connected) + hide = hide || (input_config_get_device_name(0) != NULL); + + return hide; +} + +void input_overlay_check_mouse_cursor(void) +{ + settings_t *settings = config_get_ptr(); + input_driver_state_t *input_st = &input_driver_st; video_driver_state_t *video_st = video_state_get_ptr(); - if (!video_st->current_video || !video_st->current_video->overlay_interface) - return false; - video_st->current_video->overlay_interface(video_st->data, iface); - return true; + input_overlay_t *ol = input_st->overlay_ptr; + + if ( ol && (ol->flags & INPUT_OVERLAY_ENABLE) + && video_st->poke + && video_st->poke->show_mouse) + { + if (settings->bools.input_overlay_show_mouse_cursor) + video_st->poke->show_mouse(video_st->data, true); + else if (input_st->flags & INP_FLAG_GRAB_MOUSE_STATE) + video_st->poke->show_mouse(video_st->data, false); + } } /* task_data = overlay_task_data_t* */ @@ -4364,186 +4515,105 @@ static void input_overlay_loaded(retro_task_t *task, void *task_data, void *user_data, const char *err) { size_t i; - overlay_task_data_t *data = (overlay_task_data_t*)task_data; - input_overlay_t *ol = NULL; - const video_overlay_interface_t *iface = NULL; - settings_t *settings = config_get_ptr(); - bool input_overlay_show_mouse_cursor = settings->bools.input_overlay_show_mouse_cursor; - bool inp_overlay_auto_rotate = settings->bools.input_overlay_auto_rotate; - bool input_overlay_enable = settings->bools.input_overlay_enable; - video_driver_state_t *video_st = video_state_get_ptr(); - input_driver_state_t *input_st = &input_driver_st; + settings_t *settings = config_get_ptr(); + overlay_task_data_t *data = (overlay_task_data_t*)task_data; + input_overlay_t *ol = NULL; + input_driver_state_t *input_st = &input_driver_st; +#ifdef HAVE_MENU + struct menu_state *menu_st = menu_state_get_ptr(); +#endif + bool enable_overlay = !input_overlay_want_hidden() + && settings->bools.input_overlay_enable; + uint16_t overlay_types; + if (err) return; - if (data->flags & OVERLAY_LOADER_ENABLE) - { -#ifdef HAVE_MENU - struct menu_state *menu_st = menu_state_get_ptr(); + ol = (input_overlay_t*)calloc(1, sizeof(*ol)); + ol->overlays = data->overlays; + ol->size = data->size; + ol->active = data->active; + ol->path = data->overlay_path; + ol->next_index = (unsigned)((ol->index + 1) % ol->size); + ol->flags |= INPUT_OVERLAY_ALIVE; + overlay_types = data->overlay_types; - /* Update menu entries */ - if (menu_st->overlay_types != data->overlay_types) - { - menu_st->overlay_types = data->overlay_types; - menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH; - } - - /* We can't display when the menu is up */ - if ( (data->flags & OVERLAY_LOADER_HIDE_IN_MENU) - && (menu_st->flags & MENU_ST_FLAG_ALIVE)) - goto abort_load; -#endif - - /* If 'hide_when_gamepad_connected' is enabled, - * we can't display when a gamepad is connected */ - if ( (data->flags & OVERLAY_LOADER_HIDE_WHEN_GAMEPAD_CONNECTED) - && (input_config_get_device_name(0) != NULL)) - goto abort_load; - } - - if ( !(data->flags & OVERLAY_LOADER_ENABLE) - || !video_driver_overlay_interface(&iface) - || !iface) - { - RARCH_ERR("Overlay interface is not present in video driver," - " or not enabled.\n"); - goto abort_load; - } - - ol = (input_overlay_t*)calloc(1, sizeof(*ol)); - ol->overlays = data->overlays; - ol->size = data->size; - ol->active = data->active; - ol->iface = iface; - ol->iface_data = video_st->data; - - input_overlay_load_active(input_st->overlay_visibility, - ol, data->overlay_opacity); - - /* Enable or disable the overlay. */ - if (data->flags & OVERLAY_LOADER_ENABLE) - ol->flags |= INPUT_OVERLAY_ENABLE; - else - ol->flags &= ~INPUT_OVERLAY_ENABLE; - - if (ol->iface->enable) - ol->iface->enable(ol->iface_data, (ol->flags & INPUT_OVERLAY_ENABLE)); - - input_overlay_set_scale_factor(ol, &data->layout_desc, - video_st->width, video_st->height); - - ol->next_index = (unsigned)((ol->index + 1) % ol->size); - ol->state = OVERLAY_STATUS_NONE; - ol->flags |= INPUT_OVERLAY_ALIVE; + free(data); /* Due to the asynchronous nature of overlay loading * it is possible for overlay_ptr to be non-NULL here * > Ensure it is free()'d before assigning new pointer */ if (input_st->overlay_ptr) - { - input_overlay_free_overlays(input_st->overlay_ptr); - free(input_st->overlay_ptr); - } + input_overlay_free(input_st->overlay_ptr); input_st->overlay_ptr = ol; - free(data); + /* Enable or disable the overlay */ + input_overlay_enable_(enable_overlay); - if (!input_overlay_show_mouse_cursor) + /* Abort if enable failed */ + if (!(ol->flags & INPUT_OVERLAY_ALIVE)) { - if ( video_st->poke - && video_st->poke->show_mouse) - video_st->poke->show_mouse(video_st->data, false); + input_st->overlay_ptr = NULL; + input_overlay_free(ol); + return; } - /* Attempt to automatically rotate overlay, if required */ - if (inp_overlay_auto_rotate) - input_overlay_auto_rotate_( - video_st->width, - video_st->height, - input_overlay_enable, - input_st->overlay_ptr); + /* Cache or free if hidden */ + if (!enable_overlay) + input_overlay_unload(); input_overlay_set_eightway_diagonal_sensitivity(); - return; - -abort_load: - for (i = 0; i < data->size; i++) - input_overlay_free_overlay(&data->overlays[i]); - - free(data->overlays); - free(data); +#ifdef HAVE_MENU + /* Update menu entries */ + if (menu_st->overlay_types != overlay_types) + { + menu_st->overlay_types = overlay_types; + menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH; + } +#endif } void input_overlay_init(void) { - settings_t *settings = config_get_ptr(); - bool input_overlay_enable = settings->bools.input_overlay_enable; - bool input_overlay_auto_scale = settings->bools.input_overlay_auto_scale; - const char *path_overlay = settings->paths.path_overlay; - float overlay_opacity = settings->floats.input_overlay_opacity; - float overlay_scale_landscape = settings->floats.input_overlay_scale_landscape; - float overlay_aspect_adjust_landscape = settings->floats.input_overlay_aspect_adjust_landscape; - float overlay_x_separation_landscape = settings->floats.input_overlay_x_separation_landscape; - float overlay_y_separation_landscape = settings->floats.input_overlay_y_separation_landscape; - float overlay_x_offset_landscape = settings->floats.input_overlay_x_offset_landscape; - float overlay_y_offset_landscape = settings->floats.input_overlay_y_offset_landscape; - float overlay_scale_portrait = settings->floats.input_overlay_scale_portrait; - float overlay_aspect_adjust_portrait = settings->floats.input_overlay_aspect_adjust_portrait; - float overlay_x_separation_portrait = settings->floats.input_overlay_x_separation_portrait; - float overlay_y_separation_portrait = settings->floats.input_overlay_y_separation_portrait; - float overlay_x_offset_portrait = settings->floats.input_overlay_x_offset_portrait; - float overlay_y_offset_portrait = settings->floats.input_overlay_y_offset_portrait; - float overlay_touch_scale = (float)settings->uints.input_touch_scale; + settings_t *settings = config_get_ptr(); + input_driver_state_t *input_st = &input_driver_st; + input_overlay_t *ol = input_st->overlay_ptr; + input_overlay_t *ol_cache = input_st->overlay_cache_ptr; + const char *path_overlay = settings->paths.path_overlay; + bool want_hidden = input_overlay_want_hidden(); + bool overlay_shown = ol + && (ol->flags & INPUT_OVERLAY_ENABLE) + && string_is_equal(path_overlay, ol->path); + bool overlay_cached = ol_cache + && (ol_cache->flags & INPUT_OVERLAY_ALIVE) + && string_is_equal(path_overlay, ol_cache->path); + bool overlay_hidden = !ol && overlay_cached; - bool load_enabled = input_overlay_enable; -#ifdef HAVE_MENU - bool overlay_hide_in_menu = settings->bools.input_overlay_hide_in_menu; -#else - bool overlay_hide_in_menu = false; -#endif - bool overlay_hide_when_gamepad_connected = settings->bools.input_overlay_hide_when_gamepad_connected; #if defined(GEKKO) /* Avoid a crash at startup or even when toggling overlay in rgui */ if (frontend_driver_get_free_memory() < (3 * 1024 * 1024)) return; #endif + /* Cancel if overlays disabled or task already done */ + if ( !settings->bools.input_overlay_enable + || ( want_hidden && overlay_hidden) + || (!want_hidden && overlay_shown)) + return; + + /* Restore if cached */ + if (!want_hidden && overlay_cached) + { + input_overlay_swap_with_cached(); + return; + } + input_overlay_deinit(); - /* Cancel load if 'hide_when_gamepad_connected' is - * enabled and a gamepad is currently connected */ - if (overlay_hide_when_gamepad_connected) - load_enabled = load_enabled && (input_config_get_device_name(0) == NULL); - - if (load_enabled) - { - overlay_layout_desc_t layout_desc; - - layout_desc.scale_landscape = overlay_scale_landscape; - layout_desc.aspect_adjust_landscape = overlay_aspect_adjust_landscape; - layout_desc.x_separation_landscape = overlay_x_separation_landscape; - layout_desc.y_separation_landscape = overlay_y_separation_landscape; - layout_desc.x_offset_landscape = overlay_x_offset_landscape; - layout_desc.y_offset_landscape = overlay_y_offset_landscape; - layout_desc.scale_portrait = overlay_scale_portrait; - layout_desc.aspect_adjust_portrait = overlay_aspect_adjust_portrait; - layout_desc.x_separation_portrait = overlay_x_separation_portrait; - layout_desc.y_separation_portrait = overlay_y_separation_portrait; - layout_desc.x_offset_portrait = overlay_x_offset_portrait; - layout_desc.y_offset_portrait = overlay_y_offset_portrait; - layout_desc.touch_scale = overlay_touch_scale; - layout_desc.auto_scale = input_overlay_auto_scale; - - task_push_overlay_load_default(input_overlay_loaded, - path_overlay, - overlay_hide_in_menu, - overlay_hide_when_gamepad_connected, - input_overlay_enable, - overlay_opacity, - &layout_desc, - NULL); - } + /* Start task */ + task_push_overlay_load_default( + input_overlay_loaded, path_overlay, NULL); } #endif diff --git a/input/input_driver.h b/input/input_driver.h index 9067111b43..db992f204e 100644 --- a/input/input_driver.h +++ b/input/input_driver.h @@ -515,6 +515,7 @@ typedef struct #endif #ifdef HAVE_OVERLAY input_overlay_t *overlay_ptr; + input_overlay_t *overlay_cache_ptr; enum overlay_visibility *overlay_visibility; float overlay_eightway_dpad_slopes[2]; float overlay_eightway_abxy_slopes[2]; @@ -996,9 +997,11 @@ void input_driver_deinit_command(input_driver_state_t *input_st); #endif #ifdef HAVE_OVERLAY -void input_overlay_deinit(void); +void input_overlay_unload(void); void input_overlay_init(void); + +void input_overlay_check_mouse_cursor(void); #endif #ifdef HAVE_BSV_MOVIE diff --git a/input/input_overlay.h b/input/input_overlay.h index b337c6e0d4..4dd7b2b927 100644 --- a/input/input_overlay.h +++ b/input/input_overlay.h @@ -100,10 +100,7 @@ enum overlay_show_input_type enum OVERLAY_LOADER_FLAGS { - OVERLAY_LOADER_ENABLE = (1 << 0), - OVERLAY_LOADER_HIDE_IN_MENU = (1 << 1), - OVERLAY_LOADER_HIDE_WHEN_GAMEPAD_CONNECTED = (1 << 2), - OVERLAY_LOADER_RGBA_SUPPORT = (1 << 3) + OVERLAY_LOADER_RGBA_SUPPORT = (1 << 0) }; enum INPUT_OVERLAY_FLAGS @@ -291,6 +288,7 @@ struct input_overlay { struct overlay *overlays; const struct overlay *active; + char *path; void *iface_data; const video_overlay_interface_t *iface; input_overlay_state_t overlay_state; @@ -300,8 +298,6 @@ struct input_overlay unsigned next_index; - enum overlay_status state; - uint8_t flags; }; @@ -344,11 +340,10 @@ typedef struct input_overlay input_overlay_t; typedef struct { + char *overlay_path; struct overlay *overlays; struct overlay *active; size_t size; - float overlay_opacity; - overlay_layout_desc_t layout_desc; uint16_t overlay_types; uint8_t flags; } overlay_task_data_t; diff --git a/menu/menu_driver.c b/menu/menu_driver.c index 388f8722ff..bb2c94ca7a 100644 --- a/menu/menu_driver.c +++ b/menu/menu_driver.c @@ -6307,7 +6307,7 @@ void retroarch_menu_running(void) #ifdef HAVE_OVERLAY if (input_overlay_hide_in_menu) - command_event(CMD_EVENT_OVERLAY_DEINIT, NULL); + command_event(CMD_EVENT_OVERLAY_UNLOAD, NULL); #endif } diff --git a/menu/menu_setting.c b/menu/menu_setting.c index eb0702d08c..bebf9213dd 100644 --- a/menu/menu_setting.c +++ b/menu/menu_setting.c @@ -8666,48 +8666,18 @@ static void preempt_change_handler(rarch_setting_t *setting) #ifdef HAVE_OVERLAY static void overlay_enable_toggle_change_handler(rarch_setting_t *setting) { - settings_t *settings = config_get_ptr(); - bool input_overlay_hide_in_menu = settings ? settings->bools.input_overlay_hide_in_menu : false; + (void)setting; - if (!setting) - return; - - if (input_overlay_hide_in_menu) - { - command_event(CMD_EVENT_OVERLAY_DEINIT, NULL); - return; - } - - if (setting->value.target.boolean) - command_event(CMD_EVENT_OVERLAY_INIT, NULL); - else - command_event(CMD_EVENT_OVERLAY_DEINIT, NULL); + /* Force a re-init to apply updates */ + command_event(CMD_EVENT_OVERLAY_UNLOAD, NULL); + command_event(CMD_EVENT_OVERLAY_INIT, NULL); } -static void overlay_auto_rotate_toggle_change_handler(rarch_setting_t *setting) +static void overlay_show_mouse_cursor_change_handler(rarch_setting_t *setting) { - settings_t *settings = config_get_ptr(); + (void)setting; - if (!setting || !settings) - return; - - /* This is very simple... - * The menu is currently active, so if: - * - Overlays are enabled - * - Overlays are not hidden in menus - * ...we just need to de-initialise then - * initialise the current overlay and the - * auto-rotate setting will be applied - * (i.e. There's no need to explicitly - * call the internal 'rotate overlay' - * function - saves having to expose it - * via the API) */ - if (settings->bools.input_overlay_enable && - !settings->bools.input_overlay_hide_in_menu) - { - command_event(CMD_EVENT_OVERLAY_DEINIT, NULL); - command_event(CMD_EVENT_OVERLAY_INIT, NULL); - } + input_overlay_check_mouse_cursor(); } #endif @@ -16213,6 +16183,7 @@ static bool setting_append_list( general_read_handler, SD_FLAG_NONE ); + (*list)[list_info->index - 1].change_handler = overlay_show_mouse_cursor_change_handler; CONFIG_BOOL( list, list_info, @@ -16229,7 +16200,7 @@ static bool setting_append_list( general_read_handler, SD_FLAG_NONE ); - (*list)[list_info->index - 1].change_handler = overlay_auto_rotate_toggle_change_handler; + (*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler; CONFIG_BOOL( list, list_info, diff --git a/retroarch.c b/retroarch.c index b1dc99e558..586728c93a 100644 --- a/retroarch.c +++ b/retroarch.c @@ -2214,9 +2214,9 @@ bool command_event(enum event_command cmd, void *data) case CMD_EVENT_SAVE_FILES: event_save_files(runloop_st->flags & RUNLOOP_FLAG_USE_SRAM); break; - case CMD_EVENT_OVERLAY_DEINIT: + case CMD_EVENT_OVERLAY_UNLOAD: #ifdef HAVE_OVERLAY - input_overlay_deinit(); + input_overlay_unload(); #endif #if defined(HAVE_TRANSLATE) && defined(HAVE_GFX_WIDGETS) /* Because the overlay is a display widget, @@ -3951,6 +3951,9 @@ bool command_event(enum event_command cmd, void *data) if (input_driver_ungrab_mouse()) input_st->flags &= ~INP_FLAG_GRAB_MOUSE_STATE; } +#ifdef HAVE_OVERLAY + input_overlay_check_mouse_cursor(); +#endif video_st->flags &= ~VIDEO_FLAG_IS_SWITCHING_DISPLAY_MODE; audio_st->flags &= ~AUDIO_FLAG_SUSPENDED; diff --git a/runloop.c b/runloop.c index ddf078ef67..9538f94c7d 100644 --- a/runloop.c +++ b/runloop.c @@ -5502,7 +5502,7 @@ static enum runloop_state_enum runloop_check_state( if (controller_connected != last_controller_connected) { if (controller_connected) - input_overlay_deinit(); + input_overlay_unload(); else input_overlay_init(); diff --git a/tasks/task_overlay.c b/tasks/task_overlay.c index 0e593264da..993b43cdb9 100644 --- a/tasks/task_overlay.c +++ b/tasks/task_overlay.c @@ -47,9 +47,6 @@ struct overlay_loader unsigned pos; unsigned pos_increment; - float overlay_opacity; - overlay_layout_desc_t layout_desc; - enum overlay_status state; enum overlay_image_transfer_status loading_status; @@ -544,16 +541,8 @@ static void task_overlay_resolve_iterate(retro_task_t *task) } if (loader->resolve_pos == 0) - { loader->active = &loader->overlays[0]; -#if 0 - /* TODO: MOVE TO MAIN THREAD / CALLBACK */ - input_overlay_load_active(loader->deferred.opacity); - input_overlay_enable(loader->deferred.enable); -#endif - } - loader->resolve_pos += 1; } @@ -889,11 +878,11 @@ static void task_overlay_free(retro_task_t *task) overlay_loader_t *loader = (overlay_loader_t*)task->state; struct overlay *overlay = &loader->overlays[loader->pos]; - if (loader->overlay_path) - free(loader->overlay_path); - if (task_get_cancelled(task)) { + if (loader->overlay_path) + free(loader->overlay_path); + for (i = 0; i < overlay->load_images_size; i++) { struct texture_image *ti = &overlay->load_images[i]; @@ -945,12 +934,9 @@ static void task_overlay_handler(retro_task_t *task) data->overlays = loader->overlays; data->active = loader->active; data->size = loader->size; - data->overlay_opacity = loader->overlay_opacity; data->flags = loader->flags; data->overlay_types = loader->overlay_types; - - memcpy(&data->layout_desc, &loader->layout_desc, - sizeof(overlay_layout_desc_t)); + data->overlay_path = loader->overlay_path; task_set_data(task, data); } @@ -976,11 +962,6 @@ static bool task_overlay_finder(retro_task_t *task, void *user_data) bool task_push_overlay_load_default( retro_task_callback_t cb, const char *overlay_path, - bool overlay_hide_in_menu, - bool overlay_hide_when_gamepad_connected, - bool input_overlay_enable, - float input_overlay_opacity, - overlay_layout_desc_t *layout_desc, void *user_data) { task_finder_data_t find_data; @@ -988,7 +969,7 @@ bool task_push_overlay_load_default( config_file_t *conf = NULL; overlay_loader_t *loader = NULL; - if (string_is_empty(overlay_path) || !layout_desc) + if (string_is_empty(overlay_path)) return false; /* Prevent overlay from being loaded if it already is being loaded */ @@ -1027,25 +1008,15 @@ bool task_push_overlay_load_default( return false; } - loader->overlay_opacity = input_overlay_opacity; loader->conf = conf; loader->state = OVERLAY_STATUS_DEFERRED_LOAD; loader->pos_increment = (loader->size / 4) ? (loader->size / 4) : 4; - if (overlay_hide_in_menu) - loader->flags |= OVERLAY_LOADER_HIDE_IN_MENU; - if (overlay_hide_when_gamepad_connected) - loader->flags |= OVERLAY_LOADER_HIDE_WHEN_GAMEPAD_CONNECTED; - if (input_overlay_enable) - loader->flags |= OVERLAY_LOADER_ENABLE; #ifdef RARCH_INTERNAL if (video_driver_supports_rgba()) loader->flags |= OVERLAY_LOADER_RGBA_SUPPORT; #endif - memcpy(&loader->layout_desc, layout_desc, - sizeof(overlay_layout_desc_t)); - t = task_init(); if (!t) diff --git a/tasks/tasks_internal.h b/tasks/tasks_internal.h index 8dab9b319c..6a592f49a4 100644 --- a/tasks/tasks_internal.h +++ b/tasks/tasks_internal.h @@ -219,11 +219,6 @@ bool task_push_manual_content_scan( bool task_push_overlay_load_default( retro_task_callback_t cb, const char *overlay_path, - bool overlay_hide_in_menu, - bool overlay_hide_when_gamepad_connected, - bool input_overlay_enable, - float input_overlay_opacity, - overlay_layout_desc_t *layout_desc, void *user_data); #endif