libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-11-29 03:00:24 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
d9409e071f
RetroArch/menu/drivers/glui.c
Jean-André Santoni d9409e071f (GLUI) Animate keyboard navigation
2015-04-20 21:22:55 +07:00

727 lines
19 KiB
C
Raw Blame History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2011-2015 - Daniel De Matteis
* Copyright (C) 2014-2015 - Jean-André Santoni
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "../menu.h"
#include "../../runloop_data.h"
#include <file/file_path.h>
#include "../../gfx/drivers/gl_common.h"
#include "../../gfx/font_driver.h"
#include "../../gfx/video_texture.h"
#include <compat/posix_string.h>
#include "shared.h"
typedef struct glui_handle
{
unsigned line_height;
unsigned margin;
unsigned ticker_limit;
char box_message[PATH_MAX_LENGTH];
struct
{
struct
{
GLuint id;
char path[PATH_MAX_LENGTH];
} bg;
} textures;
gl_font_raster_block_t list_block;
bool use_blocks;
} glui_handle_t;
static int glui_entry_iterate(unsigned action)
{
const char *label = NULL;
menu_file_list_cbs_t *cbs = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
runloop_t *runloop = rarch_main_get_ptr();
if (!menu || !runloop)
return -1;
if (action != MENU_ACTION_NOOP || menu->need_refresh ||
runloop->frames.video.current.menu.label.is_updated ||
runloop->frames.video.current.menu.animation.is_active)
{
runloop->frames.video.current.menu.framebuf.dirty = true;
}
cbs = (menu_file_list_cbs_t*)menu_list_get_actiondata_at_offset(
menu->menu_list->selection_buf, menu->navigation.selection_ptr);
menu_list_get_last_stack(menu->menu_list, NULL, &label, NULL);
if (cbs && cbs->action_iterate)
return cbs->action_iterate(label, action);
return -1;
}
static void glui_blit_line(gl_t *gl, float x, float y, const char *message, uint32_t color, enum text_alignment text_align)
{
struct font_params params = {0};
params.x = x / gl->win_width;
params.y = 1.0f - y / gl->win_height;
params.scale = 1.0;
params.color = color;
params.full_screen = true;
params.text_align = text_align;
video_driver_set_osd_msg(message, &params, NULL);
}
static void glui_render_background(settings_t *settings,
gl_t *gl, glui_handle_t *glui,
bool force_transparency)
{
static const GLfloat vertex[] = {
0, 0,
1, 0,
0, 1,
1, 1,
};
static const GLfloat tex_coord[] = {
0, 1,
1, 1,
0, 0,
1, 0,
};
struct gl_coords coords;
float alpha = 0.75f;
GLfloat color[] = {
1.0f, 1.0f, 1.0f, alpha,
1.0f, 1.0f, 1.0f, alpha,
1.0f, 1.0f, 1.0f, alpha,
1.0f, 1.0f, 1.0f, alpha,
};
GLfloat black_color[] = {
0.0f, 0.0f, 0.0f, alpha,
0.0f, 0.0f, 0.0f, alpha,
0.0f, 0.0f, 0.0f, alpha,
0.0f, 0.0f, 0.0f, alpha,
};
global_t *global = global_get_ptr();
glViewport(0, 0, gl->win_width, gl->win_height);
coords.vertices = 4;
coords.vertex = vertex;
coords.tex_coord = tex_coord;
coords.lut_tex_coord = tex_coord;
if ((settings->menu.pause_libretro
|| !global->main_is_init || global->libretro_dummy)
&& !force_transparency
&& glui->textures.bg.id)
{
coords.color = color;
glBindTexture(GL_TEXTURE_2D, glui->textures.bg.id);
}
else
{
coords.color = black_color;
glBindTexture(GL_TEXTURE_2D, 0);
}
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
gl->shader->set_coords(&coords);
gl->shader->set_mvp(gl, &gl->mvp_no_rot);
glEnable(GL_BLEND);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisable(GL_BLEND);
gl->coords.color = gl->white_color_ptr;
}
static void glui_render_quad(gl_t *gl, int x, int y, int w, int h,
float r, float g, float b, float a)
{
static const GLfloat vertex[] = {
0, 0,
1, 0,
0, 1,
1, 1,
};
static const GLfloat tex_coord[] = {
0, 1,
1, 1,
0, 0,
1, 0,
};
struct gl_coords coords;
GLfloat color[] = {
r, g, b, a,
r, g, b, a,
r, g, b, a,
r, g, b, a,
};
glViewport(x, gl->win_height - y - h, w, h);
coords.vertices = 4;
coords.vertex = vertex;
coords.tex_coord = tex_coord;
coords.lut_tex_coord = tex_coord;
coords.color = color;
glBindTexture(GL_TEXTURE_2D, 0);
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
gl->shader->set_coords(&coords);
gl->shader->set_mvp(gl, &gl->mvp_no_rot);
glEnable(GL_BLEND);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisable(GL_BLEND);
gl->coords.color = gl->white_color_ptr;
}
static void glui_draw_cursor(gl_t *gl, float x, float y)
{
glui_render_quad(gl, x-5, y-5, 10, 10, 1, 1, 1, 1);
}
static void glui_get_message(const char *message)
{
glui_handle_t *glui = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return;
if (!message || !*message)
return;
glui = (glui_handle_t*)menu->userdata;
if (glui)
strlcpy(glui->box_message, message, sizeof(glui->box_message));
}
static void glui_render_messagebox(const char *message)
{
unsigned i;
uint32_t normal_color;
int x, y;
struct string_list *list = NULL;
glui_handle_t *glui = NULL;
gl_t *gl = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return;
gl = (gl_t*)video_driver_get_ptr(NULL);
if (!gl)
return;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
list = (struct string_list*)string_split(message, "\n");
if (!list)
return;
if (list->elems == 0)
goto end;
x = gl->win_width / 2;
y = gl->win_height / 2 - list->size * settings->video.font_size / 2;
normal_color = FONT_COLOR_ARGB_TO_RGBA(settings->menu.entry_normal_color);
for (i = 0; i < list->size; i++)
{
const char *msg = list->elems[i].data;
if (msg)
glui_blit_line(gl, x, y + i * settings->video.font_size, msg, normal_color, TEXT_ALIGN_CENTER);
}
end:
string_list_free(list);
}
static void glui_render(void)
{
int bottom;
glui_handle_t *glui = NULL;
gl_t *gl = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
gl = (gl_t*)video_driver_get_ptr(NULL);
if (!gl)
return;
menu_animation_update(menu->animation, menu->dt / IDEAL_DT);
menu->frame_buf.width = gl->win_width;
menu->frame_buf.height = gl->win_height;
if (settings->menu.pointer.enable)
{
menu->pointer.ptr =
(menu->pointer.y - glui->line_height + menu->scroll_y - 16)
/ glui->line_height;
if (menu->pointer.dragging)
menu->scroll_y -= menu->pointer.dy;
}
if (settings->menu.mouse.enable)
{
if (menu->mouse.scrolldown)
menu->scroll_y += 10;
if (menu->mouse.scrollup)
menu->scroll_y -= 10;
menu->mouse.ptr =
(menu->mouse.y - glui->line_height + menu->scroll_y - 16)
/ glui->line_height;
}
if (menu->scroll_y < 0)
menu->scroll_y = 0;
bottom = (menu_list_get_size(menu->menu_list)-1) * glui->line_height
- gl->win_height + menu->header_height * 2;
if (menu->scroll_y > bottom)
menu->scroll_y = bottom;
if ((menu_list_get_size(menu->menu_list)-1) * glui->line_height
< gl->win_height - menu->header_height*2)
menu->scroll_y = 0;
}
static void glui_render_menu_list(runloop_t *runloop, gl_t *gl, glui_handle_t *glui,
menu_handle_t *menu, const char *label, uint32_t normal_color,
uint32_t hover_color)
{
const struct font_renderer *font_driver = (const struct font_renderer *)gl->font_driver;
size_t i = 0;
if (glui->use_blocks)
font_driver->bind_block(gl->font_handle, &glui->list_block);
if (!menu_display_update_pending())
goto draw_text;
glui->list_block.carr.coords.vertices = 0;
for (i = 0; i < menu_list_get_size(menu->menu_list); i++)
{
char message[PATH_MAX_LENGTH], type_str[PATH_MAX_LENGTH],
entry_title_buf[PATH_MAX_LENGTH], type_str_buf[PATH_MAX_LENGTH],
path_buf[PATH_MAX_LENGTH];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_file_list_cbs_t *cbs = NULL;
menu_list_get_at_offset(menu->menu_list->selection_buf, i, &path,
&entry_label, &type);
cbs = (menu_file_list_cbs_t*)
menu_list_get_actiondata_at_offset(menu->menu_list->selection_buf, i);
if (cbs && cbs->action_get_representation)
cbs->action_get_representation(menu->menu_list->selection_buf,
&w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == menu->navigation.selection_ptr);
menu_animation_ticker_line(entry_title_buf, glui->ticker_limit,
runloop->frames.video.count / 100, path_buf, selected);
menu_animation_ticker_line(type_str_buf, glui->ticker_limit,
runloop->frames.video.count / 100, type_str, selected);
strlcpy(message, entry_title_buf, sizeof(message));
unsigned y = menu->header_height - menu->scroll_y + (glui->line_height * i);
glui_blit_line(gl, glui->margin, y, message,
selected ? hover_color : normal_color, TEXT_ALIGN_LEFT);
glui_blit_line(gl, gl->win_width - glui->margin, y, type_str_buf,
selected ? hover_color : normal_color, TEXT_ALIGN_RIGHT);
}
draw_text:
if (glui->use_blocks)
{
font_driver->flush(gl->font_handle);
font_driver->bind_block(gl->font_handle, NULL);
}
}
static void glui_frame(void)
{
char title[PATH_MAX_LENGTH], title_buf[PATH_MAX_LENGTH],
title_msg[PATH_MAX_LENGTH];
char timedate[PATH_MAX_LENGTH];
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
gl_t *gl = NULL;
glui_handle_t *glui = NULL;
const char *core_name = NULL;
const char *core_version = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
const uint32_t normal_color = FONT_COLOR_ARGB_TO_RGBA(settings->menu.entry_normal_color);
const uint32_t hover_color = FONT_COLOR_ARGB_TO_RGBA(settings->menu.entry_hover_color);
const uint32_t title_color = FONT_COLOR_ARGB_TO_RGBA(settings->menu.title_color);
runloop_t *runloop = rarch_main_get_ptr();
global_t *global = global_get_ptr();
if (!menu)
return;
gl = (gl_t*)video_driver_get_ptr(NULL);
if (!gl)
return;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
if (menu->need_refresh
&& runloop->is_menu
&& !menu->msg_force)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, true, false);
glui_render_background(settings, gl, glui, false);
menu_list_get_last_stack(menu->menu_list, &dir, &label, &menu_type);
get_title(label, dir, menu_type, title, sizeof(title));
glui_render_quad(gl, 0,
menu->header_height - menu->scroll_y + glui->line_height *
menu->navigation.selection_ptr - glui->line_height / 2 - 4,
gl->win_width, glui->line_height, 1, 1, 1, 0.1);
glui_render_menu_list(runloop, gl, glui, menu, label, normal_color, hover_color);
runloop->frames.video.current.menu.animation.is_active = false;
runloop->frames.video.current.menu.label.is_updated = false;
runloop->frames.video.current.menu.framebuf.dirty = false;
glui_render_quad(gl, 0, 0, gl->win_width,
menu->header_height - glui->line_height/2 - 4, 0.2, 0.2, 0.2, 1);
menu_animation_ticker_line(title_buf, glui->ticker_limit,
runloop->frames.video.count / 100, title, true);
glui_blit_line(gl, gl->win_width/2, glui->line_height, title_buf, title_color, TEXT_ALIGN_CENTER);
if (file_list_get_size(menu->menu_list->menu_stack) > 1)
glui_blit_line(gl, glui->margin, glui->line_height, "BACK", title_color, TEXT_ALIGN_LEFT);
glui_render_quad(gl, 0,
gl->win_height - (menu->header_height - glui->line_height/2 + 4),
gl->win_width, menu->header_height - glui->line_height/2 + 4,
0.2, 0.2, 0.2, 1);
core_name = global->menu.info.library_name;
if (!core_name)
core_name = global->system.info.library_name;
if (!core_name)
core_name = "No Core";
if (settings->menu.core_enable)
{
core_version = global->menu.info.library_version;
if (!core_version)
core_version = global->system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title_msg, sizeof(title_msg), "%s - %s %s", PACKAGE_VERSION,
core_name, core_version);
glui_blit_line(gl, glui->margin, gl->win_height - glui->line_height, title_msg,
title_color, TEXT_ALIGN_LEFT);
}
if (settings->menu.timedate_enable)
{
disp_timedate_set_label(timedate, sizeof(timedate), 0);
glui_blit_line(gl, gl->win_width - glui->margin,
gl->win_height - glui->line_height, timedate, hover_color,
TEXT_ALIGN_RIGHT);
}
if (menu->keyboard.display)
{
char msg[PATH_MAX_LENGTH];
const char *str = *menu->keyboard.buffer;
if (!str)
str = "";
glui_render_background(settings, gl, glui, true);
snprintf(msg, sizeof(msg), "%s\n%s", menu->keyboard.label, str);
glui_render_messagebox(msg);
}
if (glui->box_message[0] != '\0')
{
glui_render_background(settings, gl, glui, true);
glui_render_messagebox(glui->box_message);
glui->box_message[0] = '\0';
}
if (settings->menu.mouse.enable)
glui_draw_cursor(gl, menu->mouse.x, menu->mouse.y);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static void *glui_init(void)
{
glui_handle_t *glui = NULL;
const video_driver_t *video_driver = NULL;
const struct font_renderer *font_driver = NULL;
menu_handle_t *menu = NULL;
gl_t *gl = (gl_t*)video_driver_get_ptr(&video_driver);
settings_t *settings = config_get_ptr();
if (video_driver != &video_gl || !gl)
{
RARCH_ERR("Cannot initialize GLUI menu driver: gl video driver is not active.\n");
return NULL;
}
font_driver = (const struct font_renderer*)gl->font_driver;
menu = (menu_handle_t*)calloc(1, sizeof(*menu));
if (!menu)
goto error;
menu->userdata = (glui_handle_t*)calloc(1, sizeof(glui_handle_t));
if (!menu->userdata)
goto error;
glui = (glui_handle_t*)menu->userdata;
glui->line_height = 44;
glui->margin = 22;
glui->ticker_limit = 44;
menu->header_height = 88;
glui->textures.bg.id = 0;
if (font_driver->bind_block && font_driver->flush)
glui->use_blocks = true;
rarch_main_data_msg_queue_push(DATA_TYPE_IMAGE, settings->menu.wallpaper, "cb_menu_wallpaper", 0, 1, true);
return menu;
error:
if (menu)
free(menu);
return NULL;
}
static void glui_free(void *data)
{
gl_t *gl = (gl_t*)video_driver_get_ptr(NULL);
const struct font_renderer *font_driver = NULL;
menu_handle_t *menu = (menu_handle_t*)data;
glui_handle_t *glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
gl_coord_array_free(&glui->list_block.carr);
font_driver = (const struct font_renderer*)gl->font_driver;
if (glui->use_blocks)
font_driver->bind_block(gl->font_handle, NULL);
if (menu->alloc_font)
free((uint8_t*)menu->font);
if (menu->userdata)
free(menu->userdata);
}
static void glui_context_destroy(void)
{
glui_handle_t *glui = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
if (glui->textures.bg.id)
glDeleteTextures(1, &glui->textures.bg.id);
}
static bool glui_load_wallpaper(void *data)
{
glui_handle_t *glui = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return false;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return false;
if (glui->textures.bg.id)
glDeleteTextures(1, &glui->textures.bg.id);
glui->textures.bg.id = video_texture_load(data,
TEXTURE_BACKEND_OPENGL, TEXTURE_FILTER_MIPMAP_LINEAR);
return true;
}
static void glui_navigation_clear(bool pending_push)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return;
menu->begin = 0;
menu_animation_push(menu->animation, 10, 0,
&menu->scroll_y, EASING_IN_OUT_QUAD, NULL);
}
static void glui_navigation_set(bool scroll)
{
glui_handle_t *glui = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
gl_t *gl = (gl_t*)video_driver_get_ptr(NULL);
float sy = 0;
if (!menu)
return;
glui = (glui_handle_t*)menu->userdata;
if (!glui)
return;
if (!scroll)
return;
int half = (gl->win_height / glui->line_height) / 2;
if (menu->navigation.selection_ptr < half)
sy = 0;
else
sy = ((menu->navigation.selection_ptr + 2 - half) * glui->line_height);
menu_animation_push(menu->animation, 10, sy,
&menu->scroll_y, EASING_IN_OUT_QUAD, NULL);
}
static void glui_navigation_set_last(void)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
glui_navigation_set(true);
}
static void glui_navigation_descend_alphabet(size_t *unused)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
glui_navigation_set(true);
}
static void glui_navigation_ascend_alphabet(size_t *unused)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
glui_navigation_set(true);
}
menu_ctx_driver_t menu_ctx_glui = {
NULL,
glui_get_message,
glui_render,
glui_frame,
glui_init,
glui_free,
NULL,
glui_context_destroy,
NULL,
NULL,
glui_navigation_clear,
NULL,
NULL,
glui_navigation_set,
glui_navigation_set_last,
glui_navigation_descend_alphabet,
glui_navigation_ascend_alphabet,
NULL,
NULL,
NULL,
NULL,
NULL,
glui_entry_iterate,
glui_load_wallpaper,
"glui",
};
Reference in New Issue View Git Blame Copy Permalink