1
0
mirror of https://github.com/libretro/RetroArch synced 2025-02-16 03:40:12 +00:00

Create separate D3D8 and D3D9 drivers

This commit is contained in:
twinaphex 2018-01-23 02:55:33 +01:00
parent 1a20fff7f2
commit d28d14079a
12 changed files with 3296 additions and 701 deletions

@ -1333,9 +1333,19 @@ ifeq ($(HAVE_DX_COMMON), 1)
LIBS += -ldxguid
endif
ifeq ($(HAVE_D3D8), 1)
DEFINES += -DHAVE_D3D8
OBJ += gfx/drivers/d3d9.o
endif
ifeq ($(HAVE_D3D9), 1)
DEFINES += -DHAVE_D3D9
OBJ += gfx/drivers/d3d9.o
endif
ifeq ($(HAVE_D3D_COMMON), 1)
DEFINES += -DHAVE_D3D
OBJ += gfx/drivers/d3d.o \
OBJ += \
gfx/common/d3d_common.o \
gfx/drivers_context/d3d_ctx.o

@ -126,11 +126,11 @@ enum video_driver_enum
VIDEO_WII,
VIDEO_WIIU,
VIDEO_XENON360,
VIDEO_XDK_D3D,
VIDEO_PSP1,
VIDEO_VITA2D,
VIDEO_CTR,
VIDEO_SWITCH,
VIDEO_D3D8,
VIDEO_D3D9,
VIDEO_D3D11,
VIDEO_D3D12,
@ -283,10 +283,10 @@ static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_WII;
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_WIIU;
#elif defined(XENON)
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_XENON360;
#elif (defined(_XBOX1) || defined(_XBOX360)) && (defined(HAVE_D3D8) || defined(HAVE_D3D9))
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_XDK_D3D;
#elif defined(HAVE_D3D9)
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D9;
#elif defined(HAVE_D3D8)
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D8;
#elif defined(HAVE_VG)
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_VG;
#elif defined(HAVE_VITA2D)
@ -694,9 +694,10 @@ const char *config_get_default_video(void)
return "gx2";
case VIDEO_XENON360:
return "xenon360";
case VIDEO_XDK_D3D:
case VIDEO_D3D8:
return "d3d8";
case VIDEO_D3D9:
return "d3d";
return "d3d9";
case VIDEO_D3D11:
return "d3d11";
case VIDEO_D3D12:

File diff suppressed because it is too large Load Diff

