static void *menu_display_vk_get_default_mvp(void)
{
vk_t *vk = (vk_t*)video_driver_get_ptr(false);
if (!vk)
return NULL;
return &vk->mvp_no_rot;
}
static void menu_display_d3d_restore_clear_color(void)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
DWORD clear_color = 0x00000000;
d3d_clear(d3d->dev, 0, NULL, D3DCLEAR_TARGET, clear_color, 0, 0);
}
static gl_t *gl_get_ptr(void)
{
gl_t *gl = (gl_t*)video_driver_get_ptr(false);
if (!gl)
return NULL;
return gl;
}
static void menu_display_d3d_clear_color(float r, float g, float b, float a)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
DWORD clear_color = D3DCOLOR_ARGB(BYTE_CLAMP(a * 255.0f), BYTE_CLAMP(r * 255.0f), BYTE_CLAMP(g * 255.0f), BYTE_CLAMP(b * 255.0f));
d3d_clear(d3d->dev, 0, NULL, D3DCLEAR_TARGET, clear_color, 0, 0);
}
static void menu_display_d3d_draw(void *data)
{
#if 0
math_matrix_4x4 *mat = NULL;
#endif
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw)
return;
if (!draw->coords->vertex)
draw->coords->vertex = menu_display_d3d_get_default_vertices();
if (!draw->coords->tex_coord)
draw->coords->tex_coord = menu_display_d3d_get_default_tex_coords();
if (!draw->coords->lut_tex_coord)
draw->coords->lut_tex_coord = menu_display_d3d_get_default_tex_coords();
menu_display_d3d_viewport(draw);
menu_display_d3d_bind_texture(draw);
#if 0
mat = (math_matrix_4x4*)draw->matrix_data;
if (!mat)
mat = (math_matrix_4x4*)
menu_display_d3d_get_default_mvp();
video_shader_driver_set_coords(d3d, draw->coords);
video_shader_driver_set_mvp(d3d, mat);
#endif
d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)
menu_display_prim_to_d3d_enum(draw->prim_type),
0, draw->coords->vertices);
}
bool menu_display_init_main_font(void *data,
const char *font_path, float font_size)
{
bool ret;
driver_t *driver = driver_get_ptr();
void *video = video_driver_get_ptr(NULL);
menu_display_t *disp = menu_display_get_ptr();
if (!disp)
return false;
if (disp->font.buf)
menu_display_free_main_font();
ret = menu_display_font_init_first(
(const void**)&driver->font_osd_driver,
&disp->font.buf, video,
font_path, font_size);
if (ret)
disp->font.size = font_size;
else
disp->font.buf = NULL;
return ret;
}
static void *glui_init(void)
{
glui_handle_t *glui = NULL;
const video_driver_t *video_driver = NULL;
menu_handle_t *menu = NULL;
gl_t *gl = (gl_t*)
video_driver_get_ptr(&video_driver);
if (video_driver != &video_gl || !gl)
{
RARCH_ERR("Cannot initialize GLUI menu driver: gl video driver is not active.\n");
return NULL;
}
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_layout(menu, glui);
glui_allocate_white_texture(glui);
return menu;
error:
if (menu)
free(menu);
return NULL;
}
void shader_dlg_show(HWND parent_hwnd)
{
const video_driver_t* vid_drv;
video_driver_get_ptr(&vid_drv);
if(vid_drv != &video_gl)
return;
if (!IsWindowVisible(g_shader_dlg.hwnd))
{
if (parent_hwnd)
{
RECT parent_rect;
GetWindowRect(parent_hwnd, &parent_rect);
SetWindowPos(g_shader_dlg.hwnd, HWND_TOP, parent_rect.right, parent_rect.top,
0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
}
else
ShowWindow(g_shader_dlg.hwnd, SW_SHOW);
shader_dlg_update_on_top_state();
shader_dlg_params_reload();
}
SetFocus(g_shader_dlg.hwnd);
}
/* task_data = overlay_task_data_t* */
void input_overlay_loaded(void *task_data, void *user_data, const char *err)
{
size_t i;
overlay_task_data_t *data = (overlay_task_data_t*)task_data;
settings_t *settings = config_get_ptr();
input_overlay_t *ol = NULL;
const video_overlay_interface_t *iface = NULL;
if (err)
return;
#ifdef HAVE_MENU
/* We can't display when the menu is up */
if (settings->input.overlay_hide_in_menu && menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (!input_driver_is_onscreen_keyboard_enabled() && settings->input.overlay_enable)
goto abort_load;
}
#endif
if (!settings->input.overlay_enable)
goto abort_load;
if (!video_driver_overlay_interface(&iface) || !iface)
{
RARCH_ERR("Overlay interface is not present in video driver.\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_driver_get_ptr(true);
input_overlay_load_active(ol, settings->input.overlay_opacity);
if (input_driver_is_onscreen_keyboard_enabled())
input_overlay_enable(ol, settings->osk.enable);
else
input_overlay_enable(ol, settings->input.overlay_enable);
input_overlay_set_scale_factor(ol, settings->input.overlay_scale);
ol->next_index = (ol->index + 1) % ol->size;
ol->state = OVERLAY_STATUS_NONE;
ol->alive = true;
overlay_ptr = ol;
free(data);
return;
abort_load:
for (i = 0; i < data->size; i++)
input_overlay_free_overlay(&data->overlays[i]);
free(data->overlays);
free(data);
}
static d3d_video_t *d3d_get_ptr(void)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
if (!d3d)
return NULL;
return d3d;
}
static void menu_display_d3d_draw_bg(
unsigned width,
unsigned height,
uintptr_t texture,
float handle_alpha,
bool force_transparency,
float *coord_color,
float *coord_color2,
const float *vertex,
const float *tex_coord,
size_t vertex_count,
enum menu_display_prim_type prim_type)
{
struct gfx_coords coords;
const float *new_vertex = NULL;
const float *new_tex_coord = NULL;
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
if (!d3d)
return;
new_vertex = vertex;
new_tex_coord = tex_coord;
if (!new_vertex)
new_vertex = &d3d_vertexes[0];
if (!new_tex_coord)
new_tex_coord = &d3d_tex_coords[0];
coords.vertices = vertex_count;
coords.vertex = new_vertex;
coords.tex_coord = new_tex_coord;
coords.lut_tex_coord = new_tex_coord;
coords.color = (const float*)coord_color;
menu_display_d3d_blend_begin();
menu_display_ctl(MENU_DISPLAY_CTL_SET_VIEWPORT, NULL);
if ((settings->menu.pause_libretro
|| !global->inited.main || (global->inited.core.type == CORE_TYPE_DUMMY))
&& !force_transparency
&& texture)
coords.color = (const float*)coord_color2;
menu_display_d3d_draw(0, 0, width, height,
&coords, (math_matrix_4x4*)menu_display_d3d_get_default_mvp(),
(uintptr_t)texture, prim_type);
menu_display_d3d_blend_end();
#if 0
gl->coords.color = gl->white_color_ptr;
#endif
}
static void *menu_display_d3d_get_default_mvp(void)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
if (!d3d)
return NULL;
return NULL; /* TODO/FIXME */
}
static void menu_display_gl_viewport(void *data)
{
gl_t *gl = (gl_t*)video_driver_get_ptr(false);
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!gl || !draw)
return;
glViewport(draw->x, draw->y, draw->width, draw->height);
}
static void menu_display_d3d_blend_end(void)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
if (!d3d)
return;
d3d_disable_blend_func(d3d->dev);
}
static void *menu_display_gl_get_default_mvp(void)
{
gl_t *gl = (gl_t*)video_driver_get_ptr(false);
if (!gl)
return NULL;
return &gl->mvp_no_rot;
}
const char *video_thread_get_ident(void)
{
const thread_video_t *thr = (const thread_video_t*)
video_driver_get_ptr(true);
if (!thr || !thr->driver)
return NULL;
return thr->driver->ident;
}
struct video_shader *video_shader_driver_get_current_shader(void)
{
void *video_driver = video_driver_get_ptr(false);
const video_poke_interface_t *video_poke = video_driver_get_poke();
if (!video_poke || !video_driver)
return NULL;
if (!video_poke->get_current_shader)
return NULL;
return video_poke->get_current_shader(video_driver);
}
static void menu_display_d3d_bind_texture(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw)
return;
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);
}
/**
* video_thread_get_ptr:
* @drv : Found driver.
*
* Gets the underlying video driver associated with the
* threaded video wrapper. Sets @drv to the found
* video driver.
*
* Returns: Video driver data of the video driver associated
* with the threaded wrapper (if successful). If not successful,
* NULL.
**/
void *video_thread_get_ptr(const video_driver_t **drv)
{
const thread_video_t *thr = (const thread_video_t*)
video_driver_get_ptr(true);
if (drv)
*drv = thr->driver;
if (!thr)
return NULL;
return thr->driver_data;
}
static bool shader_null_set_mvp(void *data, const math_matrix_4x4 *mat)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
gl_t *gl = (gl_t*)video_driver_get_ptr(NULL);
if (gl)
{
gl_ff_matrix(mat);
}
#endif
#endif
return false;
}
static void driver_adjust_system_rates(void)
{
audio_driver_monitor_adjust_system_rates();
video_driver_monitor_adjust_system_rates();
if (!video_driver_get_ptr(false))
return;
if (rarch_ctl(RARCH_CTL_IS_NONBLOCK_FORCED, NULL))
command_event(CMD_EVENT_VIDEO_SET_NONBLOCKING_STATE, NULL);
else
driver_set_nonblock_state();
}
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader)
{
void *video_driver = video_driver_get_ptr(true);
const video_poke_interface_t *video_poke = video_driver_get_poke();
shader->data = NULL;
if (!video_poke || !video_driver)
return false;
if (!video_poke->get_current_shader)
return false;
shader->data = video_poke->get_current_shader(video_driver);
return true;
}
static void driver_adjust_system_rates(void)
{
audio_driver_monitor_adjust_system_rates();
video_driver_monitor_adjust_system_rates();
if (!video_driver_get_ptr(false))
return;
if (runloop_ctl(RUNLOOP_CTL_IS_NONBLOCK_FORCED, NULL))
command_event(CMD_EVENT_VIDEO_SET_NONBLOCKING_STATE, NULL);
else
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
}
static void menu_display_d3d_draw(
unsigned x, unsigned y,
unsigned width, unsigned height,
struct gfx_coords *coords,
void *matrix_data,
uintptr_t texture,
enum menu_display_prim_type prim_type
)
{
D3DVIEWPORT vp = {0};
driver_t *driver = driver_get_ptr();
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
math_matrix_4x4 *mat = (math_matrix_4x4*)matrix_data;
if (!d3d)
return;
/* TODO - edge case */
if (height <= 0)
height = 1;
if (!mat)
mat = (math_matrix_4x4*)menu_display_d3d_get_default_mvp();
if (!coords->vertex)
coords->vertex = &d3d_vertexes[0];
if (!coords->tex_coord)
coords->tex_coord = &d3d_tex_coords[0];
if (!coords->lut_tex_coord)
coords->lut_tex_coord = &d3d_tex_coords[0];
vp.X = x;
vp.Y = y;
vp.Width = width;
vp.Height = height;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
d3d_set_viewport(d3d->dev, &vp);
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)texture);
#if 0
gl->shader->set_coords(coords);
gl->shader->set_mvp(driver->video_data, mat);
#endif
d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)menu_display_prim_to_d3d_enum(prim_type), 0, coords->vertices);
#if 0
gl->coords.color = gl->white_color_ptr;
#endif
}
static bool shader_null_set_coords(const void *data)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
gl_t *gl = (gl_t*)video_driver_get_ptr(NULL);
if (gl)
{
const struct gfx_coords *coords = (const struct gfx_coords*)data;
gl_ff_vertex(coords);
}
#endif
#endif
return false;
}
static void menu_display_d3d_blend_begin(void)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
if (!d3d)
return;
d3d_enable_blend_func(d3d->dev);
#if 0
if (gl->shader && gl->shader->use)
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
#endif
}
static void menu_display_d3d_bind_texture(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw)
return;
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);
d3d_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_BORDER);
d3d_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_BORDER);
d3d_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_LINEAR);
d3d_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_LINEAR);
}
static void menu_display_vk_viewport(void *data)
{
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
vk_t *vk = (vk_t*)video_driver_get_ptr(false);
if (!vk || !draw)
return;
vk->vk_vp.x = draw->x;
vk->vk_vp.y = vk->context->swapchain_height - draw->y - draw->height;
vk->vk_vp.width = draw->width;
vk->vk_vp.height = draw->height;
vk->vk_vp.minDepth = 0.0f;
vk->vk_vp.maxDepth = 1.0f;
}
static void sdl_grab_mouse(void *data, bool state)
{
#ifdef HAVE_SDL2
struct temp{
SDL_Window *w;
};
if (!string_is_equal(video_driver_get_ident(), "sdl2"))
return;
/* First member of sdl2_video_t is the window */
SDL_SetWindowGrab(((struct temp*)video_driver_get_ptr(false))->w,
state ? SDL_TRUE : SDL_FALSE);
#endif
}
static void *glui_init(void)
{
float dpi;
glui_handle_t *glui = NULL;
const video_driver_t *video_driver = NULL;
menu_handle_t *menu = NULL;
settings_t *settings = config_get_ptr();
gl_t *gl = (gl_t*)
video_driver_get_ptr(&video_driver);
if (video_driver != &video_gl || !gl)
{
RARCH_ERR("Cannot initialize GLUI menu driver: gl video driver is not active.\n");
return NULL;
}
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;
dpi = menu_display_get_dpi();
glui->line_height = dpi / 3;
glui->margin = dpi / 6;
glui->ticker_limit = dpi / 3;
menu->display.header_height = dpi / 3;
menu->display.font.size = dpi / 8;
glui->textures.bg.id = 0;
glui_allocate_white_texture(glui);
if (settings->menu.wallpaper[0] != '\0')
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;
}
