mirror of
https://github.com/libretro/RetroArch
synced 2025-03-29 22:20:21 +00:00
(D3D9) Split up D3D9 driver into two separate drivers - one for D3D9 HLSL
and another one for D3D9 Cg
This commit is contained in:
twinaphex
parent
6195711bb3
commit
68032c7734
@ -1743,7 +1743,9 @@ ifeq ($(HAVE_D3D9), 1)
|
||||
OBJ += gfx/drivers_font/d3d_w32_font.o
|
||||
ifeq ($(HAVE_CG), 1)
|
||||
LIBS += -lcgD3D9
|
||||
OBJ += gfx/drivers/d3d9cg.o
|
||||
OBJ += gfx/drivers_renderchain/d3d9_cg_renderchain.o
|
||||
OBJ += gfx/drivers_display/gfx_display_d3d9cg.o
|
||||
endif
|
||||
endif
|
||||
|
||||
@ -1813,9 +1815,7 @@ endif
|
||||
|
||||
ifeq ($(HAVE_D3D9), 1)
|
||||
DEFINES += -DHAVE_D3D9
|
||||
OBJ += gfx/drivers/d3d9.o
|
||||
OBJ += gfx/common/d3d9_common.o
|
||||
OBJ += gfx/drivers_display/gfx_display_d3d9.o
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_D3D_COMMON), 1)
|
||||
@ -1836,7 +1836,9 @@ endif
|
||||
|
||||
ifeq ($(HAVE_HLSL),1)
|
||||
DEFINES += -DHAVE_HLSL
|
||||
OBJ += gfx/drivers/d3d9hlsl.o
|
||||
OBJ += gfx/drivers_renderchain/d3d9_hlsl_renderchain.o
|
||||
OBJ += gfx/drivers_display/gfx_display_d3d9hlsl.o
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_SLANG),1)
|
||||
|
||||
@ -88,7 +88,8 @@ enum video_driver_enum
|
||||
VIDEO_CTR,
|
||||
VIDEO_SWITCH,
|
||||
VIDEO_D3D8,
|
||||
VIDEO_D3D9,
|
||||
VIDEO_D3D9_CG,
|
||||
VIDEO_D3D9_HLSL,
|
||||
VIDEO_D3D10,
|
||||
VIDEO_D3D11,
|
||||
VIDEO_D3D12,
|
||||
@ -960,8 +961,10 @@ const char *config_get_default_video(void)
|
||||
return "xenon360";
|
||||
case VIDEO_D3D8:
|
||||
return "d3d8";
|
||||
case VIDEO_D3D9:
|
||||
return "d3d9";
|
||||
case VIDEO_D3D9_CG:
|
||||
return "d3d9_cg";
|
||||
case VIDEO_D3D9_HLSL:
|
||||
return "d3d9_hlsl";
|
||||
case VIDEO_D3D10:
|
||||
return "d3d10";
|
||||
case VIDEO_D3D11:
|
||||
@ -2991,9 +2994,9 @@ static bool check_menu_driver_compatibility(settings_t *settings)
|
||||
/* TODO/FIXME - maintenance hazard */
|
||||
if (string_starts_with_size(video_driver, "d3d", STRLEN_CONST("d3d")))
|
||||
if (
|
||||
string_is_equal(video_driver, "d3d9") ||
|
||||
string_is_equal(video_driver, "d3d10") ||
|
||||
string_is_equal(video_driver, "d3d11") ||
|
||||
string_is_equal(video_driver, "d3d9_hlsl") ||
|
||||
string_is_equal(video_driver, "d3d10") ||
|
||||
string_is_equal(video_driver, "d3d11") ||
|
||||
string_is_equal(video_driver, "d3d12")
|
||||
)
|
||||
return true;
|
||||
|
||||
898
gfx/drivers/d3d9cg.c
Normal file
898
gfx/drivers/d3d9cg.c
Normal file
@ -0,0 +1,898 @@
|
||||
/* RetroArch - A frontend for libretro.
|
||||
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
||||
* Copyright (C) 2011-2017 - Daniel De Matteis
|
||||
* Copyright (C) 2012-2014 - OV2
|
||||
*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
/* Direct3D 9 driver with Cg runtime backend.
|
||||
*
|
||||
* Minimum version : Direct3D 9.0 (2002)
|
||||
* Minimum OS : Windows 98, Windows 2000, Windows ME
|
||||
* Recommended OS : Windows XP
|
||||
* Requirements : Cg runtime
|
||||
*/
|
||||
|
||||
#define CINTERFACE
|
||||
|
||||
#include <formats/image.h>
|
||||
#include <compat/strl.h>
|
||||
#include <compat/posix_string.h>
|
||||
#include <file/file_path.h>
|
||||
#include <string/stdstring.h>
|
||||
#include <retro_math.h>
|
||||
|
||||
#include <d3d9.h>
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "../../config.h"
|
||||
#endif
|
||||
|
||||
#include <defines/d3d_defines.h>
|
||||
#include "../common/d3d_common.h"
|
||||
#include "../common/d3d9_common.h"
|
||||
#include "../video_coord_array.h"
|
||||
#include "../../configuration.h"
|
||||
#include "../../dynamic.h"
|
||||
#include "../../frontend/frontend_driver.h"
|
||||
|
||||
#include "../common/win32_common.h"
|
||||
|
||||
#ifdef HAVE_MENU
|
||||
#include "../../menu/menu_driver.h"
|
||||
#endif
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
#include "../gfx_widgets.h"
|
||||
#endif
|
||||
|
||||
#include "../font_driver.h"
|
||||
|
||||
#include "../../core.h"
|
||||
#include "../../verbosity.h"
|
||||
#include "../../retroarch.h"
|
||||
|
||||
#ifdef __WINRT__
|
||||
#error "UWP does not support D3D9"
|
||||
#endif
|
||||
|
||||
/* TODO/FIXME - Temporary workaround for D3D9 not being able to poll flags during init */
|
||||
static gfx_ctx_driver_t d3d9_cg_fake_context;
|
||||
|
||||
extern d3d9_renderchain_driver_t cg_d3d9_renderchain;
|
||||
|
||||
static uint32_t d3d9_cg_get_flags(void *data)
|
||||
{
|
||||
uint32_t flags = 0;
|
||||
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static void d3d9_cg_deinit_chain(d3d9_video_t *d3d)
|
||||
{
|
||||
if (!d3d || !d3d->renderchain_driver)
|
||||
return;
|
||||
|
||||
if (d3d->renderchain_driver->chain_free)
|
||||
d3d->renderchain_driver->chain_free(d3d->renderchain_data);
|
||||
|
||||
d3d->renderchain_driver = NULL;
|
||||
d3d->renderchain_data = NULL;
|
||||
}
|
||||
|
||||
static void d3d9_cg_deinitialize(d3d9_video_t *d3d)
|
||||
{
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
font_driver_free_osd();
|
||||
|
||||
d3d9_cg_deinit_chain(d3d);
|
||||
d3d9_vertex_buffer_free(d3d->menu_display.buffer,
|
||||
d3d->menu_display.decl);
|
||||
|
||||
d3d->menu_display.buffer = NULL;
|
||||
d3d->menu_display.decl = NULL;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_init_base(d3d9_video_t *d3d, const video_info_t *info)
|
||||
{
|
||||
D3DPRESENT_PARAMETERS d3dpp;
|
||||
HWND focus_window = win32_get_window();
|
||||
|
||||
memset(&d3dpp, 0, sizeof(d3dpp));
|
||||
|
||||
g_pD3D9 = (LPDIRECT3D9)d3d9_create();
|
||||
|
||||
/* this needs g_pD3D9 created first */
|
||||
d3d9_make_d3dpp(d3d, info, &d3dpp);
|
||||
|
||||
if (!g_pD3D9)
|
||||
return false;
|
||||
if (!d3d9_create_device(&d3d->dev, &d3dpp,
|
||||
g_pD3D9,
|
||||
focus_window,
|
||||
d3d->cur_mon_id)
|
||||
)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool renderchain_d3d_cg_init_first(
|
||||
enum gfx_ctx_api api,
|
||||
const d3d9_renderchain_driver_t **renderchain_driver,
|
||||
void **renderchain_handle)
|
||||
{
|
||||
switch (api)
|
||||
{
|
||||
case GFX_CTX_DIRECT3D9_API:
|
||||
{
|
||||
static const d3d9_renderchain_driver_t *renderchain_d3d_drivers[] =
|
||||
{
|
||||
&cg_d3d9_renderchain,
|
||||
NULL
|
||||
};
|
||||
unsigned i;
|
||||
|
||||
for (i = 0; renderchain_d3d_drivers[i]; i++)
|
||||
{
|
||||
void *data = renderchain_d3d_drivers[i]->chain_new();
|
||||
|
||||
if (!data)
|
||||
continue;
|
||||
|
||||
*renderchain_driver = renderchain_d3d_drivers[i];
|
||||
*renderchain_handle = data;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case GFX_CTX_NONE:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_init_chain(d3d9_video_t *d3d,
|
||||
unsigned input_scale,
|
||||
bool rgb32)
|
||||
{
|
||||
unsigned i = 0;
|
||||
struct LinkInfo link_info;
|
||||
unsigned current_width, current_height, out_width, out_height;
|
||||
|
||||
/* Setup information for first pass. */
|
||||
link_info.pass = NULL;
|
||||
link_info.tex_w = input_scale * RARCH_SCALE_BASE;
|
||||
link_info.tex_h = input_scale * RARCH_SCALE_BASE;
|
||||
link_info.pass = &d3d->shader.pass[0];
|
||||
|
||||
if (!renderchain_d3d_cg_init_first(GFX_CTX_DIRECT3D9_API,
|
||||
&d3d->renderchain_driver,
|
||||
&d3d->renderchain_data))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Renderchain could not be initialized.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!d3d->renderchain_driver || !d3d->renderchain_data)
|
||||
return false;
|
||||
|
||||
if (
|
||||
!d3d->renderchain_driver->init(
|
||||
d3d,
|
||||
d3d->dev, &d3d->final_viewport, &link_info,
|
||||
rgb32)
|
||||
)
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to init render chain.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
RARCH_LOG("[D3D9]: Renderchain driver: \"%s\".\n", d3d->renderchain_driver->ident);
|
||||
d3d9_log_info(&link_info);
|
||||
|
||||
current_width = link_info.tex_w;
|
||||
current_height = link_info.tex_h;
|
||||
out_width = 0;
|
||||
out_height = 0;
|
||||
|
||||
for (i = 1; i < d3d->shader.passes; i++)
|
||||
{
|
||||
d3d9_convert_geometry(
|
||||
&link_info,
|
||||
&out_width, &out_height,
|
||||
current_width, current_height, &d3d->final_viewport);
|
||||
|
||||
link_info.pass = &d3d->shader.pass[i];
|
||||
link_info.tex_w = next_pow2(out_width);
|
||||
link_info.tex_h = next_pow2(out_height);
|
||||
|
||||
current_width = out_width;
|
||||
current_height = out_height;
|
||||
|
||||
if (!d3d->renderchain_driver->add_pass(
|
||||
d3d->renderchain_data, &link_info))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to add pass.\n");
|
||||
return false;
|
||||
}
|
||||
d3d9_log_info(&link_info);
|
||||
}
|
||||
|
||||
if (d3d->renderchain_driver)
|
||||
{
|
||||
if (d3d->renderchain_driver->add_lut)
|
||||
{
|
||||
unsigned i;
|
||||
settings_t *settings = config_get_ptr();
|
||||
bool video_smooth = settings->bools.video_smooth;
|
||||
|
||||
for (i = 0; i < d3d->shader.luts; i++)
|
||||
{
|
||||
if (!d3d->renderchain_driver->add_lut(
|
||||
d3d->renderchain_data,
|
||||
d3d->shader.lut[i].id, d3d->shader.lut[i].path,
|
||||
d3d->shader.lut[i].filter == RARCH_FILTER_UNSPEC
|
||||
? video_smooth
|
||||
: (d3d->shader.lut[i].filter == RARCH_FILTER_LINEAR)))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to init LUTs.\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
{
|
||||
unsigned width, height;
|
||||
bool ret = true;
|
||||
settings_t *settings = config_get_ptr();
|
||||
|
||||
if (!g_pD3D9)
|
||||
ret = d3d9_cg_init_base(d3d, info);
|
||||
else if (d3d->needs_restore)
|
||||
{
|
||||
D3DPRESENT_PARAMETERS d3dpp;
|
||||
|
||||
d3d9_make_d3dpp(d3d, info, &d3dpp);
|
||||
|
||||
/* the D3DX font driver uses POOL_DEFAULT resources
|
||||
* and will prevent a clean reset here
|
||||
* another approach would be to keep track of all created D3D
|
||||
* font objects and free/realloc them around the d3d_reset call */
|
||||
#ifdef HAVE_MENU
|
||||
menu_driver_ctl(RARCH_MENU_CTL_DEINIT, NULL);
|
||||
#endif
|
||||
|
||||
if (!d3d9_reset(d3d->dev, &d3dpp))
|
||||
{
|
||||
d3d9_cg_deinitialize(d3d);
|
||||
d3d9_device_free(NULL, g_pD3D9);
|
||||
g_pD3D9 = NULL;
|
||||
|
||||
ret = d3d9_cg_init_base(d3d, info);
|
||||
if (ret)
|
||||
RARCH_LOG("[D3D9]: Recovered from dead state.\n");
|
||||
}
|
||||
|
||||
#ifdef HAVE_MENU
|
||||
menu_driver_init(info->is_threaded);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (!ret)
|
||||
return ret;
|
||||
|
||||
if (!d3d9_cg_init_chain(d3d, info->input_scale, info->rgb32))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to initialize render chain.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
video_driver_get_size(&width, &height);
|
||||
d3d9_set_viewport(d3d,
|
||||
width, height, false, true);
|
||||
|
||||
font_driver_init_osd(d3d, info,
|
||||
false,
|
||||
info->is_threaded,
|
||||
FONT_DRIVER_RENDER_D3D9_API);
|
||||
|
||||
{
|
||||
static const D3DVERTEXELEMENT9 VertexElements[4] = {
|
||||
{0, offsetof(Vertex, x), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
|
||||
D3DDECLUSAGE_POSITION, 0},
|
||||
{0, offsetof(Vertex, u), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT,
|
||||
D3DDECLUSAGE_TEXCOORD, 0},
|
||||
{0, offsetof(Vertex, color), D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT,
|
||||
D3DDECLUSAGE_COLOR, 0},
|
||||
D3DDECL_END()
|
||||
};
|
||||
if (!d3d9_vertex_declaration_new(d3d->dev,
|
||||
(void*)VertexElements, (void**)&d3d->menu_display.decl))
|
||||
return false;
|
||||
}
|
||||
|
||||
d3d->menu_display.offset = 0;
|
||||
d3d->menu_display.size = 1024;
|
||||
d3d->menu_display.buffer = d3d9_vertex_buffer_new(
|
||||
d3d->dev, d3d->menu_display.size * sizeof(Vertex),
|
||||
D3DUSAGE_WRITEONLY,
|
||||
D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1,
|
||||
D3DPOOL_DEFAULT,
|
||||
NULL);
|
||||
|
||||
if (!d3d->menu_display.buffer)
|
||||
return false;
|
||||
|
||||
d3d_matrix_ortho_off_center_lh(&d3d->mvp_transposed, 0, 1, 0, 1, 0, 1);
|
||||
d3d_matrix_transpose(&d3d->mvp, &d3d->mvp_transposed);
|
||||
|
||||
d3d9_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
|
||||
d3d9_set_render_state(d3d->dev, D3DRS_SCISSORTESTENABLE, TRUE);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_restore(d3d9_video_t *d3d)
|
||||
{
|
||||
d3d9_cg_deinitialize(d3d);
|
||||
|
||||
if (!d3d9_cg_initialize(d3d, &d3d->video_info))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Restore error.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
d3d->needs_restore = false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_set_shader(void *data,
|
||||
enum rarch_shader_type type, const char *path)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
return false;
|
||||
|
||||
if (!string_is_empty(d3d->shader_path))
|
||||
free(d3d->shader_path);
|
||||
d3d->shader_path = NULL;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case RARCH_SHADER_CG:
|
||||
case RARCH_SHADER_HLSL:
|
||||
if (!string_is_empty(path))
|
||||
d3d->shader_path = strdup(path);
|
||||
break;
|
||||
case RARCH_SHADER_NONE:
|
||||
break;
|
||||
default:
|
||||
RARCH_WARN("[D3D9]: Only Cg shaders are supported. Falling back to stock.\n");
|
||||
}
|
||||
|
||||
if (!d3d9_process_shader(d3d) || !d3d9_cg_restore(d3d))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to set shader.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool d3d9_cg_init_internal(d3d9_video_t *d3d,
|
||||
const video_info_t *info, input_driver_t **input,
|
||||
void **input_data)
|
||||
{
|
||||
#ifdef HAVE_MONITOR
|
||||
bool windowed_full;
|
||||
RECT mon_rect;
|
||||
MONITORINFOEX current_mon;
|
||||
HMONITOR hm_to_use;
|
||||
#endif
|
||||
#ifdef HAVE_WINDOW
|
||||
DWORD style;
|
||||
unsigned win_width = 0;
|
||||
unsigned win_height = 0;
|
||||
RECT rect = {0};
|
||||
#endif
|
||||
unsigned full_x = 0;
|
||||
unsigned full_y = 0;
|
||||
settings_t *settings = config_get_ptr();
|
||||
overlay_t *menu = (overlay_t*)calloc(1, sizeof(*menu));
|
||||
|
||||
if (!menu)
|
||||
return false;
|
||||
|
||||
d3d->menu = menu;
|
||||
d3d->cur_mon_id = 0;
|
||||
d3d->menu->tex_coords[0] = 0;
|
||||
d3d->menu->tex_coords[1] = 0;
|
||||
d3d->menu->tex_coords[2] = 1;
|
||||
d3d->menu->tex_coords[3] = 1;
|
||||
d3d->menu->vert_coords[0] = 0;
|
||||
d3d->menu->vert_coords[1] = 1;
|
||||
d3d->menu->vert_coords[2] = 1;
|
||||
d3d->menu->vert_coords[3] = -1;
|
||||
|
||||
#ifdef HAVE_WINDOW
|
||||
memset(&d3d->windowClass, 0, sizeof(d3d->windowClass));
|
||||
d3d->windowClass.lpfnWndProc = wnd_proc_d3d_common;
|
||||
#ifdef HAVE_DINPUT
|
||||
if (string_is_equal(settings->arrays.input_driver, "dinput"))
|
||||
d3d->windowClass.lpfnWndProc = wnd_proc_d3d_dinput;
|
||||
#endif
|
||||
#ifdef HAVE_WINRAWINPUT
|
||||
if (string_is_equal(settings->arrays.input_driver, "raw"))
|
||||
d3d->windowClass.lpfnWndProc = wnd_proc_d3d_winraw;
|
||||
#endif
|
||||
win32_window_init(&d3d->windowClass, true, NULL);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_MONITOR
|
||||
win32_monitor_info(¤t_mon, &hm_to_use, &d3d->cur_mon_id);
|
||||
|
||||
mon_rect = current_mon.rcMonitor;
|
||||
g_win32_resize_width = info->width;
|
||||
g_win32_resize_height = info->height;
|
||||
|
||||
windowed_full = settings->bools.video_windowed_fullscreen;
|
||||
|
||||
full_x = (windowed_full || info->width == 0) ?
|
||||
(mon_rect.right - mon_rect.left) : info->width;
|
||||
full_y = (windowed_full || info->height == 0) ?
|
||||
(mon_rect.bottom - mon_rect.top) : info->height;
|
||||
|
||||
RARCH_LOG("[D3D9]: Monitor size: %dx%d.\n",
|
||||
(int)(mon_rect.right - mon_rect.left),
|
||||
(int)(mon_rect.bottom - mon_rect.top));
|
||||
#else
|
||||
{
|
||||
d3d9_get_video_size(d3d, &full_x, &full_y);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
unsigned new_width = info->fullscreen ? full_x : info->width;
|
||||
unsigned new_height = info->fullscreen ? full_y : info->height;
|
||||
video_driver_set_size(new_width, new_height);
|
||||
}
|
||||
|
||||
#ifdef HAVE_WINDOW
|
||||
video_driver_get_size(&win_width, &win_height);
|
||||
|
||||
win32_set_style(¤t_mon, &hm_to_use, &win_width, &win_height,
|
||||
info->fullscreen, windowed_full, &rect, &mon_rect, &style);
|
||||
|
||||
win32_window_create(d3d, style, &mon_rect, win_width,
|
||||
win_height, info->fullscreen);
|
||||
|
||||
win32_set_window(&win_width, &win_height, info->fullscreen,
|
||||
windowed_full, &rect);
|
||||
#endif
|
||||
|
||||
d3d->video_info = *info;
|
||||
|
||||
if (!d3d9_cg_initialize(d3d, &d3d->video_info))
|
||||
return false;
|
||||
|
||||
d3d9_cg_fake_context.get_flags = d3d9_cg_get_flags;
|
||||
d3d9_cg_fake_context.get_metrics = win32_get_metrics;
|
||||
video_context_driver_set(&d3d9_cg_fake_context);
|
||||
{
|
||||
const char *shader_preset = retroarch_get_shader_preset();
|
||||
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
|
||||
|
||||
d3d9_cg_set_shader(d3d, type, shader_preset);
|
||||
}
|
||||
|
||||
d3d_input_driver(settings->arrays.input_joypad_driver,
|
||||
settings->arrays.input_joypad_driver, input, input_data);
|
||||
|
||||
{
|
||||
char version_str[128];
|
||||
D3DADAPTER_IDENTIFIER9 ident = {0};
|
||||
|
||||
IDirect3D9_GetAdapterIdentifier(g_pD3D9, 0, 0, &ident);
|
||||
|
||||
version_str[0] = '\0';
|
||||
|
||||
snprintf(version_str, sizeof(version_str), "%u.%u.%u.%u",
|
||||
HIWORD(ident.DriverVersion.HighPart),
|
||||
LOWORD(ident.DriverVersion.HighPart),
|
||||
HIWORD(ident.DriverVersion.LowPart),
|
||||
LOWORD(ident.DriverVersion.LowPart));
|
||||
|
||||
RARCH_LOG("[D3D9]: Using GPU: \"%s\".\n", ident.Description);
|
||||
RARCH_LOG("[D3D9]: GPU API Version: %s\n", version_str);
|
||||
|
||||
video_driver_set_gpu_device_string(ident.Description);
|
||||
video_driver_set_gpu_api_version_string(version_str);
|
||||
}
|
||||
|
||||
RARCH_LOG("[D3D9]: Init complete.\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
static void *d3d9_cg_init(const video_info_t *info,
|
||||
input_driver_t **input, void **input_data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)calloc(1, sizeof(*d3d));
|
||||
|
||||
if (!d3d)
|
||||
return NULL;
|
||||
|
||||
if (!d3d9_initialize_symbols(GFX_CTX_DIRECT3D9_API))
|
||||
{
|
||||
free(d3d);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
win32_window_reset();
|
||||
win32_monitor_init();
|
||||
|
||||
/* Default values */
|
||||
d3d->dev = NULL;
|
||||
d3d->dev_rotation = 0;
|
||||
d3d->needs_restore = false;
|
||||
#ifdef HAVE_OVERLAY
|
||||
d3d->overlays_enabled = false;
|
||||
#endif
|
||||
d3d->should_resize = false;
|
||||
d3d->menu = NULL;
|
||||
|
||||
if (!d3d9_cg_init_internal(d3d, info, input, input_data))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to init D3D.\n");
|
||||
free(d3d);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
d3d->keep_aspect = info->force_aspect;
|
||||
|
||||
return d3d;
|
||||
}
|
||||
|
||||
static void d3d9_cg_free(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
#ifdef HAVE_OVERLAY
|
||||
d3d9_free_overlays(d3d);
|
||||
if (d3d->overlays)
|
||||
free(d3d->overlays);
|
||||
d3d->overlays = NULL;
|
||||
d3d->overlays_size = 0;
|
||||
#endif
|
||||
|
||||
d3d9_free_overlay(d3d, d3d->menu);
|
||||
if (d3d->menu)
|
||||
free(d3d->menu);
|
||||
d3d->menu = NULL;
|
||||
|
||||
d3d9_cg_deinitialize(d3d);
|
||||
|
||||
if (!string_is_empty(d3d->shader_path))
|
||||
free(d3d->shader_path);
|
||||
|
||||
d3d->shader_path = NULL;
|
||||
d3d9_device_free(d3d->dev, g_pD3D9);
|
||||
d3d->dev = NULL;
|
||||
g_pD3D9 = NULL;
|
||||
|
||||
d3d9_deinitialize_symbols();
|
||||
|
||||
win32_monitor_from_window();
|
||||
win32_destroy_window();
|
||||
free(d3d);
|
||||
}
|
||||
|
||||
static bool d3d9_cg_frame(void *data, const void *frame,
|
||||
unsigned frame_width, unsigned frame_height,
|
||||
uint64_t frame_count, unsigned pitch,
|
||||
const char *msg, video_frame_info_t *video_info)
|
||||
{
|
||||
D3DVIEWPORT9 screen_vp;
|
||||
unsigned i = 0;
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
unsigned width = video_info->width;
|
||||
unsigned height = video_info->height;
|
||||
bool statistics_show = video_info->statistics_show;
|
||||
unsigned black_frame_insertion = video_info->black_frame_insertion;
|
||||
struct font_params *osd_params = (struct font_params*)
|
||||
&video_info->osd_stat_params;
|
||||
const char *stat_text = video_info->stat_text;
|
||||
bool menu_is_alive = video_info->menu_is_alive;
|
||||
bool overlay_behind_menu = video_info->overlay_behind_menu;
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
bool widgets_active = video_info->widgets_active;
|
||||
#endif
|
||||
|
||||
if (!frame)
|
||||
return true;
|
||||
|
||||
/* We cannot recover in fullscreen. */
|
||||
if (d3d->needs_restore)
|
||||
{
|
||||
HWND window = win32_get_window();
|
||||
if (IsIconic(window))
|
||||
return true;
|
||||
|
||||
if (!d3d9_cg_restore(d3d))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to restore.\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (d3d->should_resize)
|
||||
{
|
||||
d3d9_set_viewport(d3d, width, height, false, true);
|
||||
if (d3d->renderchain_driver->set_final_viewport)
|
||||
d3d->renderchain_driver->set_final_viewport(d3d,
|
||||
d3d->renderchain_data, &d3d->final_viewport);
|
||||
|
||||
d3d->should_resize = false;
|
||||
}
|
||||
|
||||
/* render_chain() only clears out viewport,
|
||||
* clear out everything. */
|
||||
screen_vp.X = 0;
|
||||
screen_vp.Y = 0;
|
||||
screen_vp.MinZ = 0;
|
||||
screen_vp.MaxZ = 1;
|
||||
screen_vp.Width = width;
|
||||
screen_vp.Height = height;
|
||||
d3d9_set_viewports(d3d->dev, &screen_vp);
|
||||
IDirect3DDevice9_Clear(d3d->dev, 0, 0, D3DCLEAR_TARGET,
|
||||
0, 1, 0);
|
||||
|
||||
d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const float*)&d3d->mvp_transposed, 4);
|
||||
if (!d3d->renderchain_driver->render(
|
||||
d3d, frame, frame_width, frame_height,
|
||||
pitch, d3d->dev_rotation))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to render scene.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (black_frame_insertion && !d3d->menu->enabled)
|
||||
{
|
||||
unsigned n;
|
||||
for (n = 0; n < video_info->black_frame_insertion; ++n)
|
||||
{
|
||||
bool ret = (IDirect3DDevice9_Present(d3d->dev,
|
||||
NULL, NULL, NULL, NULL) != D3DERR_DEVICELOST);
|
||||
if (!ret || d3d->needs_restore)
|
||||
return true;
|
||||
IDirect3DDevice9_Clear(d3d->dev, 0, 0, D3DCLEAR_TARGET,
|
||||
0, 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_OVERLAY
|
||||
if (d3d->overlays_enabled && overlay_behind_menu)
|
||||
{
|
||||
d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const float*)&d3d->mvp_transposed, 4);
|
||||
for (i = 0; i < d3d->overlays_size; i++)
|
||||
d3d9_overlay_render(d3d, width, height, &d3d->overlays[i], true);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_MENU
|
||||
if (d3d->menu && d3d->menu->enabled)
|
||||
{
|
||||
d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const
|
||||
float*)&d3d->mvp_transposed, 4);
|
||||
d3d9_overlay_render(d3d, width, height, d3d->menu, false);
|
||||
|
||||
d3d->menu_display.offset = 0;
|
||||
d3d9_set_vertex_declaration(d3d->dev, (LPDIRECT3DVERTEXDECLARATION9)d3d->menu_display.decl);
|
||||
d3d9_set_stream_source(d3d->dev, 0, (LPDIRECT3DVERTEXBUFFER9)d3d->menu_display.buffer, 0, sizeof(Vertex));
|
||||
|
||||
d3d9_set_viewports(d3d->dev, &screen_vp);
|
||||
menu_driver_frame(menu_is_alive, video_info);
|
||||
}
|
||||
else if (statistics_show)
|
||||
{
|
||||
if (osd_params)
|
||||
{
|
||||
d3d9_set_viewports(d3d->dev, &screen_vp);
|
||||
d3d9_begin_scene(d3d->dev);
|
||||
font_driver_render_msg(d3d, stat_text,
|
||||
(const struct font_params*)osd_params, NULL);
|
||||
d3d9_end_scene(d3d->dev);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_OVERLAY
|
||||
if (d3d->overlays_enabled && !overlay_behind_menu)
|
||||
{
|
||||
d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const
|
||||
float*)&d3d->mvp_transposed, 4);
|
||||
for (i = 0; i < d3d->overlays_size; i++)
|
||||
d3d9_overlay_render(d3d, width, height, &d3d->overlays[i], true);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
if (widgets_active)
|
||||
gfx_widgets_frame(video_info);
|
||||
#endif
|
||||
|
||||
if (msg && *msg)
|
||||
{
|
||||
d3d9_set_viewports(d3d->dev, &screen_vp);
|
||||
d3d9_begin_scene(d3d->dev);
|
||||
font_driver_render_msg(d3d, msg, NULL, NULL);
|
||||
d3d9_end_scene(d3d->dev);
|
||||
}
|
||||
|
||||
win32_update_title();
|
||||
IDirect3DDevice9_Present(d3d->dev, NULL, NULL, NULL, NULL);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static const video_poke_interface_t d3d9_cg_poke_interface = {
|
||||
d3d9_cg_get_flags,
|
||||
d3d9_load_texture,
|
||||
d3d9_unload_texture,
|
||||
d3d9_set_video_mode,
|
||||
#if defined(__WINRT__)
|
||||
NULL,
|
||||
#else
|
||||
/* UWP does not expose this information easily */
|
||||
win32_get_refresh_rate,
|
||||
#endif
|
||||
NULL,
|
||||
NULL, /* get_video_output_size */
|
||||
NULL, /* get_video_output_prev */
|
||||
NULL, /* get_video_output_next */
|
||||
NULL, /* get_current_framebuffer */
|
||||
NULL, /* get_proc_address */
|
||||
d3d9_set_aspect_ratio,
|
||||
d3d9_apply_state_changes,
|
||||
d3d9_set_menu_texture_frame,
|
||||
d3d9_set_menu_texture_enable,
|
||||
d3d9_set_osd_msg,
|
||||
|
||||
win32_show_cursor,
|
||||
NULL, /* grab_mouse_toggle */
|
||||
NULL, /* get_current_shader */
|
||||
NULL, /* get_current_software_framebuffer */
|
||||
NULL, /* get_hw_render_interface */
|
||||
NULL, /* set_hdr_max_nits */
|
||||
NULL, /* set_hdr_paper_white_nits */
|
||||
NULL, /* set_hdr_contrast */
|
||||
NULL /* set_hdr_expand_gamut */
|
||||
};
|
||||
|
||||
static void d3d9_cg_get_poke_interface(void *data,
|
||||
const video_poke_interface_t **iface)
|
||||
{
|
||||
*iface = &d3d9_cg_poke_interface;
|
||||
}
|
||||
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
static bool d3d9_cg_gfx_widgets_enabled(void *data)
|
||||
{
|
||||
return false; /* currently disabled due to memory issues */
|
||||
}
|
||||
#endif
|
||||
|
||||
static void d3d9_cg_set_resize(d3d9_video_t *d3d,
|
||||
unsigned new_width, unsigned new_height)
|
||||
{
|
||||
/* No changes? */
|
||||
if ( (new_width == d3d->video_info.width)
|
||||
&& (new_height == d3d->video_info.height))
|
||||
return;
|
||||
|
||||
d3d->video_info.width = new_width;
|
||||
d3d->video_info.height = new_height;
|
||||
video_driver_set_size(new_width, new_height);
|
||||
}
|
||||
|
||||
static bool d3d9_cg_alive(void *data)
|
||||
{
|
||||
unsigned temp_width = 0;
|
||||
unsigned temp_height = 0;
|
||||
bool ret = false;
|
||||
bool quit = false;
|
||||
bool resize = false;
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
/* Needed because some context drivers don't track their sizes */
|
||||
video_driver_get_size(&temp_width, &temp_height);
|
||||
|
||||
win32_check_window(NULL, &quit, &resize, &temp_width, &temp_height);
|
||||
|
||||
if (quit)
|
||||
d3d->quitting = quit;
|
||||
|
||||
if (resize)
|
||||
{
|
||||
d3d->should_resize = true;
|
||||
d3d9_cg_set_resize(d3d, temp_width, temp_height);
|
||||
d3d9_cg_restore(d3d);
|
||||
}
|
||||
|
||||
ret = !quit;
|
||||
|
||||
if ( temp_width != 0 &&
|
||||
temp_height != 0)
|
||||
video_driver_set_size(temp_width, temp_height);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void d3d9_cg_set_nonblock_state(void *data, bool state,
|
||||
bool adaptive_vsync_enabled,
|
||||
unsigned swap_interval)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
d3d->video_info.vsync = !state;
|
||||
d3d->needs_restore = true;
|
||||
d3d9_cg_restore(d3d);
|
||||
}
|
||||
|
||||
video_driver_t video_d3d9_cg = {
|
||||
d3d9_cg_init,
|
||||
d3d9_cg_frame,
|
||||
d3d9_cg_set_nonblock_state,
|
||||
d3d9_cg_alive,
|
||||
NULL, /* focus */
|
||||
d3d9_suppress_screensaver,
|
||||
d3d9_has_windowed,
|
||||
d3d9_cg_set_shader,
|
||||
d3d9_cg_free,
|
||||
"d3d9_cg",
|
||||
d3d9_set_viewport,
|
||||
d3d9_set_rotation,
|
||||
d3d9_viewport_info,
|
||||
d3d9_read_viewport,
|
||||
NULL, /* read_frame_raw */
|
||||
#ifdef HAVE_OVERLAY
|
||||
d3d9_get_overlay_interface,
|
||||
#endif
|
||||
#ifdef HAVE_VIDEO_LAYOUT
|
||||
NULL,
|
||||
#endif
|
||||
d3d9_cg_get_poke_interface,
|
||||
NULL, /* wrap_type_to_enum */
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
d3d9_cg_gfx_widgets_enabled
|
||||
#endif
|
||||
};
|
||||
@ -15,11 +15,12 @@
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* Direct3D 9 driver.
|
||||
/* Direct3D 9 driver with HLSL runtime backend.
|
||||
*
|
||||
* Minimum version : Direct3D 9.0 (2002)
|
||||
* Minimum OS : Windows 98, Windows 2000, Windows ME
|
||||
* Recommended OS : Windows XP
|
||||
* Requirements : HLSL or fixed function backend
|
||||
*/
|
||||
|
||||
#define CINTERFACE
|
||||
@ -70,29 +71,22 @@
|
||||
#endif
|
||||
|
||||
/* TODO/FIXME - Temporary workaround for D3D9 not being able to poll flags during init */
|
||||
static gfx_ctx_driver_t d3d9_fake_context;
|
||||
static gfx_ctx_driver_t d3d9_hlsl_fake_context;
|
||||
|
||||
static enum rarch_shader_type supported_shader_type = RARCH_SHADER_NONE;
|
||||
|
||||
extern d3d9_renderchain_driver_t cg_d3d9_renderchain;
|
||||
extern d3d9_renderchain_driver_t hlsl_d3d9_renderchain;
|
||||
|
||||
static uint32_t d3d9_get_flags(void *data)
|
||||
static uint32_t d3d9_hlsl_get_flags(void *data)
|
||||
{
|
||||
uint32_t flags = 0;
|
||||
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
|
||||
|
||||
if (supported_shader_type == RARCH_SHADER_CG)
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);
|
||||
else if (supported_shader_type == RARCH_SHADER_HLSL)
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_HLSL);
|
||||
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_HLSL);
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static void d3d9_deinit_chain(d3d9_video_t *d3d)
|
||||
static void d3d9_hlsl_deinit_chain(d3d9_video_t *d3d)
|
||||
{
|
||||
if (!d3d || !d3d->renderchain_driver)
|
||||
return;
|
||||
@ -104,14 +98,11 @@ static void d3d9_deinit_chain(d3d9_video_t *d3d)
|
||||
d3d->renderchain_data = NULL;
|
||||
}
|
||||
|
||||
static void d3d9_deinitialize(d3d9_video_t *d3d)
|
||||
static void d3d9_hlsl_deinitialize(d3d9_video_t *d3d)
|
||||
{
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
font_driver_free_osd();
|
||||
|
||||
d3d9_deinit_chain(d3d);
|
||||
d3d9_hlsl_deinit_chain(d3d);
|
||||
d3d9_vertex_buffer_free(d3d->menu_display.buffer,
|
||||
d3d->menu_display.decl);
|
||||
|
||||
@ -119,7 +110,7 @@ static void d3d9_deinitialize(d3d9_video_t *d3d)
|
||||
d3d->menu_display.decl = NULL;
|
||||
}
|
||||
|
||||
static bool d3d9_init_base(d3d9_video_t *d3d, const video_info_t *info)
|
||||
static bool d3d9_hlsl_init_base(d3d9_video_t *d3d, const video_info_t *info)
|
||||
{
|
||||
D3DPRESENT_PARAMETERS d3dpp;
|
||||
#ifndef _XBOX
|
||||
@ -144,7 +135,7 @@ static bool d3d9_init_base(d3d9_video_t *d3d, const video_info_t *info)
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool renderchain_d3d_init_first(
|
||||
static bool renderchain_d3d_hlsl_init_first(
|
||||
enum gfx_ctx_api api,
|
||||
const d3d9_renderchain_driver_t **renderchain_driver,
|
||||
void **renderchain_handle)
|
||||
@ -155,12 +146,7 @@ static bool renderchain_d3d_init_first(
|
||||
{
|
||||
static const d3d9_renderchain_driver_t *renderchain_d3d_drivers[] =
|
||||
{
|
||||
#if defined(_WIN32) && defined(HAVE_CG)
|
||||
&cg_d3d9_renderchain,
|
||||
#endif
|
||||
#if defined(_WIN32) && defined(HAVE_HLSL)
|
||||
&hlsl_d3d9_renderchain,
|
||||
#endif
|
||||
NULL
|
||||
};
|
||||
unsigned i;
|
||||
@ -175,11 +161,6 @@ static bool renderchain_d3d_init_first(
|
||||
*renderchain_driver = renderchain_d3d_drivers[i];
|
||||
*renderchain_handle = data;
|
||||
|
||||
if (string_is_equal(renderchain_d3d_drivers[i]->ident, "cg_d3d9"))
|
||||
supported_shader_type = RARCH_SHADER_CG;
|
||||
else if (string_is_equal(renderchain_d3d_drivers[i]->ident, "hlsl_d3d9"))
|
||||
supported_shader_type = RARCH_SHADER_HLSL;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -192,8 +173,7 @@ static bool renderchain_d3d_init_first(
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
static bool d3d9_init_chain(d3d9_video_t *d3d,
|
||||
static bool d3d9_hlsl_init_chain(d3d9_video_t *d3d,
|
||||
unsigned input_scale,
|
||||
bool rgb32)
|
||||
{
|
||||
@ -209,7 +189,7 @@ static bool d3d9_init_chain(d3d9_video_t *d3d,
|
||||
link_info.tex_h = input_scale * RARCH_SCALE_BASE;
|
||||
link_info.pass = &d3d->shader.pass[0];
|
||||
|
||||
if (!renderchain_d3d_init_first(GFX_CTX_DIRECT3D9_API,
|
||||
if (!renderchain_d3d_hlsl_init_first(GFX_CTX_DIRECT3D9_API,
|
||||
&d3d->renderchain_driver,
|
||||
&d3d->renderchain_data))
|
||||
{
|
||||
@ -291,15 +271,14 @@ static bool d3d9_init_chain(d3d9_video_t *d3d,
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static bool d3d9_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
static bool d3d9_hlsl_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
{
|
||||
unsigned width, height;
|
||||
bool ret = true;
|
||||
settings_t *settings = config_get_ptr();
|
||||
|
||||
if (!g_pD3D9)
|
||||
ret = d3d9_init_base(d3d, info);
|
||||
ret = d3d9_hlsl_init_base(d3d, info);
|
||||
else if (d3d->needs_restore)
|
||||
{
|
||||
D3DPRESENT_PARAMETERS d3dpp;
|
||||
@ -316,11 +295,11 @@ static bool d3d9_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
|
||||
if (!d3d9_reset(d3d->dev, &d3dpp))
|
||||
{
|
||||
d3d9_deinitialize(d3d);
|
||||
d3d9_hlsl_deinitialize(d3d);
|
||||
d3d9_device_free(NULL, g_pD3D9);
|
||||
g_pD3D9 = NULL;
|
||||
|
||||
ret = d3d9_init_base(d3d, info);
|
||||
ret = d3d9_hlsl_init_base(d3d, info);
|
||||
if (ret)
|
||||
RARCH_LOG("[D3D9]: Recovered from dead state.\n");
|
||||
}
|
||||
@ -333,7 +312,7 @@ static bool d3d9_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
if (!ret)
|
||||
return ret;
|
||||
|
||||
if (!d3d9_init_chain(d3d, info->input_scale, info->rgb32))
|
||||
if (!d3d9_hlsl_init_chain(d3d, info->input_scale, info->rgb32))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to initialize render chain.\n");
|
||||
return false;
|
||||
@ -388,12 +367,11 @@ static bool d3d9_initialize(d3d9_video_t *d3d, const video_info_t *info)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static bool d3d9_restore(d3d9_video_t *d3d)
|
||||
static bool d3d9_hlsl_restore(d3d9_video_t *d3d)
|
||||
{
|
||||
d3d9_deinitialize(d3d);
|
||||
d3d9_hlsl_deinitialize(d3d);
|
||||
|
||||
if (!d3d9_initialize(d3d, &d3d->video_info))
|
||||
if (!d3d9_hlsl_initialize(d3d, &d3d->video_info))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Restore error.\n");
|
||||
return false;
|
||||
@ -404,11 +382,9 @@ static bool d3d9_restore(d3d9_video_t *d3d)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static bool d3d9_set_shader(void *data,
|
||||
static bool d3d9_hlsl_set_shader(void *data,
|
||||
enum rarch_shader_type type, const char *path)
|
||||
{
|
||||
#if defined(HAVE_CG) || defined(HAVE_HLSL)
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
@ -422,14 +398,6 @@ static bool d3d9_set_shader(void *data,
|
||||
{
|
||||
case RARCH_SHADER_CG:
|
||||
case RARCH_SHADER_HLSL:
|
||||
|
||||
if (type != supported_shader_type)
|
||||
{
|
||||
RARCH_WARN("[D3D9]: Shader preset %s is using unsupported shader type %s, falling back to stock %s.\n",
|
||||
path, video_shader_type_to_str(type), video_shader_type_to_str(supported_shader_type));
|
||||
break;
|
||||
}
|
||||
|
||||
if (!string_is_empty(path))
|
||||
d3d->shader_path = strdup(path);
|
||||
|
||||
@ -440,19 +408,16 @@ static bool d3d9_set_shader(void *data,
|
||||
RARCH_WARN("[D3D9]: Only Cg shaders are supported. Falling back to stock.\n");
|
||||
}
|
||||
|
||||
if (!d3d9_process_shader(d3d) || !d3d9_restore(d3d))
|
||||
if (!d3d9_process_shader(d3d) || !d3d9_hlsl_restore(d3d))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to set shader.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool d3d9_init_internal(d3d9_video_t *d3d,
|
||||
static bool d3d9_hlsl_init_internal(d3d9_video_t *d3d,
|
||||
const video_info_t *info, input_driver_t **input,
|
||||
void **input_data)
|
||||
{
|
||||
@ -544,22 +509,20 @@ static bool d3d9_init_internal(d3d9_video_t *d3d,
|
||||
|
||||
d3d->video_info = *info;
|
||||
|
||||
if (!d3d9_initialize(d3d, &d3d->video_info))
|
||||
if (!d3d9_hlsl_initialize(d3d, &d3d->video_info))
|
||||
return false;
|
||||
|
||||
d3d9_fake_context.get_flags = d3d9_get_flags;
|
||||
d3d9_hlsl_fake_context.get_flags = d3d9_hlsl_get_flags;
|
||||
#ifndef _XBOX_
|
||||
d3d9_fake_context.get_metrics = win32_get_metrics;
|
||||
d3d9_hlsl_fake_context.get_metrics = win32_get_metrics;
|
||||
#endif
|
||||
video_context_driver_set(&d3d9_fake_context);
|
||||
#if defined(HAVE_CG) || defined(HAVE_HLSL)
|
||||
video_context_driver_set(&d3d9_hlsl_fake_context);
|
||||
{
|
||||
const char *shader_preset = retroarch_get_shader_preset();
|
||||
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
|
||||
|
||||
d3d9_set_shader(d3d, type, shader_preset);
|
||||
d3d9_hlsl_set_shader(d3d, type, shader_preset);
|
||||
}
|
||||
#endif
|
||||
|
||||
d3d_input_driver(settings->arrays.input_joypad_driver,
|
||||
settings->arrays.input_joypad_driver, input, input_data);
|
||||
@ -589,7 +552,7 @@ static bool d3d9_init_internal(d3d9_video_t *d3d,
|
||||
return true;
|
||||
}
|
||||
|
||||
static void *d3d9_init(const video_info_t *info,
|
||||
static void *d3d9_hlsl_init(const video_info_t *info,
|
||||
input_driver_t **input, void **input_data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)calloc(1, sizeof(*d3d));
|
||||
@ -618,7 +581,7 @@ static void *d3d9_init(const video_info_t *info,
|
||||
d3d->should_resize = false;
|
||||
d3d->menu = NULL;
|
||||
|
||||
if (!d3d9_init_internal(d3d, info, input, input_data))
|
||||
if (!d3d9_hlsl_init_internal(d3d, info, input, input_data))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to init D3D.\n");
|
||||
free(d3d);
|
||||
@ -630,7 +593,7 @@ static void *d3d9_init(const video_info_t *info,
|
||||
return d3d;
|
||||
}
|
||||
|
||||
static void d3d9_free(void *data)
|
||||
static void d3d9_hlsl_free(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
@ -650,7 +613,7 @@ static void d3d9_free(void *data)
|
||||
free(d3d->menu);
|
||||
d3d->menu = NULL;
|
||||
|
||||
d3d9_deinitialize(d3d);
|
||||
d3d9_hlsl_deinitialize(d3d);
|
||||
|
||||
if (!string_is_empty(d3d->shader_path))
|
||||
free(d3d->shader_path);
|
||||
@ -669,7 +632,7 @@ static void d3d9_free(void *data)
|
||||
free(d3d);
|
||||
}
|
||||
|
||||
static bool d3d9_frame(void *data, const void *frame,
|
||||
static bool d3d9_hlsl_frame(void *data, const void *frame,
|
||||
unsigned frame_width, unsigned frame_height,
|
||||
uint64_t frame_count, unsigned pitch,
|
||||
const char *msg, video_frame_info_t *video_info)
|
||||
@ -702,7 +665,7 @@ static bool d3d9_frame(void *data, const void *frame,
|
||||
return true;
|
||||
#endif
|
||||
|
||||
if (!d3d9_restore(d3d))
|
||||
if (!d3d9_hlsl_restore(d3d))
|
||||
{
|
||||
RARCH_ERR("[D3D9]: Failed to restore.\n");
|
||||
return false;
|
||||
@ -824,8 +787,8 @@ static bool d3d9_frame(void *data, const void *frame,
|
||||
return true;
|
||||
}
|
||||
|
||||
static const video_poke_interface_t d3d9_poke_interface = {
|
||||
d3d9_get_flags,
|
||||
static const video_poke_interface_t d3d9_hlsl_poke_interface = {
|
||||
d3d9_hlsl_get_flags,
|
||||
d3d9_load_texture,
|
||||
d3d9_unload_texture,
|
||||
d3d9_set_video_mode,
|
||||
@ -858,20 +821,20 @@ static const video_poke_interface_t d3d9_poke_interface = {
|
||||
NULL /* set_hdr_expand_gamut */
|
||||
};
|
||||
|
||||
static void d3d9_get_poke_interface(void *data,
|
||||
static void d3d9_hlsl_get_poke_interface(void *data,
|
||||
const video_poke_interface_t **iface)
|
||||
{
|
||||
*iface = &d3d9_poke_interface;
|
||||
*iface = &d3d9_hlsl_poke_interface;
|
||||
}
|
||||
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
static bool d3d9_gfx_widgets_enabled(void *data)
|
||||
static bool d3d9_hlsl_gfx_widgets_enabled(void *data)
|
||||
{
|
||||
return false; /* currently disabled due to memory issues */
|
||||
}
|
||||
#endif
|
||||
|
||||
static void d3d9_set_resize(d3d9_video_t *d3d,
|
||||
static void d3d9_hlsl_set_resize(d3d9_video_t *d3d,
|
||||
unsigned new_width, unsigned new_height)
|
||||
{
|
||||
/* No changes? */
|
||||
@ -884,7 +847,7 @@ static void d3d9_set_resize(d3d9_video_t *d3d,
|
||||
video_driver_set_size(new_width, new_height);
|
||||
}
|
||||
|
||||
static bool d3d9_alive(void *data)
|
||||
static bool d3d9_hlsl_alive(void *data)
|
||||
{
|
||||
unsigned temp_width = 0;
|
||||
unsigned temp_height = 0;
|
||||
@ -904,8 +867,8 @@ static bool d3d9_alive(void *data)
|
||||
if (resize)
|
||||
{
|
||||
d3d->should_resize = true;
|
||||
d3d9_set_resize(d3d, temp_width, temp_height);
|
||||
d3d9_restore(d3d);
|
||||
d3d9_hlsl_set_resize(d3d, temp_width, temp_height);
|
||||
d3d9_hlsl_restore(d3d);
|
||||
}
|
||||
|
||||
ret = !quit;
|
||||
@ -917,7 +880,7 @@ static bool d3d9_alive(void *data)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void d3d9_set_nonblock_state(void *data, bool state,
|
||||
static void d3d9_hlsl_set_nonblock_state(void *data, bool state,
|
||||
bool adaptive_vsync_enabled,
|
||||
unsigned swap_interval)
|
||||
{
|
||||
@ -944,21 +907,21 @@ static void d3d9_set_nonblock_state(void *data, bool state,
|
||||
);
|
||||
#else
|
||||
d3d->needs_restore = true;
|
||||
d3d9_restore(d3d);
|
||||
d3d9_hlsl_restore(d3d);
|
||||
#endif
|
||||
}
|
||||
|
||||
video_driver_t video_d3d9 = {
|
||||
d3d9_init,
|
||||
d3d9_frame,
|
||||
d3d9_set_nonblock_state,
|
||||
d3d9_alive,
|
||||
video_driver_t video_d3d9_hlsl = {
|
||||
d3d9_hlsl_init,
|
||||
d3d9_hlsl_frame,
|
||||
d3d9_hlsl_set_nonblock_state,
|
||||
d3d9_hlsl_alive,
|
||||
NULL, /* focus */
|
||||
d3d9_suppress_screensaver,
|
||||
d3d9_has_windowed,
|
||||
d3d9_set_shader,
|
||||
d3d9_free,
|
||||
"d3d9",
|
||||
d3d9_hlsl_set_shader,
|
||||
d3d9_hlsl_free,
|
||||
"d3d9_hlsl",
|
||||
d3d9_set_viewport,
|
||||
d3d9_set_rotation,
|
||||
d3d9_viewport_info,
|
||||
@ -970,9 +933,9 @@ video_driver_t video_d3d9 = {
|
||||
#ifdef HAVE_VIDEO_LAYOUT
|
||||
NULL,
|
||||
#endif
|
||||
d3d9_get_poke_interface,
|
||||
d3d9_hlsl_get_poke_interface,
|
||||
NULL, /* wrap_type_to_enum */
|
||||
#ifdef HAVE_GFX_WIDGETS
|
||||
d3d9_gfx_widgets_enabled
|
||||
d3d9_hlsl_gfx_widgets_enabled
|
||||
#endif
|
||||
};
|
||||
325
gfx/drivers_display/gfx_display_d3d9cg.c
Normal file
325
gfx/drivers_display/gfx_display_d3d9cg.c
Normal file
@ -0,0 +1,325 @@
|
||||
/* RetroArch - A frontend for libretro.
|
||||
* Copyright (C) 2011-2017 - Daniel De Matteis
|
||||
*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#define CINTERFACE
|
||||
|
||||
#include <retro_miscellaneous.h>
|
||||
|
||||
#include <gfx/math/matrix_4x4.h>
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "../../config.h"
|
||||
#endif
|
||||
|
||||
#include "../gfx_display.h"
|
||||
|
||||
#include "../../retroarch.h"
|
||||
#include "../common/d3d_common.h"
|
||||
#include "../common/d3d9_common.h"
|
||||
|
||||
static const float d3d9_cg_vertexes[] = {
|
||||
0, 0,
|
||||
1, 0,
|
||||
0, 1,
|
||||
1, 1
|
||||
};
|
||||
|
||||
static const float d3d9_cg_tex_coords[] = {
|
||||
0, 1,
|
||||
1, 1,
|
||||
0, 0,
|
||||
1, 0
|
||||
};
|
||||
|
||||
static const float *gfx_display_d3d9_cg_get_default_vertices(void)
|
||||
{
|
||||
return &d3d9_cg_vertexes[0];
|
||||
}
|
||||
|
||||
static const float *gfx_display_d3d9_cg_get_default_tex_coords(void)
|
||||
{
|
||||
return &d3d9_cg_tex_coords[0];
|
||||
}
|
||||
|
||||
static void *gfx_display_d3d9_cg_get_default_mvp(void *data)
|
||||
{
|
||||
static float id[] = { 1.0f, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, 1.0f, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, 1.0f, 0.0f,
|
||||
0.0f, 0.0f, 0.0f, 1.0f
|
||||
};
|
||||
return &id;
|
||||
}
|
||||
|
||||
static INT32 gfx_display_prim_to_d3d9_cg_enum(
|
||||
enum gfx_display_prim_type prim_type)
|
||||
{
|
||||
switch (prim_type)
|
||||
{
|
||||
case GFX_DISPLAY_PRIM_TRIANGLES:
|
||||
case GFX_DISPLAY_PRIM_TRIANGLESTRIP:
|
||||
return D3DPT_COMM_TRIANGLESTRIP;
|
||||
case GFX_DISPLAY_PRIM_NONE:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* TODO/FIXME - hack */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_cg_blend_begin(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
d3d9_enable_blend_func(d3d->dev);
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_cg_blend_end(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d)
|
||||
return;
|
||||
|
||||
d3d9_disable_blend_func(d3d->dev);
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_cg_bind_texture(gfx_display_ctx_draw_t *draw,
|
||||
d3d9_video_t *d3d)
|
||||
{
|
||||
LPDIRECT3DDEVICE9 dev = d3d->dev;
|
||||
|
||||
d3d9_set_texture(dev, 0, (LPDIRECT3DTEXTURE9)draw->texture);
|
||||
d3d9_set_sampler_address_u(dev, 0, D3DTADDRESS_COMM_CLAMP);
|
||||
d3d9_set_sampler_address_v(dev, 0, D3DTADDRESS_COMM_CLAMP);
|
||||
d3d9_set_sampler_minfilter(dev, 0, D3DTEXF_COMM_LINEAR);
|
||||
d3d9_set_sampler_magfilter(dev, 0, D3DTEXF_COMM_LINEAR);
|
||||
d3d9_set_sampler_mipfilter(dev, 0, D3DTEXF_COMM_LINEAR);
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_cg_draw(gfx_display_ctx_draw_t *draw,
|
||||
void *data, unsigned video_width, unsigned video_height)
|
||||
{
|
||||
unsigned i;
|
||||
math_matrix_4x4 mop, m1, m2;
|
||||
LPDIRECT3DDEVICE9 dev;
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
Vertex * pv = NULL;
|
||||
const float *vertex = NULL;
|
||||
const float *tex_coord = NULL;
|
||||
const float *color = NULL;
|
||||
|
||||
if (!d3d || !draw || draw->pipeline_id)
|
||||
return;
|
||||
|
||||
dev = d3d->dev;
|
||||
|
||||
if ((d3d->menu_display.offset + draw->coords->vertices )
|
||||
> (unsigned)d3d->menu_display.size)
|
||||
return;
|
||||
|
||||
pv = (Vertex*)
|
||||
d3d9_vertex_buffer_lock((LPDIRECT3DVERTEXBUFFER9)
|
||||
d3d->menu_display.buffer);
|
||||
|
||||
if (!pv)
|
||||
return;
|
||||
|
||||
pv += d3d->menu_display.offset;
|
||||
vertex = draw->coords->vertex;
|
||||
tex_coord = draw->coords->tex_coord;
|
||||
color = draw->coords->color;
|
||||
|
||||
if (!vertex)
|
||||
vertex = &d3d9_cg_vertexes[0];
|
||||
if (!tex_coord)
|
||||
tex_coord = &d3d9_cg_tex_coords[0];
|
||||
|
||||
for (i = 0; i < draw->coords->vertices; i++)
|
||||
{
|
||||
int colors[4];
|
||||
|
||||
colors[0] = *color++ * 0xFF;
|
||||
colors[1] = *color++ * 0xFF;
|
||||
colors[2] = *color++ * 0xFF;
|
||||
colors[3] = *color++ * 0xFF;
|
||||
|
||||
pv[i].x = *vertex++;
|
||||
pv[i].y = *vertex++;
|
||||
pv[i].z = 0.5f;
|
||||
pv[i].u = *tex_coord++;
|
||||
pv[i].v = *tex_coord++;
|
||||
|
||||
pv[i].color =
|
||||
D3DCOLOR_ARGB(
|
||||
colors[3], /* A */
|
||||
colors[0], /* R */
|
||||
colors[1], /* G */
|
||||
colors[2] /* B */
|
||||
);
|
||||
}
|
||||
d3d9_vertex_buffer_unlock((LPDIRECT3DVERTEXBUFFER9)
|
||||
d3d->menu_display.buffer);
|
||||
|
||||
if (!draw->matrix_data)
|
||||
draw->matrix_data = gfx_display_d3d9_cg_get_default_mvp(d3d);
|
||||
|
||||
/* ugh */
|
||||
matrix_4x4_scale(m1, 2.0, 2.0, 0);
|
||||
matrix_4x4_translate(mop, -1.0, -1.0, 0);
|
||||
matrix_4x4_multiply(m2, mop, m1);
|
||||
matrix_4x4_multiply(m1,
|
||||
*((math_matrix_4x4*)draw->matrix_data), m2);
|
||||
matrix_4x4_scale(mop,
|
||||
(draw->width / 2.0) / video_width,
|
||||
(draw->height / 2.0) / video_height, 0);
|
||||
matrix_4x4_multiply(m2, mop, m1);
|
||||
matrix_4x4_translate(mop,
|
||||
(draw->x + (draw->width / 2.0)) / video_width,
|
||||
(draw->y + (draw->height / 2.0)) / video_height,
|
||||
0);
|
||||
matrix_4x4_multiply(m1, mop, m2);
|
||||
matrix_4x4_multiply(m2, d3d->mvp_transposed, m1);
|
||||
|
||||
d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const float*)&m2, 4);
|
||||
|
||||
if (draw && draw->texture)
|
||||
gfx_display_d3d9_cg_bind_texture(draw, d3d);
|
||||
|
||||
d3d9_draw_primitive(dev,
|
||||
(D3DPRIMITIVETYPE)gfx_display_prim_to_d3d9_cg_enum(draw->prim_type),
|
||||
d3d->menu_display.offset,
|
||||
draw->coords->vertices -
|
||||
((draw->prim_type == GFX_DISPLAY_PRIM_TRIANGLESTRIP)
|
||||
? 2 : 0));
|
||||
|
||||
d3d->menu_display.offset += draw->coords->vertices;
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_cg_draw_pipeline(gfx_display_ctx_draw_t *draw,
|
||||
gfx_display_t *p_disp,
|
||||
void *data, unsigned video_width, unsigned video_height)
|
||||
{
|
||||
#if defined(HAVE_HLSL) || defined(HAVE_CG)
|
||||
static float t = 0;
|
||||
video_coord_array_t *ca = NULL;
|
||||
|
||||
if (!draw)
|
||||
return;
|
||||
|
||||
ca = &p_disp->dispca;
|
||||
|
||||
draw->x = 0;
|
||||
draw->y = 0;
|
||||
draw->coords = NULL;
|
||||
draw->matrix_data = NULL;
|
||||
|
||||
if (ca)
|
||||
draw->coords = (struct video_coords*)&ca->coords;
|
||||
|
||||
switch (draw->pipeline_id)
|
||||
{
|
||||
case VIDEO_SHADER_MENU:
|
||||
case VIDEO_SHADER_MENU_2:
|
||||
case VIDEO_SHADER_MENU_3:
|
||||
{
|
||||
struct uniform_info uniform_param = {0};
|
||||
t += 0.01;
|
||||
|
||||
(void)uniform_param;
|
||||
|
||||
uniform_param.enabled = true;
|
||||
uniform_param.lookup.enable = true;
|
||||
uniform_param.lookup.add_prefix = true;
|
||||
uniform_param.lookup.idx = draw->pipeline_id;
|
||||
uniform_param.lookup.type = SHADER_PROGRAM_VERTEX;
|
||||
uniform_param.type = UNIFORM_1F;
|
||||
uniform_param.lookup.ident = "time";
|
||||
uniform_param.result.f.v0 = t;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool gfx_display_d3d9_font_init_first(
|
||||
void **font_handle, void *video_data,
|
||||
const char *font_path, float menu_font_size,
|
||||
bool is_threaded)
|
||||
{
|
||||
font_data_t **handle = (font_data_t**)font_handle;
|
||||
if (!(*handle = font_driver_init_first(video_data,
|
||||
font_path, menu_font_size, true,
|
||||
is_threaded,
|
||||
FONT_DRIVER_RENDER_D3D9_API)))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void gfx_display_d3d9_cg_scissor_begin(
|
||||
void *data,
|
||||
unsigned video_width, unsigned video_height,
|
||||
int x, int y, unsigned width, unsigned height)
|
||||
{
|
||||
RECT rect;
|
||||
d3d9_video_t *d3d9 = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d9 || !width || !height)
|
||||
return;
|
||||
|
||||
rect.left = x;
|
||||
rect.top = y;
|
||||
rect.right = width + x;
|
||||
rect.bottom = height + y;
|
||||
|
||||
d3d9_set_scissor_rect(d3d9->dev, &rect);
|
||||
}
|
||||
|
||||
void gfx_display_d3d9_cg_scissor_end(void *data,
|
||||
unsigned video_width, unsigned video_height)
|
||||
{
|
||||
RECT rect;
|
||||
d3d9_video_t *d3d9 = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d9)
|
||||
return;
|
||||
|
||||
rect.left = 0;
|
||||
rect.top = 0;
|
||||
rect.right = video_width;
|
||||
rect.bottom = video_height;
|
||||
|
||||
d3d9_set_scissor_rect(d3d9->dev, &rect);
|
||||
}
|
||||
|
||||
gfx_display_ctx_driver_t gfx_display_ctx_d3d9 = {
|
||||
gfx_display_d3d9_cg_draw,
|
||||
gfx_display_d3d9_cg_draw_pipeline,
|
||||
gfx_display_d3d9_cg_blend_begin,
|
||||
gfx_display_d3d9_cg_blend_end,
|
||||
gfx_display_d3d9_cg_get_default_mvp,
|
||||
gfx_display_d3d9_cg_get_default_vertices,
|
||||
gfx_display_d3d9_cg_get_default_tex_coords,
|
||||
gfx_display_d3d9_font_init_first,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9_CG,
|
||||
"d3d9_cg",
|
||||
false,
|
||||
gfx_display_d3d9_cg_scissor_begin,
|
||||
gfx_display_d3d9_cg_scissor_end
|
||||
};
|
||||
@ -29,31 +29,31 @@
|
||||
#include "../common/d3d_common.h"
|
||||
#include "../common/d3d9_common.h"
|
||||
|
||||
static const float d3d9_vertexes[] = {
|
||||
static const float d3d9_hlsl_vertexes[] = {
|
||||
0, 0,
|
||||
1, 0,
|
||||
0, 1,
|
||||
1, 1
|
||||
};
|
||||
|
||||
static const float d3d9_tex_coords[] = {
|
||||
static const float d3d9_hlsl_tex_coords[] = {
|
||||
0, 1,
|
||||
1, 1,
|
||||
0, 0,
|
||||
1, 0
|
||||
};
|
||||
|
||||
static const float *gfx_display_d3d9_get_default_vertices(void)
|
||||
static const float *gfx_display_d3d9_hlsl_get_default_vertices(void)
|
||||
{
|
||||
return &d3d9_vertexes[0];
|
||||
return &d3d9_hlsl_vertexes[0];
|
||||
}
|
||||
|
||||
static const float *gfx_display_d3d9_get_default_tex_coords(void)
|
||||
static const float *gfx_display_d3d9_hlsl_get_default_tex_coords(void)
|
||||
{
|
||||
return &d3d9_tex_coords[0];
|
||||
return &d3d9_hlsl_tex_coords[0];
|
||||
}
|
||||
|
||||
static void *gfx_display_d3d9_get_default_mvp(void *data)
|
||||
static void *gfx_display_d3d9_hlsl_get_default_mvp(void *data)
|
||||
{
|
||||
static float id[] = { 1.0f, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, 1.0f, 0.0f, 0.0f,
|
||||
@ -80,7 +80,7 @@ static INT32 gfx_display_prim_to_d3d9_enum(
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_blend_begin(void *data)
|
||||
static void gfx_display_d3d9_hlsl_blend_begin(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
@ -90,7 +90,7 @@ static void gfx_display_d3d9_blend_begin(void *data)
|
||||
d3d9_enable_blend_func(d3d->dev);
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_blend_end(void *data)
|
||||
static void gfx_display_d3d9_hlsl_blend_end(void *data)
|
||||
{
|
||||
d3d9_video_t *d3d = (d3d9_video_t*)data;
|
||||
|
||||
@ -113,7 +113,7 @@ static void gfx_display_d3d9_bind_texture(gfx_display_ctx_draw_t *draw,
|
||||
d3d9_set_sampler_mipfilter(dev, 0, D3DTEXF_COMM_LINEAR);
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_draw(gfx_display_ctx_draw_t *draw,
|
||||
static void gfx_display_d3d9_hlsl_draw(gfx_display_ctx_draw_t *draw,
|
||||
void *data, unsigned video_width, unsigned video_height)
|
||||
{
|
||||
unsigned i;
|
||||
@ -147,9 +147,9 @@ static void gfx_display_d3d9_draw(gfx_display_ctx_draw_t *draw,
|
||||
color = draw->coords->color;
|
||||
|
||||
if (!vertex)
|
||||
vertex = &d3d9_vertexes[0];
|
||||
vertex = &d3d9_hlsl_vertexes[0];
|
||||
if (!tex_coord)
|
||||
tex_coord = &d3d9_tex_coords[0];
|
||||
tex_coord = &d3d9_hlsl_tex_coords[0];
|
||||
|
||||
for (i = 0; i < draw->coords->vertices; i++)
|
||||
{
|
||||
@ -178,7 +178,7 @@ static void gfx_display_d3d9_draw(gfx_display_ctx_draw_t *draw,
|
||||
d3d->menu_display.buffer);
|
||||
|
||||
if (!draw->matrix_data)
|
||||
draw->matrix_data = gfx_display_d3d9_get_default_mvp(d3d);
|
||||
draw->matrix_data = gfx_display_d3d9_hlsl_get_default_mvp(d3d);
|
||||
|
||||
/* ugh */
|
||||
matrix_4x4_scale(m1, 2.0, 2.0, 0);
|
||||
@ -212,11 +212,10 @@ static void gfx_display_d3d9_draw(gfx_display_ctx_draw_t *draw,
|
||||
d3d->menu_display.offset += draw->coords->vertices;
|
||||
}
|
||||
|
||||
static void gfx_display_d3d9_draw_pipeline(gfx_display_ctx_draw_t *draw,
|
||||
static void gfx_display_d3d9_hlsl_draw_pipeline(gfx_display_ctx_draw_t *draw,
|
||||
gfx_display_t *p_disp,
|
||||
void *data, unsigned video_width, unsigned video_height)
|
||||
{
|
||||
#if defined(HAVE_HLSL) || defined(HAVE_CG)
|
||||
static float t = 0;
|
||||
video_coord_array_t *ca = NULL;
|
||||
|
||||
@ -255,7 +254,6 @@ static void gfx_display_d3d9_draw_pipeline(gfx_display_ctx_draw_t *draw,
|
||||
}
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool gfx_display_d3d9_font_init_first(
|
||||
@ -272,7 +270,7 @@ static bool gfx_display_d3d9_font_init_first(
|
||||
return true;
|
||||
}
|
||||
|
||||
void gfx_display_d3d9_scissor_begin(
|
||||
void gfx_display_d3d9_hlsl_scissor_begin(
|
||||
void *data,
|
||||
unsigned video_width, unsigned video_height,
|
||||
int x, int y, unsigned width, unsigned height)
|
||||
@ -291,11 +289,11 @@ void gfx_display_d3d9_scissor_begin(
|
||||
d3d9_set_scissor_rect(d3d9->dev, &rect);
|
||||
}
|
||||
|
||||
void gfx_display_d3d9_scissor_end(void *data,
|
||||
void gfx_display_d3d9_hlsl_scissor_end(void *data,
|
||||
unsigned video_width, unsigned video_height)
|
||||
{
|
||||
RECT rect;
|
||||
d3d9_video_t *d3d9 = (d3d9_video_t*)data;
|
||||
d3d9_video_t *d3d9 = (d3d9_video_t*)data;
|
||||
|
||||
if (!d3d9)
|
||||
return;
|
||||
@ -308,18 +306,18 @@ void gfx_display_d3d9_scissor_end(void *data,
|
||||
d3d9_set_scissor_rect(d3d9->dev, &rect);
|
||||
}
|
||||
|
||||
gfx_display_ctx_driver_t gfx_display_ctx_d3d9 = {
|
||||
gfx_display_d3d9_draw,
|
||||
gfx_display_d3d9_draw_pipeline,
|
||||
gfx_display_d3d9_blend_begin,
|
||||
gfx_display_d3d9_blend_end,
|
||||
gfx_display_d3d9_get_default_mvp,
|
||||
gfx_display_d3d9_get_default_vertices,
|
||||
gfx_display_d3d9_get_default_tex_coords,
|
||||
gfx_display_ctx_driver_t gfx_display_ctx_d3d9_hlsl = {
|
||||
gfx_display_d3d9_hlsl_draw,
|
||||
gfx_display_d3d9_hlsl_draw_pipeline,
|
||||
gfx_display_d3d9_hlsl_blend_begin,
|
||||
gfx_display_d3d9_hlsl_blend_end,
|
||||
gfx_display_d3d9_hlsl_get_default_mvp,
|
||||
gfx_display_d3d9_hlsl_get_default_vertices,
|
||||
gfx_display_d3d9_hlsl_get_default_tex_coords,
|
||||
gfx_display_d3d9_font_init_first,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9,
|
||||
"d3d9",
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9_HLSL,
|
||||
"d3d9_hlsl",
|
||||
false,
|
||||
gfx_display_d3d9_scissor_begin,
|
||||
gfx_display_d3d9_scissor_end
|
||||
gfx_display_d3d9_hlsl_scissor_begin,
|
||||
gfx_display_d3d9_hlsl_scissor_end
|
||||
};
|
||||
@ -85,7 +85,12 @@ static gfx_display_ctx_driver_t *gfx_display_ctx_drivers[] = {
|
||||
&gfx_display_ctx_d3d8,
|
||||
#endif
|
||||
#ifdef HAVE_D3D9
|
||||
&gfx_display_ctx_d3d9,
|
||||
#ifdef HAVE_HLSL
|
||||
&gfx_display_ctx_d3d9_hlsl,
|
||||
#endif
|
||||
#ifdef HAVE_CG
|
||||
&gfx_display_ctx_d3d9_cg,
|
||||
#endif
|
||||
#endif
|
||||
#ifdef HAVE_D3D10
|
||||
&gfx_display_ctx_d3d10,
|
||||
@ -191,8 +196,12 @@ static bool gfx_display_check_compatibility(
|
||||
if (string_is_equal(video_driver, "d3d8"))
|
||||
return true;
|
||||
break;
|
||||
case GFX_VIDEO_DRIVER_DIRECT3D9:
|
||||
if (string_is_equal(video_driver, "d3d9"))
|
||||
case GFX_VIDEO_DRIVER_DIRECT3D9_HLSL:
|
||||
if (string_is_equal(video_driver, "d3d9_hlsl"))
|
||||
return true;
|
||||
break;
|
||||
case GFX_VIDEO_DRIVER_DIRECT3D9_CG:
|
||||
if (string_is_equal(video_driver, "d3d9_cg"))
|
||||
return true;
|
||||
break;
|
||||
case GFX_VIDEO_DRIVER_DIRECT3D10:
|
||||
|
||||
@ -96,7 +96,8 @@ enum gfx_display_driver_type
|
||||
GFX_VIDEO_DRIVER_VULKAN,
|
||||
GFX_VIDEO_DRIVER_METAL,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D8,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9_CG,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D9_HLSL,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D10,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D11,
|
||||
GFX_VIDEO_DRIVER_DIRECT3D12,
|
||||
@ -352,7 +353,8 @@ extern gfx_display_ctx_driver_t gfx_display_ctx_gl1;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_vulkan;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_metal;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d8;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d9;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d9_cg;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d9_hlsl;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d10;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d11;
|
||||
extern gfx_display_ctx_driver_t gfx_display_ctx_d3d12;
|
||||
|
||||
@ -301,7 +301,12 @@ const video_driver_t *video_drivers[] = {
|
||||
&video_d3d10,
|
||||
#endif
|
||||
#if defined(HAVE_D3D9)
|
||||
&video_d3d9,
|
||||
#if defined(HAVE_HLSL)
|
||||
&video_d3d9_hlsl,
|
||||
#endif
|
||||
#if defined(HAVE_CG)
|
||||
&video_d3d9_cg,
|
||||
#endif
|
||||
#endif
|
||||
#if defined(HAVE_D3D8)
|
||||
&video_d3d8,
|
||||
@ -453,8 +458,10 @@ video_driver_t *hw_render_context_driver(
|
||||
#endif
|
||||
case RETRO_HW_CONTEXT_DIRECT3D:
|
||||
#if defined(HAVE_D3D9)
|
||||
#if defined(HAVE_HLSL)
|
||||
if (major == 9)
|
||||
return &video_d3d9;
|
||||
return &video_d3d9_hlsl;
|
||||
#endif
|
||||
#endif
|
||||
#if defined(HAVE_D3D11)
|
||||
if (major == 11)
|
||||
@ -506,8 +513,10 @@ const char *hw_render_context_name(
|
||||
return "d3d11";
|
||||
#endif
|
||||
#ifdef HAVE_D3D9
|
||||
#if defined(HAVE_HLSL)
|
||||
if (type == RETRO_HW_CONTEXT_DIRECT3D && major == 9)
|
||||
return "d3d9";
|
||||
return "d3d9_hlsl";
|
||||
#endif
|
||||
#endif
|
||||
return "N/A";
|
||||
}
|
||||
@ -531,7 +540,7 @@ enum retro_hw_context_type hw_render_context_type(const char *s)
|
||||
return RETRO_HW_CONTEXT_DIRECT3D;
|
||||
#endif
|
||||
#ifdef HAVE_D3D11
|
||||
if (string_is_equal(s, "d3d9"))
|
||||
if (string_is_equal(s, "d3d9_hlsl"))
|
||||
return RETRO_HW_CONTEXT_DIRECT3D;
|
||||
#endif
|
||||
return RETRO_HW_CONTEXT_NONE;
|
||||
@ -3134,7 +3143,7 @@ enum gfx_ctx_api video_context_driver_get_api(void)
|
||||
: NULL;
|
||||
if (string_starts_with_size(video_ident, "d3d", STRLEN_CONST("d3d")))
|
||||
{
|
||||
if (string_is_equal(video_ident, "d3d9"))
|
||||
if (string_is_equal(video_ident, "d3d9_hlsl"))
|
||||
return GFX_CTX_DIRECT3D9_API;
|
||||
else if (string_is_equal(video_ident, "d3d10"))
|
||||
return GFX_CTX_DIRECT3D10_API;
|
||||
|
||||
@ -1439,7 +1439,8 @@ extern video_driver_t video_ctr;
|
||||
extern video_driver_t video_gcm;
|
||||
extern video_driver_t video_switch;
|
||||
extern video_driver_t video_d3d8;
|
||||
extern video_driver_t video_d3d9;
|
||||
extern video_driver_t video_d3d9_cg;
|
||||
extern video_driver_t video_d3d9_hlsl;
|
||||
extern video_driver_t video_d3d10;
|
||||
extern video_driver_t video_d3d11;
|
||||
extern video_driver_t video_d3d12;
|
||||
|
||||
@ -419,15 +419,17 @@ VIDEO DRIVER
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_D3D9)
|
||||
#include "../gfx/drivers/d3d9.c"
|
||||
#include "../gfx/common/d3d9_common.c"
|
||||
#include "../gfx/drivers_display/gfx_display_d3d9.c"
|
||||
|
||||
#ifdef HAVE_HLSL
|
||||
#include "../gfx/drivers/d3d9hlsl.c"
|
||||
#include "../gfx/drivers_display/gfx_display_d3d9hlsl.c"
|
||||
#include "../gfx/drivers_renderchain/d3d9_hlsl_renderchain.c"
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CG
|
||||
#include "../gfx/drivers/d3d9cg.c"
|
||||
#include "../gfx/drivers_display/gfx_display_d3d9cg.c"
|
||||
#include "../gfx/drivers_renderchain/d3d9_cg_renderchain.c"
|
||||
#endif
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user