@ -19,11 +19,17 @@
#include <boolean.h>
#include <retro_common_api.h>
#include "win32_common.h"
#include "../../defines/d3d_defines.h"
RETRO_BEGIN_DECLS
enum d3d_comm_api
{
D3D_COMM_NONE = 0,
D3D_COMM_D3D8,
D3D_COMM_D3D9
};
typedef struct d3d_texture
{
LPDIRECT3DTEXTURE data;
@ -207,7 +213,7 @@ void d3d_device_free(LPDIRECT3DDEVICE dev, LPDIRECT3D pd3d);
void *d3d_create(void);
bool d3d_initialize_symbols(void);
bool d3d_initialize_symbols(enum d3d_comm_api api);
void d3d_deinitialize_symbols(void);

@ -121,8 +121,9 @@ static bool d3d_init_chain(d3d_video_t *d3d, const video_info_t *video_info)
link_info.tex_h = video_info->input_scale * RARCH_SCALE_BASE;
link_info.pass = &d3d->shader.pass[0];
if (!renderchain_d3d_init_first(&d3d->renderchain_driver,
&d3d->renderchain_data))
if (!renderchain_d3d_init_first(D3D_COMM_D3D8,
&d3d->renderchain_driver,
&d3d->renderchain_data))
{
RARCH_ERR("[D3D]: Renderchain could not be initialized.\n");
return false;
@ -390,26 +391,7 @@ static void d3d_overlay_render(d3d_video_t *d3d,
d3d_vertex_buffer_unlock(overlay->vert_buf);
d3d_enable_blend_func(d3d->dev);
#if defined(HAVE_D3D9)
{
LPDIRECT3DVERTEXDECLARATION vertex_decl;
/* set vertex declaration for overlay. */
D3DVERTEXELEMENT vElems[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()
};
d3d_vertex_declaration_new(d3d->dev, &vElems, (void**)&vertex_decl);
d3d_set_vertex_declaration(d3d->dev, vertex_decl);
d3d_vertex_declaration_free(vertex_decl);
}
#elif defined(HAVE_D3D8)
d3d_set_vertex_shader(d3d->dev, D3DFVF_CUSTOMVERTEX, NULL);
#endif
d3d_set_stream_source(d3d->dev, 0, overlay->vert_buf,
0, sizeof(*vert));
@ -474,11 +456,7 @@ static void d3d_deinitialize(d3d_video_t *d3d)
d3d->menu_display.decl = NULL;
}
#if defined(HAVE_D3D8)
#define FS_PRESENTINTERVAL(pp) ((pp)->FullScreen_PresentationInterval)
#else
#define FS_PRESENTINTERVAL(pp) ((pp)->PresentationInterval)
#endif
static D3DFORMAT d3d_get_color_format_backbuffer(bool rgb32, bool windowed)
{
@ -497,13 +475,6 @@ static D3DFORMAT d3d_get_color_format_backbuffer(bool rgb32, bool windowed)
return fmt;
}
#ifdef _XBOX360
static D3DFORMAT d3d_get_color_format_front_buffer(void)
{
return D3DFMT_LE_X8R8G8B8;
}
#endif
static bool d3d_is_windowed_enable(bool info_fullscreen)
{
#ifndef _XBOX
@ -520,12 +491,6 @@ void d3d_make_d3dpp(void *data,
const video_info_t *info, D3DPRESENT_PARAMETERS *d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
#ifdef _XBOX360
/* TODO/FIXME - get rid of global state dependencies. */
global_t *global = global_get_ptr();
bool gamma_enable = global ?
global->console.screen.gamma_correction : false;
#endif
bool windowed_enable = d3d_is_windowed_enable(info->fullscreen);
memset(d3dpp, 0, sizeof(*d3dpp));
@ -555,11 +520,9 @@ void d3d_make_d3dpp(void *data,
}
}
#ifdef HAVE_D3D8
/* PresentationInterval must be zero for windowed mode on DX8. */
if (d3dpp->Windowed)
FS_PRESENTINTERVAL(d3dpp) = D3DPRESENT_INTERVAL_DEFAULT;
#endif
d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp->BackBufferCount = 2;
@ -569,18 +532,6 @@ void d3d_make_d3dpp(void *data,
d3dpp->hDeviceWindow = win32_get_window();
#endif
#ifdef _XBOX360
d3dpp->FrontBufferFormat = d3d_get_color_format_front_buffer();
if (gamma_enable)
{
d3dpp->BackBufferFormat = (D3DFORMAT)MAKESRGBFMT(
d3dpp->BackBufferFormat);
d3dpp->FrontBufferFormat = (D3DFORMAT)MAKESRGBFMT(
d3dpp->FrontBufferFormat);
}
#endif
if (!windowed_enable)
{
#ifdef _XBOX
@ -603,7 +554,6 @@ void d3d_make_d3dpp(void *data,
#ifdef _XBOX
d3dpp->MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp->EnableAutoDepthStencil = FALSE;
#if defined(_XBOX1)
{
/* Get the "video mode" */
DWORD video_mode = XGetVideoFlags();
@ -638,13 +588,6 @@ void d3d_make_d3dpp(void *data,
d3dpp->Flags |= D3DPRESENTFLAG_WIDESCREEN;
#endif
}
#elif defined(_XBOX360)
#if 0
if (!widescreen_mode)
d3dpp->Flags |= D3DPRESENTFLAG_NO_LETTERBOX;
#endif
d3dpp->MultiSampleQuality = 0;
#endif
#endif
}
@ -851,31 +794,10 @@ static bool d3d_initialize(d3d_video_t *d3d, const video_info_t *info)
d3d_set_viewport(d3d,
width, height, false, true);
#if defined(_XBOX360)
strlcpy(settings->paths.path_font, "game:\\media\\Arial_12.xpr",
sizeof(settings->paths.path_font));
#endif
font_driver_init_osd(d3d, false,
info->is_threaded,
FONT_DRIVER_RENDER_DIRECT3D_API);
#ifdef HAVE_D3D9
{
static const D3DVERTEXELEMENT 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 (!d3d_vertex_declaration_new(d3d->dev,
(void*)VertexElements, (void**)&d3d->menu_display.decl))
return false;
}
#endif
d3d->menu_display.offset = 0;
d3d->menu_display.size = 1024;
d3d->menu_display.buffer = d3d_vertex_buffer_new(
@ -1174,16 +1096,9 @@ static void d3d_show_mouse(void *data, bool state)
static const gfx_ctx_driver_t *d3d_get_context(void *data)
{
/* Default to Direct3D9 for now.
TODO: GL core contexts through ANGLE? */
unsigned minor = 0;
#if defined(HAVE_D3D8)
unsigned major = 8;
enum gfx_ctx_api api = GFX_CTX_DIRECT3D8_API;
#else
unsigned major = 9;
enum gfx_ctx_api api = GFX_CTX_DIRECT3D9_API;
#endif
settings_t *settings = config_get_ptr();
return video_context_driver_init_first(data,
@ -1197,7 +1112,7 @@ static void *d3d_init(const video_info_t *info,
d3d_video_t *d3d = NULL;
const gfx_ctx_driver_t *ctx_driver = NULL;
if (!d3d_initialize_symbols())
if (!d3d_initialize_symbols(D3D_COMM_D3D8))
return NULL;
d3d = (d3d_video_t*)calloc(1, sizeof(*d3d));
@ -1314,7 +1229,7 @@ static void d3d_overlay_tex_geom(
d3d->overlays[index].tex_coords[1] = y;
d3d->overlays[index].tex_coords[2] = w;
d3d->overlays[index].tex_coords[3] = h;
#ifdef _XBOX1
#ifdef _XBOX
d3d->overlays[index].tex_coords[0] *= d3d->overlays[index].tex_w;
d3d->overlays[index].tex_coords[1] *= d3d->overlays[index].tex_h;
d3d->overlays[index].tex_coords[2] *= d3d->overlays[index].tex_w;
@ -1639,7 +1554,7 @@ static void d3d_set_menu_texture_frame(void *data,
d3d->menu->tex_w = width;
d3d->menu->tex_h = height;
#ifdef _XBOX1
#ifdef _XBOX
d3d->menu->tex_coords [2] = width;
d3d->menu->tex_coords[3] = height;
#endif
@ -1710,17 +1625,9 @@ static void video_texture_load_d3d(d3d_video_t *d3d,
uintptr_t *id)
{
D3DLOCKED_RECT d3dlr;
LPDIRECT3DTEXTURE tex = NULL;
unsigned usage = 0;
bool want_mipmap = false;
#ifndef HAVE_D3D8
if((filter_type == TEXTURE_FILTER_MIPMAP_LINEAR) ||
(filter_type == TEXTURE_FILTER_MIPMAP_NEAREST))
want_mipmap = true;
#endif
tex = d3d_texture_new(d3d->dev, NULL,
LPDIRECT3DTEXTURE tex = d3d_texture_new(d3d->dev, NULL,
ti->width, ti->height, 0,
usage, d3d_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0,
@ -1830,7 +1737,7 @@ static void d3d_get_poke_interface(void *data,
*iface = &d3d_poke_interface;
}
video_driver_t video_d3d = {
video_driver_t video_d3d8 = {
d3d_init,
d3d_frame,
d3d_set_nonblock_state,
@ -1840,7 +1747,7 @@ video_driver_t video_d3d = {
NULL, /* has_windowed */
d3d_set_shader,
d3d_free,
"d3d",
"d3d8",
d3d_set_viewport,
d3d_set_rotation,
d3d_viewport_info,

1780
gfx/drivers/d3d9.c Normal file

File diff suppressed because it is too large Load Diff

@ -144,7 +144,7 @@ static void d3d8_renderchain_set_vertices(void *data, unsigned pass,
vert[2].v = tex_h;
vert[3].u = tex_w;
vert[3].v = tex_h;
#ifndef _XBOX1
#ifndef _XBOX
vert[1].u /= chain->tex_w;
vert[2].v /= chain->tex_h;
vert[3].u /= chain->tex_w;

@ -184,8 +184,10 @@ static void hlsl_d3d9_renderchain_set_vertices(
d3d_vertex_buffer_unlock(chain->vertex_buf);
}
hlsl_d3d9_renderchain_set_mvp(chain,
d3d, width, height, d3d->dev_rotation);
/* TODO/FIXME - last parameter is mat_data, should be set to
something other than NULL */
hlsl_d3d9_renderchain_set_mvp(d3d, chain, &d3d->shader,
NULL);
shader_info.data = d3d;
shader_info.idx = pass;
@ -386,8 +388,10 @@ static bool hlsl_d3d9_renderchain_render(void *data, const void *frame,
d3d_set_stream_source(d3dr, i, chain->vertex_buf, 0, sizeof(Vertex));
d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
hlsl_d3d9_renderchain_set_mvp(
chain, d3d, width, height, d3d->dev_rotation);
/* TODO/FIXME - last parameter is mat_data - should be something
other than NULL */
hlsl_d3d9_renderchain_set_mvp(d3d,
chain, &d3d->shader, NULL);
return true;
}

@ -268,8 +268,11 @@ static const video_driver_t *video_drivers[] = {
#if defined(HAVE_D3D12)
&video_d3d12,
#endif
#if defined(HAVE_D3D)
&video_d3d,
#if defined(HAVE_D3D9)
&video_d3d9,
#endif
#if defined(HAVE_D3D8)
&video_d3d8,
#endif
#ifdef HAVE_VITA2D
&video_vita2d,
@ -413,19 +416,6 @@ static const shader_backend_t *shader_ctx_drivers[] = {
NULL
};
static const d3d_renderchain_driver_t *renderchain_d3d_drivers[] = {
#if defined(_WIN32) && defined(HAVE_D3D9) && defined(HAVE_CG)
&cg_d3d9_renderchain,
#endif
#if defined(_WIN32) && defined(HAVE_D3D9) && defined(HAVE_HLSL)
&hlsl_d3d9_renderchain,
#endif
#if defined(_WIN32) && defined(HAVE_D3D8)
&d3d8_d3d_renderchain,
#endif
&null_d3d_renderchain,
NULL
};
static const gl_renderchain_driver_t *renderchain_gl_drivers[] = {
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
@ -3436,23 +3426,59 @@ void video_driver_set_mvp(video_shader_ctx_mvp_t *mvp)
}
bool renderchain_d3d_init_first(
enum d3d_comm_api api,
const d3d_renderchain_driver_t **renderchain_driver,
void **renderchain_handle)
{
unsigned i;
for (i = 0; renderchain_d3d_drivers[i]; i++)
switch (api)
{
void *data = renderchain_d3d_drivers[i]->chain_new();
case D3D_COMM_D3D9:
#ifdef HAVE_D3D9
{
static const d3d_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_d3d_renderchain,
NULL
};
for (i = 0; renderchain_d3d_drivers[i]; i++)
{
void *data = renderchain_d3d_drivers[i]->chain_new();
if (!data)
continue;
if (!data)
continue;
*renderchain_driver = renderchain_d3d_drivers[i];
*renderchain_handle = data;
return true;
*renderchain_driver = renderchain_d3d_drivers[i];
*renderchain_handle = data;
return true;
}
}
#endif
break;
case D3D_COMM_D3D8:
{
#ifdef HAVE_D3D8
void *data = d3d8_d3d_renderchain.chain_new();
if (data)
{
*renderchain_driver = &d3d8_d3d_renderchain;
*renderchain_handle = data;
}
#endif
}
break;
case D3D_COMM_NONE:
break;
}
return false;
}

@ -33,6 +33,10 @@
#include "../input/input_overlay.h"
#endif
#ifdef HAVE_D3D
#include "common/d3d_common.h"
#endif
#include "video_defines.h"
#include "video_coord_array.h"
#include "video_filter.h"
@ -1317,6 +1321,7 @@ bool video_shader_driver_compile_program(struct shader_program_info *program_inf
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap);
bool renderchain_d3d_init_first(
enum d3d_comm_api api,
const d3d_renderchain_driver_t **renderchain_driver,
void **renderchain_handle);
@ -1335,7 +1340,8 @@ extern video_driver_t video_psp1;
extern video_driver_t video_vita2d;
extern video_driver_t video_ctr;
extern video_driver_t video_switch;
extern video_driver_t video_d3d;
extern video_driver_t video_d3d8;
extern video_driver_t video_d3d9;
extern video_driver_t video_d3d11;
extern video_driver_t video_d3d12;
extern video_driver_t video_gx;

@ -324,14 +324,15 @@ VIDEO DRIVER
============================================================ */
#if defined(HAVE_D3D)
#include "../gfx/common/d3d_common.c"
#include "../gfx/drivers/d3d.c"
#include "../gfx/drivers_context/d3d_ctx.c"
#if defined(HAVE_D3D8)
#include "../gfx/drivers/d3d8.c"
#include "../gfx/drivers_renderchain/d3d8_renderchain.c"
#endif
#if defined(HAVE_D3D9)
#include "../gfx/drivers/d3d9.c"
#ifdef HAVE_HLSL
#include "../gfx/drivers_renderchain/d3d9_hlsl_renderchain.c"

@ -217,7 +217,9 @@ static bool menu_display_check_compatibility(
return true;
break;
case MENU_VIDEO_DRIVER_DIRECT3D:
if (string_is_equal(video_driver, "d3d"))
if ( string_is_equal(video_driver, "d3d9") ||
string_is_equal(video_driver, "d3d8")
)
return true;
break;
case MENU_VIDEO_DRIVER_VITA2D: