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