自学教程：C++ video_driver_get_ptr函数代码示例

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

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