mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-07 03:40:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Uniquely name D3D9

Browse Source
This commit is contained in:
twinaphex 2018-01-23 06:43:03 +01:00
parent f1c5812ff8
commit 93523782e5
1 changed files with 123 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
gfx/drivers/d3d9.c
View File

@ -55,9 +55,9 @@
#include "../../defines/d3d_defines.h" #include "../../defines/d3d_defines.h"
#include "../../verbosity.h" #include "../../verbosity.h"
static LPDIRECT3D g_pD3D; static LPDIRECT3D g_pD3D9;
static bool d3d_init_imports(d3d_video_t *d3d) static bool d3d9_init_imports(d3d_video_t *d3d)
{ {
retro_ctx_memory_info_t mem_info; retro_ctx_memory_info_t mem_info;
state_tracker_t *state_tracker = NULL; state_tracker_t *state_tracker = NULL;
@ -103,7 +103,7 @@ static bool d3d_init_imports(d3d_video_t *d3d)
return true; return true;
} }
static bool d3d_init_chain(d3d_video_t *d3d, const video_info_t *video_info) static bool d3d9_init_chain(d3d_video_t *d3d, const video_info_t *video_info)
{ {
struct LinkInfo link_info; struct LinkInfo link_info;
unsigned current_width, current_height, out_width, out_height; unsigned current_width, current_height, out_width, out_height;
@ -199,7 +199,7 @@ static bool d3d_init_chain(d3d_video_t *d3d, const video_info_t *video_info)
if (d3d->renderchain_driver->add_state_tracker) if (d3d->renderchain_driver->add_state_tracker)
{ {
if (!d3d_init_imports(d3d)) if (!d3d9_init_imports(d3d))
{ {
RARCH_ERR("[D3D]: Failed to init imports.\n"); RARCH_ERR("[D3D]: Failed to init imports.\n");
return false; return false;
@ -210,7 +210,7 @@ static bool d3d_init_chain(d3d_video_t *d3d, const video_info_t *video_info)
return true; return true;
} }
static bool d3d_init_singlepass(d3d_video_t *d3d) static bool d3d9_init_singlepass(d3d_video_t *d3d)
{ {
struct video_shader_pass *pass = NULL; struct video_shader_pass *pass = NULL;
@ -236,7 +236,7 @@ static bool d3d_init_singlepass(d3d_video_t *d3d)
return true; return true;
} }
static bool d3d_init_multipass(d3d_video_t *d3d, const char *shader_path) static bool d3d9_init_multipass(d3d_video_t *d3d, const char *shader_path)
{ {
unsigned i; unsigned i;
bool use_extra_pass = false; bool use_extra_pass = false;
@ -304,17 +304,17 @@ static bool d3d_init_multipass(d3d_video_t *d3d, const char *shader_path)
return true; return true;
} }
static bool d3d_process_shader(d3d_video_t *d3d) static bool d3d9_process_shader(d3d_video_t *d3d)
{ {
const char *shader_path = d3d->shader_path; const char *shader_path = d3d->shader_path;
if (d3d && !string_is_empty(shader_path) && if (d3d && !string_is_empty(shader_path) &&
string_is_equal(path_get_extension(shader_path), "cgp")) string_is_equal(path_get_extension(shader_path), "cgp"))
return d3d_init_multipass(d3d, shader_path); return d3d9_init_multipass(d3d, shader_path);
return d3d_init_singlepass(d3d); return d3d9_init_singlepass(d3d);
} }
static void d3d_viewport_info(void *data, struct video_viewport *vp) static void d3d9_viewport_info(void *data, struct video_viewport *vp)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -324,7 +324,7 @@ static void d3d_viewport_info(void *data, struct video_viewport *vp)
d3d->renderchain_driver->viewport_info(d3d, vp); d3d->renderchain_driver->viewport_info(d3d, vp);
} }
static void d3d_set_mvp(void *data, static void d3d9_set_mvp(void *data,
void *shader_data, void *shader_data,
const void *mat_data) const void *mat_data)
{ {
@ -336,7 +336,7 @@ static void d3d_set_mvp(void *data,
d3d->renderchain_driver->set_mvp(d3d, d3d->renderchain_data, shader_data, mat_data); d3d->renderchain_driver->set_mvp(d3d, d3d->renderchain_data, shader_data, mat_data);
} }
static void d3d_overlay_render(d3d_video_t *d3d, static void d3d9_overlay_render(d3d_video_t *d3d,
video_frame_info_t *video_info, video_frame_info_t *video_info,
overlay_t *overlay) overlay_t *overlay)
{ {
@ -375,7 +375,7 @@ static void d3d_overlay_render(d3d_video_t *d3d,
vert[i].color = (((uint32_t)(overlay->alpha_mod * 0xFF)) << 24) | 0xFFFFFF; vert[i].color = (((uint32_t)(overlay->alpha_mod * 0xFF)) << 24) | 0xFFFFFF;
} }
d3d_viewport_info(d3d, &vp); d3d9_viewport_info(d3d, &vp);
vert[0].x = overlay->vert_coords[0]; vert[0].x = overlay->vert_coords[0];
vert[1].x = overlay->vert_coords[0] + overlay->vert_coords[2]; vert[1].x = overlay->vert_coords[0] + overlay->vert_coords[2];
@ -435,7 +435,7 @@ static void d3d_overlay_render(d3d_video_t *d3d,
d3d_set_viewports(d3d->dev, &d3d->final_viewport); d3d_set_viewports(d3d->dev, &d3d->final_viewport);
} }
static void d3d_free_overlay(d3d_video_t *d3d, overlay_t *overlay) static void d3d9_free_overlay(d3d_video_t *d3d, overlay_t *overlay)
{ {
if (!d3d) if (!d3d)
return; return;
@ -481,7 +481,7 @@ static D3DFORMAT d3d_get_color_format_backbuffer(bool rgb32, bool windowed)
if (windowed) if (windowed)
{ {
D3DDISPLAYMODE display_mode; D3DDISPLAYMODE display_mode;
if (d3d_get_adapter_display_mode(g_pD3D, 0, &display_mode)) if (d3d_get_adapter_display_mode(g_pD3D9, 0, &display_mode))
fmt = display_mode.Format; fmt = display_mode.Format;
} }
#endif #endif
@ -595,7 +595,7 @@ void d3d_make_d3dpp(void *data,
#endif #endif
} }
static bool d3d_init_base(void *data, const video_info_t *info) static bool d3d9_init_base(void *data, const video_info_t *info)
{ {
D3DPRESENT_PARAMETERS d3dpp; D3DPRESENT_PARAMETERS d3dpp;
HWND focus_window = NULL; HWND focus_window = NULL;
@ -607,19 +607,19 @@ static bool d3d_init_base(void *data, const video_info_t *info)
memset(&d3dpp, 0, sizeof(d3dpp)); memset(&d3dpp, 0, sizeof(d3dpp));
g_pD3D = (LPDIRECT3D)d3d_create(); g_pD3D9 = (LPDIRECT3D)d3d_create();
/* this needs g_pD3D created first */ /* this needs g_pD3D9 created first */
d3d_make_d3dpp(d3d, info, &d3dpp); d3d_make_d3dpp(d3d, info, &d3dpp);
if (!g_pD3D) if (!g_pD3D9)
{ {
RARCH_ERR("[D3D]: Failed to create D3D interface.\n"); RARCH_ERR("[D3D]: Failed to create D3D interface.\n");
return false; return false;
} }
if (!d3d_create_device(&d3d->dev, &d3dpp, if (!d3d_create_device(&d3d->dev, &d3dpp,
g_pD3D, g_pD3D9,
focus_window, focus_window,
d3d->cur_mon_id) d3d->cur_mon_id)
) )
@ -717,7 +717,7 @@ static void d3d_calculate_rect(void *data,
} }
} }
static void d3d_set_viewport(void *data, static void d3d9_set_viewport(void *data,
unsigned width, unsigned height, unsigned width, unsigned height,
bool force_full, bool force_full,
bool allow_rotate) bool allow_rotate)
@ -749,7 +749,7 @@ static void d3d_set_viewport(void *data,
d3d->renderchain_driver->set_font_rect(d3d, NULL); d3d->renderchain_driver->set_font_rect(d3d, NULL);
} }
static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info) static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
{ {
unsigned width, height; unsigned width, height;
bool ret = true; bool ret = true;
@ -758,8 +758,8 @@ static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info)
if (!d3d) if (!d3d)
return false; return false;
if (!g_pD3D) if (!g_pD3D9)
ret = d3d_init_base(d3d, info); ret = d3d9_init_base(d3d, info);
else if (d3d->needs_restore) else if (d3d->needs_restore)
{ {
D3DPRESENT_PARAMETERS d3dpp; D3DPRESENT_PARAMETERS d3dpp;
@ -775,10 +775,10 @@ static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info)
if (!d3d_reset(d3d->dev, &d3dpp)) if (!d3d_reset(d3d->dev, &d3dpp))
{ {
d3d_deinitialize(d3d); d3d_deinitialize(d3d);
d3d_device_free(NULL, g_pD3D); d3d_device_free(NULL, g_pD3D9);
g_pD3D = NULL; g_pD3D9 = NULL;
ret = d3d_init_base(d3d, info); ret = d3d9_init_base(d3d, info);
if (ret) if (ret)
RARCH_LOG("[D3D]: Recovered from dead state.\n"); RARCH_LOG("[D3D]: Recovered from dead state.\n");
} }
@ -788,14 +788,14 @@ static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info)
if (!ret) if (!ret)
return ret; return ret;
if (!d3d_init_chain(d3d, info)) if (!d3d9_init_chain(d3d, info))
{ {
RARCH_ERR("[D3D]: Failed to initialize render chain.\n"); RARCH_ERR("[D3D]: Failed to initialize render chain.\n");
return false; return false;
} }
video_driver_get_size(&width, &height); video_driver_get_size(&width, &height);
d3d_set_viewport(d3d, d3d9_set_viewport(d3d,
width, height, false, true); width, height, false, true);
#ifdef _XBOX #ifdef _XBOX
@ -839,7 +839,7 @@ static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info)
return true; return true;
} }
static bool d3d_restore(void *data) static bool d3d9_restore(void *data)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -848,7 +848,7 @@ static bool d3d_restore(void *data)
d3d_deinitialize(d3d); d3d_deinitialize(d3d);
if (!d3d_initialize(d3d, &d3d->video_info)) if (!d3d9_initialize(d3d, &d3d->video_info))
{ {
RARCH_ERR("[D3D]: Restore error.\n"); RARCH_ERR("[D3D]: Restore error.\n");
return false; return false;
@ -860,7 +860,7 @@ static bool d3d_restore(void *data)
} }
static void d3d_set_nonblock_state(void *data, bool state) static void d3d9_set_nonblock_state(void *data, bool state)
{ {
unsigned interval = state ? 0 : 1; unsigned interval = state ? 0 : 1;
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -873,11 +873,11 @@ static void d3d_set_nonblock_state(void *data, bool state)
video_context_driver_swap_interval(&interval); video_context_driver_swap_interval(&interval);
#ifndef _XBOX #ifndef _XBOX
d3d->needs_restore = true; d3d->needs_restore = true;
d3d_restore(d3d); d3d9_restore(d3d);
#endif #endif
} }
static bool d3d_alive(void *data) static bool d3d9_alive(void *data)
{ {
gfx_ctx_size_t size_data; gfx_ctx_size_t size_data;
unsigned temp_width = 0; unsigned temp_width = 0;
@ -904,7 +904,7 @@ static bool d3d_alive(void *data)
{ {
d3d->should_resize = true; d3d->should_resize = true;
video_driver_set_resize(temp_width, temp_height); video_driver_set_resize(temp_width, temp_height);
d3d_restore(d3d); d3d9_restore(d3d);
} }
ret = !quit; ret = !quit;
@ -916,13 +916,13 @@ static bool d3d_alive(void *data)
return ret; return ret;
} }
static bool d3d_suppress_screensaver(void *data, bool enable) static bool d3d9_suppress_screensaver(void *data, bool enable)
{ {
bool enabled = enable; bool enabled = enable;
return video_context_driver_suppress_screensaver(&enabled); return video_context_driver_suppress_screensaver(&enabled);
} }
static void d3d_set_aspect_ratio(void *data, unsigned aspect_ratio_idx) static void d3d9_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -954,14 +954,14 @@ static void d3d_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
d3d->should_resize = true; d3d->should_resize = true;
} }
static void d3d_apply_state_changes(void *data) static void d3d9_apply_state_changes(void *data)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
if (d3d) if (d3d)
d3d->should_resize = true; d3d->should_resize = true;
} }
static void d3d_set_osd_msg(void *data, static void d3d9_set_osd_msg(void *data,
video_frame_info_t *video_info, video_frame_info_t *video_info,
const char *msg, const char *msg,
const void *params, void *font) const void *params, void *font)
@ -974,7 +974,7 @@ static void d3d_set_osd_msg(void *data,
font_driver_render_msg(video_info, font, msg, params); font_driver_render_msg(video_info, font, msg, params);
} }
static bool d3d_init_internal(d3d_video_t *d3d, static bool d3d9_init_internal(d3d_video_t *d3d,
const video_info_t *info, const input_driver_t **input, const video_info_t *info, const input_driver_t **input,
void **input_data) void **input_data)
{ {
@ -1085,11 +1085,11 @@ static bool d3d_init_internal(d3d_video_t *d3d,
} }
} }
if (!d3d_process_shader(d3d)) if (!d3d9_process_shader(d3d))
return false; return false;
d3d->video_info = *info; d3d->video_info = *info;
if (!d3d_initialize(d3d, &d3d->video_info)) if (!d3d9_initialize(d3d, &d3d->video_info))
return false; return false;
inp.input = input; inp.input = input;
@ -1101,7 +1101,7 @@ static bool d3d_init_internal(d3d_video_t *d3d,
return true; return true;
} }
static void d3d_set_rotation(void *data, unsigned rot) static void d3d9_set_rotation(void *data, unsigned rot)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
struct video_ortho ortho = {0, 1, 0, 1, -1, 1}; struct video_ortho ortho = {0, 1, 0, 1, -1, 1};
@ -1112,12 +1112,12 @@ static void d3d_set_rotation(void *data, unsigned rot)
d3d->dev_rotation = rot; d3d->dev_rotation = rot;
} }
static void d3d_show_mouse(void *data, bool state) static void d3d9_show_mouse(void *data, bool state)
{ {
video_context_driver_show_mouse(&state); video_context_driver_show_mouse(&state);
} }
static const gfx_ctx_driver_t *d3d_get_context(void *data) static const gfx_ctx_driver_t *d3d9_get_context(void *data)
{ {
/* TODO: GL core contexts through ANGLE? */ /* TODO: GL core contexts through ANGLE? */
unsigned minor = 0; unsigned minor = 0;
@ -1130,7 +1130,7 @@ static const gfx_ctx_driver_t *d3d_get_context(void *data)
api, major, minor, false); api, major, minor, false);
} }
static void *d3d_init(const video_info_t *info, static void *d3d9_init(const video_info_t *info,
const input_driver_t **input, void **input_data) const input_driver_t **input, void **input_data)
{ {
d3d_video_t *d3d = NULL; d3d_video_t *d3d = NULL;
@ -1143,7 +1143,7 @@ static void *d3d_init(const video_info_t *info,
if (!d3d) if (!d3d)
goto error; goto error;
ctx_driver = d3d_get_context(d3d); ctx_driver = d3d9_get_context(d3d);
if (!ctx_driver) if (!ctx_driver)
goto error; goto error;
@ -1159,7 +1159,7 @@ static void *d3d_init(const video_info_t *info,
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver); video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
if (!d3d_init_internal(d3d, info, input, input_data)) if (!d3d9_init_internal(d3d, info, input, input_data))
{ {
RARCH_ERR("[D3D]: Failed to init D3D.\n"); RARCH_ERR("[D3D]: Failed to init D3D.\n");
goto error; goto error;
@ -1177,7 +1177,7 @@ error:
} }
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
static void d3d_free_overlays(d3d_video_t *d3d) static void d3d9_free_overlays(d3d_video_t *d3d)
{ {
unsigned i; unsigned i;
@ -1185,14 +1185,14 @@ static void d3d_free_overlays(d3d_video_t *d3d)
return; return;
for (i = 0; i < d3d->overlays_size; i++) for (i = 0; i < d3d->overlays_size; i++)
d3d_free_overlay(d3d, &d3d->overlays[i]); d3d9_free_overlay(d3d, &d3d->overlays[i]);
free(d3d->overlays); free(d3d->overlays);
d3d->overlays = NULL; d3d->overlays = NULL;
d3d->overlays_size = 0; d3d->overlays_size = 0;
} }
#endif #endif
static void d3d_free(void *data) static void d3d9_free(void *data)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1200,14 +1200,14 @@ static void d3d_free(void *data)
return; return;
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
d3d_free_overlays(d3d); d3d9_free_overlays(d3d);
if (d3d->overlays) if (d3d->overlays)
free(d3d->overlays); free(d3d->overlays);
d3d->overlays = NULL; d3d->overlays = NULL;
d3d->overlays_size = 0; d3d->overlays_size = 0;
#endif #endif
d3d_free_overlay(d3d, d3d->menu); d3d9_free_overlay(d3d, d3d->menu);
if (d3d->menu) if (d3d->menu)
free(d3d->menu); free(d3d->menu);
d3d->menu = NULL; d3d->menu = NULL;
@ -1220,9 +1220,9 @@ static void d3d_free(void *data)
free(d3d->shader_path); free(d3d->shader_path);
d3d->shader_path = NULL; d3d->shader_path = NULL;
d3d_device_free(d3d->dev, g_pD3D); d3d_device_free(d3d->dev, g_pD3D9);
d3d->dev = NULL; d3d->dev = NULL;
g_pD3D = NULL; g_pD3D9 = NULL;
#ifndef _XBOX #ifndef _XBOX
win32_monitor_from_window(); win32_monitor_from_window();
@ -1239,7 +1239,7 @@ static void d3d_free(void *data)
} }
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
static void d3d_overlay_tex_geom( static void d3d9_overlay_tex_geom(
void *data, void *data,
unsigned index, unsigned index,
float x, float y, float x, float y,
@ -1255,7 +1255,7 @@ static void d3d_overlay_tex_geom(
d3d->overlays[index].tex_coords[3] = h; d3d->overlays[index].tex_coords[3] = h;
} }
static void d3d_overlay_vertex_geom( static void d3d9_overlay_vertex_geom(
void *data, void *data,
unsigned index, unsigned index,
float x, float y, float x, float y,
@ -1273,7 +1273,7 @@ static void d3d_overlay_vertex_geom(
d3d->overlays[index].vert_coords[3] = h; d3d->overlays[index].vert_coords[3] = h;
} }
static bool d3d_overlay_load(void *data, static bool d3d9_overlay_load(void *data,
const void *image_data, unsigned num_images) const void *image_data, unsigned num_images)
{ {
unsigned i, y; unsigned i, y;
@ -1285,7 +1285,7 @@ static bool d3d_overlay_load(void *data,
if (!d3d) if (!d3d)
return false; return false;
d3d_free_overlays(d3d); d3d9_free_overlays(d3d);
d3d->overlays = (overlay_t*)calloc(num_images, sizeof(*d3d->overlays)); d3d->overlays = (overlay_t*)calloc(num_images, sizeof(*d3d->overlays));
d3d->overlays_size = num_images; d3d->overlays_size = num_images;
@ -1325,14 +1325,14 @@ static bool d3d_overlay_load(void *data,
overlay->tex_h = height; overlay->tex_h = height;
/* Default. Stretch to whole screen. */ /* Default. Stretch to whole screen. */
d3d_overlay_tex_geom(d3d, i, 0, 0, 1, 1); d3d9_overlay_tex_geom(d3d, i, 0, 0, 1, 1);
d3d_overlay_vertex_geom(d3d, i, 0, 0, 1, 1); d3d9_overlay_vertex_geom(d3d, i, 0, 0, 1, 1);
} }
return true; return true;
} }
static void d3d_overlay_enable(void *data, bool state) static void d3d9_overlay_enable(void *data, bool state)
{ {
unsigned i; unsigned i;
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1346,7 +1346,7 @@ static void d3d_overlay_enable(void *data, bool state)
video_context_driver_show_mouse(&state); video_context_driver_show_mouse(&state);
} }
static void d3d_overlay_full_screen(void *data, bool enable) static void d3d9_overlay_full_screen(void *data, bool enable)
{ {
unsigned i; unsigned i;
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1355,31 +1355,31 @@ static void d3d_overlay_full_screen(void *data, bool enable)
d3d->overlays[i].fullscreen = enable; d3d->overlays[i].fullscreen = enable;
} }
static void d3d_overlay_set_alpha(void *data, unsigned index, float mod) static void d3d9_overlay_set_alpha(void *data, unsigned index, float mod)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
if (d3d) if (d3d)
d3d->overlays[index].alpha_mod = mod; d3d->overlays[index].alpha_mod = mod;
} }
static const video_overlay_interface_t d3d_overlay_interface = { static const video_overlay_interface_t d3d9_overlay_interface = {
d3d_overlay_enable, d3d9_overlay_enable,
d3d_overlay_load, d3d9_overlay_load,
d3d_overlay_tex_geom, d3d9_overlay_tex_geom,
d3d_overlay_vertex_geom, d3d9_overlay_vertex_geom,
d3d_overlay_full_screen, d3d9_overlay_full_screen,
d3d_overlay_set_alpha, d3d9_overlay_set_alpha,
}; };
static void d3d_get_overlay_interface(void *data, static void d3d9_get_overlay_interface(void *data,
const video_overlay_interface_t **iface) const video_overlay_interface_t **iface)
{ {
(void)data; (void)data;
*iface = &d3d_overlay_interface; *iface = &d3d9_overlay_interface;
} }
#endif #endif
static bool d3d_frame(void *data, const void *frame, static bool d3d9_frame(void *data, const void *frame,
unsigned frame_width, unsigned frame_height, unsigned frame_width, unsigned frame_height,
uint64_t frame_count, unsigned pitch, uint64_t frame_count, unsigned pitch,
const char *msg, video_frame_info_t *video_info) const char *msg, video_frame_info_t *video_info)
@ -1403,7 +1403,7 @@ static bool d3d_frame(void *data, const void *frame,
return true; return true;
#endif #endif
if (!d3d_restore(d3d)) if (!d3d9_restore(d3d))
{ {
RARCH_ERR("[D3D]: Failed to restore.\n"); RARCH_ERR("[D3D]: Failed to restore.\n");
return false; return false;
@ -1412,7 +1412,7 @@ static bool d3d_frame(void *data, const void *frame,
if (d3d->should_resize) if (d3d->should_resize)
{ {
d3d_set_viewport(d3d, width, height, false, true); d3d9_set_viewport(d3d, width, height, false, true);
if (d3d->renderchain_driver->set_final_viewport) if (d3d->renderchain_driver->set_final_viewport)
d3d->renderchain_driver->set_final_viewport(d3d, d3d->renderchain_driver->set_final_viewport(d3d,
d3d->renderchain_data, &d3d->final_viewport); d3d->renderchain_data, &d3d->final_viewport);
@ -1453,8 +1453,8 @@ static bool d3d_frame(void *data, const void *frame,
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (d3d->menu && d3d->menu->enabled) if (d3d->menu && d3d->menu->enabled)
{ {
d3d_set_mvp(d3d, NULL, &d3d->mvp); d3d9_set_mvp(d3d, NULL, &d3d->mvp);
d3d_overlay_render(d3d, video_info, d3d->menu); d3d9_overlay_render(d3d, video_info, d3d->menu);
d3d->menu_display.offset = 0; d3d->menu_display.offset = 0;
d3d_set_vertex_declaration(d3d->dev, d3d->menu_display.decl); d3d_set_vertex_declaration(d3d->dev, d3d->menu_display.decl);
@ -1468,9 +1468,9 @@ static bool d3d_frame(void *data, const void *frame,
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (d3d->overlays_enabled) if (d3d->overlays_enabled)
{ {
d3d_set_mvp(d3d, NULL, &d3d->mvp); d3d9_set_mvp(d3d, NULL, &d3d->mvp);
for (i = 0; i < d3d->overlays_size; i++) for (i = 0; i < d3d->overlays_size; i++)
d3d_overlay_render(d3d, video_info, &d3d->overlays[i]); d3d9_overlay_render(d3d, video_info, &d3d->overlays[i]);
} }
#endif #endif
@ -1489,7 +1489,7 @@ static bool d3d_frame(void *data, const void *frame,
return true; return true;
} }
static bool d3d_read_viewport(void *data, uint8_t *buffer, bool is_idle) static bool d3d9_read_viewport(void *data, uint8_t *buffer, bool is_idle)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1501,7 +1501,7 @@ static bool d3d_read_viewport(void *data, uint8_t *buffer, bool is_idle)
return d3d->renderchain_driver->read_viewport(d3d, buffer, false); return d3d->renderchain_driver->read_viewport(d3d, buffer, false);
} }
static bool d3d_set_shader(void *data, static bool d3d9_set_shader(void *data,
enum rarch_shader_type type, const char *path) enum rarch_shader_type type, const char *path)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1522,14 +1522,14 @@ static bool d3d_set_shader(void *data,
break; break;
} }
if (!d3d_process_shader(d3d) || !d3d_restore(d3d)) if (!d3d9_process_shader(d3d) || !d3d9_restore(d3d))
{ {
RARCH_ERR("[D3D]: Setting shader failed.\n"); RARCH_ERR("[D3D]: Setting shader failed.\n");
if (!string_is_empty(old_shader)) if (!string_is_empty(old_shader))
{ {
d3d->shader_path = strdup(old_shader); d3d->shader_path = strdup(old_shader);
d3d_process_shader(d3d); d3d9_process_shader(d3d);
d3d_restore(d3d); d3d9_restore(d3d);
} }
free(old_shader); free(old_shader);
return false; return false;
@ -1538,7 +1538,7 @@ static bool d3d_set_shader(void *data,
return true; return true;
} }
static void d3d_set_menu_texture_frame(void *data, static void d3d9_set_menu_texture_frame(void *data,
const void *frame, bool rgb32, unsigned width, unsigned height, const void *frame, bool rgb32, unsigned width, unsigned height,
float alpha) float alpha)
{ {
@ -1621,7 +1621,7 @@ static void d3d_set_menu_texture_frame(void *data,
} }
} }
static void d3d_set_menu_texture_enable(void *data, static void d3d9_set_menu_texture_enable(void *data,
bool state, bool full_screen) bool state, bool full_screen)
{ {
d3d_video_t *d3d = (d3d_video_t*)data; d3d_video_t *d3d = (d3d_video_t*)data;
@ -1633,7 +1633,7 @@ static void d3d_set_menu_texture_enable(void *data,
d3d->menu->fullscreen = full_screen; d3d->menu->fullscreen = full_screen;
} }
static void video_texture_load_d3d(d3d_video_t *d3d, static void d3d9_video_texture_load_d3d(d3d_video_t *d3d,
struct texture_image *ti, struct texture_image *ti,
enum texture_filter_type filter_type, enum texture_filter_type filter_type,
uintptr_t *id) uintptr_t *id)
@ -1675,51 +1675,51 @@ static void video_texture_load_d3d(d3d_video_t *d3d,
*id = (uintptr_t)tex; *id = (uintptr_t)tex;
} }
static int video_texture_load_wrap_d3d_mipmap(void *data) static int d3d9_video_texture_load_wrap_d3d_mipmap(void *data)
{ {
uintptr_t id = 0; uintptr_t id = 0;
video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(true), d3d9_video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(true),
(struct texture_image*)data, TEXTURE_FILTER_MIPMAP_LINEAR, &id); (struct texture_image*)data, TEXTURE_FILTER_MIPMAP_LINEAR, &id);
return id; return id;
} }
static int video_texture_load_wrap_d3d(void *data) static int d3d9_video_texture_load_wrap_d3d(void *data)
{ {
uintptr_t id = 0; uintptr_t id = 0;
video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(true), d3d9_video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(true),
(struct texture_image*)data, TEXTURE_FILTER_LINEAR, &id); (struct texture_image*)data, TEXTURE_FILTER_LINEAR, &id);
return id; return id;
} }
static uintptr_t d3d_load_texture(void *video_data, void *data, static uintptr_t d3d9_load_texture(void *video_data, void *data,
bool threaded, enum texture_filter_type filter_type) bool threaded, enum texture_filter_type filter_type)
{ {
uintptr_t id = 0; uintptr_t id = 0;
if (threaded) if (threaded)
{ {
custom_command_method_t func = video_texture_load_wrap_d3d; custom_command_method_t func = d3d9_video_texture_load_wrap_d3d;
switch (filter_type) switch (filter_type)
{ {
case TEXTURE_FILTER_MIPMAP_LINEAR: case TEXTURE_FILTER_MIPMAP_LINEAR:
case TEXTURE_FILTER_MIPMAP_NEAREST: case TEXTURE_FILTER_MIPMAP_NEAREST:
func = video_texture_load_wrap_d3d_mipmap; func = d3d9_video_texture_load_wrap_d3d_mipmap;
break; break;
default: default:
func = video_texture_load_wrap_d3d; func = d3d9_video_texture_load_wrap_d3d;
break; break;
} }
return video_thread_texture_load(data, func); return video_thread_texture_load(data, func);
} }
video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(false), d3d9_video_texture_load_d3d((d3d_video_t*)video_driver_get_ptr(false),
(struct texture_image*)data, filter_type, &id); (struct texture_image*)data, filter_type, &id);
return id; return id;
} }
static void d3d_unload_texture(void *data, uintptr_t id) static void d3d9_unload_texture(void *data, uintptr_t id)
{ {
LPDIRECT3DTEXTURE texid; LPDIRECT3DTEXTURE texid;
if (!id) if (!id)
@ -1729,11 +1729,11 @@ static void d3d_unload_texture(void *data, uintptr_t id)
d3d_texture_free(texid); d3d_texture_free(texid);
} }
static const video_poke_interface_t d3d_poke_interface = { static const video_poke_interface_t d3d9_poke_interface = {
NULL, /* set_coords */ NULL, /* set_coords */
d3d_set_mvp, d3d9_set_mvp,
d3d_load_texture, d3d9_load_texture,
d3d_unload_texture, d3d9_unload_texture,
NULL, NULL,
NULL, NULL,
NULL, /* get_video_output_size */ NULL, /* get_video_output_size */
@ -1741,40 +1741,40 @@ static const video_poke_interface_t d3d_poke_interface = {
NULL, /* get_video_output_next */ NULL, /* get_video_output_next */
NULL, /* get_current_framebuffer */ NULL, /* get_current_framebuffer */
NULL, /* get_proc_address */ NULL, /* get_proc_address */
d3d_set_aspect_ratio, d3d9_set_aspect_ratio,
d3d_apply_state_changes, d3d9_apply_state_changes,
d3d_set_menu_texture_frame, d3d9_set_menu_texture_frame,
d3d_set_menu_texture_enable, d3d9_set_menu_texture_enable,
d3d_set_osd_msg, d3d9_set_osd_msg,
d3d_show_mouse, d3d9_show_mouse,
}; };
static void d3d_get_poke_interface(void *data, static void d3d9_get_poke_interface(void *data,
const video_poke_interface_t **iface) const video_poke_interface_t **iface)
{ {
(void)data; (void)data;
*iface = &d3d_poke_interface; *iface = &d3d9_poke_interface;
} }
video_driver_t video_d3d9 = { video_driver_t video_d3d9 = {
d3d_init, d3d9_init,
d3d_frame, d3d9_frame,
d3d_set_nonblock_state, d3d9_set_nonblock_state,
d3d_alive, d3d9_alive,
NULL, /* focus */ NULL, /* focus */
d3d_suppress_screensaver, d3d9_suppress_screensaver,
NULL, /* has_windowed */ NULL, /* has_windowed */
d3d_set_shader, d3d9_set_shader,
d3d_free, d3d9_free,
"d3d9", "d3d9",
d3d_set_viewport, d3d9_set_viewport,
d3d_set_rotation, d3d9_set_rotation,
d3d_viewport_info, d3d9_viewport_info,
d3d_read_viewport, d3d9_read_viewport,
NULL, /* read_frame_raw */ NULL, /* read_frame_raw */
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
d3d_get_overlay_interface, d3d9_get_overlay_interface,
#endif #endif
d3d_get_poke_interface d3d9_get_poke_interface
}; };