diff --git a/Makefile.common b/Makefile.common
index 9da4dc8974..a0931b6a0e 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -1305,21 +1305,27 @@ endif
ifeq ($(HAVE_D3D8), 1)
DEFINES += -DHAVE_D3D8
- OBJ += gfx/drivers/d3d9.o
+ OBJ += gfx/drivers/d3d8.o
+ OBJ += gfx/common/d3d8_common.o
+
+ifeq ($(HAVE_MENU_COMMON), 1)
+ OBJ += menu/drivers_display/menu_display_d3d8.o
+endif
endif
ifeq ($(HAVE_D3D9), 1)
DEFINES += -DHAVE_D3D9
OBJ += gfx/drivers/d3d9.o
+ OBJ += gfx/common/d3d9_common.o
+
+ifeq ($(HAVE_MENU_COMMON), 1)
+ OBJ += menu/drivers_display/menu_display_d3d9.o
+endif
endif
ifeq ($(HAVE_D3D_COMMON), 1)
DEFINES += -DHAVE_D3D
OBJ += gfx/common/d3d_common.o
-
- ifeq ($(HAVE_MENU_COMMON), 1)
- OBJ += menu/drivers_display/menu_display_d3d.o
- endif
endif
ifeq ($(HAVE_SLANG),1)
diff --git a/gfx/common/d3d8_common.c b/gfx/common/d3d8_common.c
new file mode 100644
index 0000000000..07fb3cf1a0
--- /dev/null
+++ b/gfx/common/d3d8_common.c
@@ -0,0 +1,1086 @@
+/* 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 .
+ */
+
+/* For Xbox we will just link statically
+ * to Direct3D libraries instead. */
+
+#if !defined(_XBOX) && defined(HAVE_DYLIB)
+#define HAVE_DYNAMIC_D3D
+#endif
+
+#ifdef HAVE_DYNAMIC_D3D
+#include
+#endif
+
+#include "../../configuration.h"
+#include "../../verbosity.h"
+
+#include
+
+#ifdef HAVE_D3DX
+#ifdef _XBOX
+#include
+#include
+#else
+#include "../include/d3d8/d3dx8tex.h"
+#endif
+#endif
+
+#include "d3d8_common.h"
+
+#ifdef _XBOX
+#include
+#endif
+
+static UINT SDKVersion = 0;
+
+#ifdef HAVE_DYNAMIC_D3D
+static dylib_t g_d3d8_dll;
+#ifdef HAVE_D3DX
+static dylib_t g_d3d8x_dll;
+#endif
+static bool dylib_initialized = false;
+#endif
+
+typedef IDirect3D8 *(__stdcall *D3DCreate_t)(UINT);
+#ifdef HAVE_D3DX
+typedef HRESULT (__stdcall
+ *D3DCreateTextureFromFile_t)(
+ LPDIRECT3DDEVICE8 pDevice,
+ LPCSTR pSrcFile,
+ UINT Width,
+ UINT Height,
+ UINT MipLevels,
+ DWORD Usage,
+ D3DFORMAT Format,
+ D3DPOOL Pool,
+ DWORD Filter,
+ DWORD MipFilter,
+ D3DCOLOR ColorKey,
+ D3DXIMAGE_INFO* pSrcInfo,
+ PALETTEENTRY* pPalette,
+ LPDIRECT3DTEXTURE8* ppTexture);
+
+typedef HRESULT (__stdcall
+ *D3DXCreateFontIndirect_t)(
+ LPDIRECT3DDEVICE8 pDevice,
+ CONST LOGFONT* pDesc,
+ LPD3DXFONT* ppFont);
+#endif
+
+
+#ifdef HAVE_D3DX
+static D3DXCreateFontIndirect_t D3DCreateFontIndirect;
+static D3DCreateTextureFromFile_t D3DCreateTextureFromFile;
+#endif
+static D3DCreate_t D3DCreate;
+
+void *d3d8_create(void)
+{
+ return D3DCreate(SDKVersion);
+}
+
+#ifdef HAVE_DYNAMIC_D3D
+#ifdef HAVE_D3DX
+static dylib_t dylib_load_d3dx(void)
+{
+ dylib_t dll = NULL;
+
+ return dll;
+}
+#endif
+
+#endif
+
+bool d3d8_initialize_symbols(enum gfx_ctx_api api)
+{
+#ifdef HAVE_DYNAMIC_D3D
+ if (dylib_initialized)
+ return true;
+
+#if defined(DEBUG) || defined(_DEBUG)
+ g_d3d8_dll = dylib_load("d3d8d.dll");
+ if(!g_d3d8_dll)
+#endif
+ g_d3d8_dll = dylib_load("d3d8.dll");
+
+ if (!g_d3d8_dll)
+ return false;
+#endif
+
+ SDKVersion = 220;
+#ifdef HAVE_DYNAMIC_D3D
+ D3DCreate = (D3DCreate_t)dylib_proc(g_d3d8_dll, "Direct3DCreate8");
+#ifdef HAVE_D3DX
+#ifdef UNICODE
+ D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3d8x_dll, "D3DXCreateFontIndirectW");
+#else
+ D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3d8x_dll, "D3DXCreateFontIndirectA");
+#endif
+ D3DCreateTextureFromFile = (D3DCreateTextureFromFile_t)dylib_proc(g_d3d8x_dll, "D3DXCreateTextureFromFileExA");
+#endif
+#else
+ D3DCreate = Direct3DCreate8;
+#ifdef HAVE_D3DX
+ D3DCreateFontIndirect = D3DXCreateFontIndirect;
+ D3DCreateTextureFromFile = D3DXCreateTextureFromFileExA;
+#endif
+#endif
+
+ if (!D3DCreate)
+ goto error;
+
+#ifdef _XBOX
+ SDKVersion = 0;
+#endif
+#ifdef HAVE_DYNAMIC_D3D
+ dylib_initialized = true;
+#endif
+
+ return true;
+
+error:
+ d3d8_deinitialize_symbols();
+ return false;
+}
+
+void d3d8_deinitialize_symbols(void)
+{
+#ifdef HAVE_DYNAMIC_D3D
+ if (g_d3d8_dll)
+ dylib_close(g_d3d8_dll);
+#ifdef HAVE_D3DX
+ if (g_d3d8x_dll)
+ dylib_close(g_d3d8x_dll);
+ g_d3d8x_dll = NULL;
+#endif
+ g_d3d8_dll = NULL;
+
+ dylib_initialized = false;
+#endif
+}
+
+bool d3d8_check_device_type(void *_d3d,
+ unsigned idx,
+ INT32 disp_format,
+ INT32 backbuffer_format,
+ bool windowed_mode)
+{
+ LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
+ if (!d3d)
+ return false;
+#ifdef __cplusplus
+ if (FAILED(d3d->CheckDeviceType(
+ 0,
+ D3DDEVTYPE_HAL,
+ (D3DFORMAT)disp_format,
+ (D3DFORMAT)backbuffer_format,
+ windowed_mode)))
+ return false;
+#else
+ if (FAILED(IDirect3D8_CheckDeviceType(d3d,
+ 0,
+ D3DDEVTYPE_HAL,
+ disp_format,
+ backbuffer_format,
+ windowed_mode)))
+ return false;
+#endif
+
+ return true;
+}
+
+bool d3d8_get_adapter_display_mode(
+ void *_d3d,
+ unsigned idx,
+ void *display_mode)
+{
+ LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
+ if (!d3d)
+ return false;
+#ifdef __cplusplus
+ if (FAILED(d3d->GetAdapterDisplayMode(idx, (D3DDISPLAYMODE*)display_mode)))
+ return false;
+#else
+ if (FAILED(IDirect3D8_GetAdapterDisplayMode(d3d, idx, (D3DDISPLAYMODE*)display_mode)))
+ return false;
+#endif
+
+ return true;
+}
+
+bool d3d8_swap(void *data, void *_dev)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ if (dev->Present(NULL, NULL, NULL, NULL) != D3D_OK)
+ return false;
+#else
+ if (IDirect3DDevice8_Present(dev, NULL, NULL, NULL, NULL)
+ == D3DERR_DEVICELOST)
+ return false;
+#endif
+ return true;
+}
+
+void d3d8_set_transform(void *_dev,
+ INT32 state, const void *_matrix)
+{
+ CONST D3DMATRIX *matrix = (CONST D3DMATRIX*)_matrix;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ dev->SetTransform((D3DTRANSFORMSTATETYPE)state, matrix);
+#else
+ IDirect3DDevice8_SetTransform(dev, (D3DTRANSFORMSTATETYPE)state, matrix);
+#endif
+}
+
+bool d3d8_texture_get_level_desc(void *_tex,
+ unsigned idx, void *_ppsurface_level)
+{
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
+#ifdef __cplusplus
+ if (SUCCEEDED(tex->GetLevelDesc(idx, (D3DSURFACE_DESC*)_ppsurface_level)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DTexture8_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level)))
+ return true;
+#endif
+
+ return false;
+}
+
+bool d3d8_texture_get_surface_level(void *_tex,
+ unsigned idx, void **_ppsurface_level)
+{
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
+ if (!tex)
+ return false;
+#ifdef __cplusplus
+ if (SUCCEEDED(tex->GetSurfaceLevel(idx, (IDirect3DSurface8**)_ppsurface_level)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DTexture8_GetSurfaceLevel(tex, idx, (IDirect3DSurface8**)_ppsurface_level)))
+ return true;
+#endif
+
+ return false;
+}
+
+#ifdef HAVE_D3DX
+static void *d3d8_texture_new_from_file(
+ void *dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, D3DFORMAT format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info_data,
+ PALETTEENTRY *palette)
+{
+ void *buf = NULL;
+ HRESULT hr = D3DCreateTextureFromFile((LPDIRECT3DDEVICE8)dev,
+ path, width, height, miplevels, usage, format,
+ (D3DPOOL)pool, filter, mipfilter, color_key, src_info_data,
+ palette, (struct IDirect3DTeture8**)&buf);
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+#endif
+
+void *d3d8_texture_new(void *_dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, INT32 format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info_data,
+ PALETTEENTRY *palette, bool want_mipmap)
+{
+ HRESULT hr = S_OK;
+ void *buf = NULL;
+
+ if (path)
+ {
+#ifdef HAVE_D3DX
+ return d3d8_texture_new_from_file(_dev,
+ path, width, height, miplevels,
+ usage, (D3DFORMAT)format,
+ (D3DPOOL)pool, filter, mipfilter,
+ color_key, src_info_data, palette);
+#else
+ return NULL;
+#endif
+ }
+
+ {
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ hr = dev->CreateTexture(
+ width, height, miplevels, usage,
+ (D3DFORMAT)format, (D3DPOOL)pool, (IDirect3DTexture8**)&buf);
+#else
+ hr = IDirect3DDevice8_CreateTexture(dev,
+ width, height, miplevels, usage,
+ (D3DFORMAT)format, (D3DPOOL)pool, (struct IDirect3DTexture8**)&buf);
+#endif
+ }
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+
+void d3d8_texture_free(void *_tex)
+{
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
+ if (!tex)
+ return;
+#ifdef __cplusplus
+ tex->Release();
+#else
+ IDirect3DTexture8_Release(tex);
+#endif
+}
+
+bool d3d8_surface_lock_rect(void *data, void *data2)
+{
+ LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
+ if (!surf)
+ return false;
+#ifdef __cplusplus
+ if (FAILED(surf->LockRect((D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
+ return false;
+#else
+ if (FAILED(IDirect3DSurface8_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
+ return false;
+#endif
+
+ return true;
+}
+
+void d3d8_surface_unlock_rect(void *data)
+{
+ LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
+ if (!surf)
+ return;
+#ifdef __cplusplus
+ surf->UnlockRect();
+#else
+ IDirect3DSurface8_UnlockRect(surf);
+#endif
+}
+
+void d3d8_surface_free(void *data)
+{
+ LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
+ if (!surf)
+ return;
+#ifdef __cplusplus
+ surf->Release();
+#else
+ IDirect3DSurface8_Release(surf);
+#endif
+}
+
+void *d3d8_vertex_buffer_new(void *_dev,
+ unsigned length, unsigned usage,
+ unsigned fvf, INT32 pool, void *handle)
+{
+ void *buf = NULL;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ HRESULT hr = dev->CreateVertexBuffer(
+ length, usage, fvf, (D3DPOOL)pool, (IDirect3DVertexBuffer8**)&buf);
+#else
+ HRESULT hr = IDirect3DDevice8_CreateVertexBuffer(
+ dev, length, usage, fvf,
+ (D3DPOOL)pool,
+ (struct IDirect3DVertexBuffer8**)&buf);
+#endif
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+
+void d3d8_vertex_buffer_unlock(void *vertbuf_ptr)
+{
+ LPDIRECT3DVERTEXBUFFER8 vertbuf = (LPDIRECT3DVERTEXBUFFER8)vertbuf_ptr;
+
+ if (!vertbuf)
+ return;
+#ifdef __cplusplus
+ vertbuf->Unlock();
+#else
+ IDirect3DVertexBuffer8_Unlock(vertbuf);
+#endif
+}
+
+void *d3d8_vertex_buffer_lock(void *vertbuf_ptr)
+{
+ void *buf = NULL;
+ LPDIRECT3DVERTEXBUFFER8 vertbuf = (LPDIRECT3DVERTEXBUFFER8)vertbuf_ptr;
+
+ if (!vertbuf)
+ return NULL;
+
+#ifdef __cplusplus
+ vertbuf->Lock(0, 0, (BYTE**)&buf, 0);
+#else
+ IDirect3DVertexBuffer8_Lock(vertbuf, 0, 0, (BYTE**)&buf, 0);
+#endif
+
+ if (!buf)
+ return NULL;
+
+ return buf;
+}
+
+void d3d8_vertex_buffer_free(void *vertex_data, void *vertex_declaration)
+{
+ if (vertex_data)
+ {
+ LPDIRECT3DVERTEXBUFFER8 buf = (LPDIRECT3DVERTEXBUFFER8)vertex_data;
+#ifdef __cplusplus
+ buf->Release();
+#else
+ IDirect3DVertexBuffer8_Release(buf);
+#endif
+ buf = NULL;
+ }
+}
+
+void d3d8_set_stream_source(void *_dev, unsigned stream_no,
+ void *stream_vertbuf_ptr, unsigned offset_bytes,
+ unsigned stride)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ LPDIRECT3DVERTEXBUFFER8 stream_vertbuf = (LPDIRECT3DVERTEXBUFFER8)stream_vertbuf_ptr;
+ if (!stream_vertbuf)
+ return;
+#ifdef __cplusplus
+ dev->SetStreamSource(stream_no, stream_vertbuf, offset_bytes, stride);
+#else
+ IDirect3DDevice8_SetStreamSource(dev, stream_no, stream_vertbuf, stride);
+#endif
+}
+
+static void d3d8_set_texture_stage_state(void *_dev,
+ unsigned sampler, unsigned type, unsigned value)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ if (dev->SetTextureStageState(sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
+ RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
+#else
+ if (IDirect3DDevice8_SetTextureStageState(dev, sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
+ RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
+#endif
+}
+
+void d3d8_set_sampler_address_u(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ d3d8_set_texture_stage_state(dev, sampler, D3DTSS_ADDRESSU, value);
+}
+
+void d3d8_set_sampler_address_v(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ d3d8_set_texture_stage_state(dev, sampler, D3DTSS_ADDRESSV, value);
+}
+
+void d3d8_set_sampler_minfilter(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ d3d8_set_texture_stage_state(_dev, sampler, D3DTSS_MINFILTER, value);
+}
+
+void d3d8_set_sampler_magfilter(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ d3d8_set_texture_stage_state(_dev, sampler, D3DTSS_MAGFILTER, value);
+}
+
+bool d3d8_begin_scene(void *_dev)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return false;
+#ifdef __cplusplus
+#ifdef _XBOX
+ dev->BeginScene();
+#else
+ if (FAILED(dev->BeginScene()))
+ return false;
+#endif
+#else
+#ifdef _XBOX
+ IDirect3DDevice8_BeginScene(dev);
+#else
+ if (FAILED(IDirect3DDevice8_BeginScene(dev)))
+ return false;
+#endif
+#endif
+
+ return true;
+}
+
+void d3d8_end_scene(void *_dev)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->EndScene();
+#else
+ IDirect3DDevice8_EndScene(dev);
+#endif
+}
+
+static void d3d8_draw_primitive_internal(void *_dev,
+ D3DPRIMITIVETYPE type, unsigned start, unsigned count)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->DrawPrimitive(type, start, count);
+#else
+ IDirect3DDevice8_DrawPrimitive(dev, type, start, count);
+#endif
+}
+
+void d3d8_draw_primitive(void *dev,
+ INT32 type, unsigned start, unsigned count)
+{
+ if (!d3d8_begin_scene(dev))
+ return;
+
+ d3d8_draw_primitive_internal(dev, (D3DPRIMITIVETYPE)type, start, count);
+ d3d8_end_scene(dev);
+}
+
+void d3d8_clear(void *_dev,
+ unsigned count, const void *rects, unsigned flags,
+ INT32 color, float z, unsigned stencil)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->Clear(count, (const D3DRECT*)rects, flags, color, z, stencil);
+#else
+ IDirect3DDevice8_Clear(dev, count, (const D3DRECT*)rects, flags,
+ color, z, stencil);
+#endif
+}
+
+bool d3d8_device_get_render_target(void *_dev,
+ unsigned idx, void **data)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return false;
+#ifdef __cplusplus
+ if (SUCCEEDED(dev->GetRenderTarget(
+ (LPDIRECT3DSURFACE8*)data)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice8_GetRenderTarget(dev,
+ (LPDIRECT3DSURFACE8*)data)))
+ return true;
+#endif
+
+ return false;
+}
+
+
+bool d3d8_lock_rectangle(void *_tex,
+ unsigned level, void *_lr, RECT *rect,
+ unsigned rectangle_height, unsigned flags)
+{
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
+ if (!tex)
+ return false;
+#ifdef __cplusplus
+ if (FAILED(tex->LockRect(level, lr, rect, flags)))
+ return false;
+#else
+ if (IDirect3DTexture8_LockRect(tex, level, lr, rect, flags) != D3D_OK)
+ return false;
+#endif
+
+ return true;
+}
+
+void d3d8_unlock_rectangle(void *_tex)
+{
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
+ if (!tex)
+ return;
+#ifdef __cplusplus
+ tex->UnlockRect(0);
+#else
+ IDirect3DTexture8_UnlockRect(tex, 0);
+#endif
+}
+
+void d3d8_lock_rectangle_clear(void *tex,
+ unsigned level, void *_lr, RECT *rect,
+ unsigned rectangle_height, unsigned flags)
+{
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+#if defined(_XBOX)
+ level = 0;
+#endif
+ memset(lr->pBits, level, rectangle_height * lr->Pitch);
+ d3d8_unlock_rectangle(tex);
+}
+
+void d3d8_set_viewports(void *_dev, void *_vp)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ D3DVIEWPORT8 *vp = (D3DVIEWPORT8*)_vp;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->SetViewport(vp);
+#else
+ IDirect3DDevice8_SetViewport(dev, vp);
+#endif
+}
+
+void d3d8_set_texture(void *_dev, unsigned sampler,
+ void *tex_data)
+{
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)tex_data;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev || !tex)
+ return;
+#ifdef __cplusplus
+ dev->SetTexture(sampler, tex);
+#else
+ IDirect3DDevice8_SetTexture(dev, sampler,
+ (IDirect3DBaseTexture8*)tex);
+#endif
+}
+
+bool d3d8_set_vertex_shader(void *_dev, unsigned index,
+ void *data)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+#ifdef __cplusplus
+ LPDIRECT3DVERTEXSHADER8 shader = (LPDIRECT3DVERTEXSHADER8)data;
+
+ if (dev->SetVertexShader(shader) != D3D_OK)
+ return false;
+#else
+ if (IDirect3DDevice8_SetVertexShader(dev, index) != D3D_OK)
+ return false;
+#endif
+
+ return true;
+}
+
+void d3d8_texture_blit(unsigned pixel_size,
+ void *tex,
+ void *_lr, const void *frame,
+ unsigned width, unsigned height, unsigned pitch)
+{
+ unsigned y;
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+
+ for (y = 0; y < height; y++)
+ {
+ const uint8_t *in = (const uint8_t*)frame + y * pitch;
+ uint8_t *out = (uint8_t*)lr->pBits + y * lr->Pitch;
+ memcpy(out, in, width * pixel_size);
+ }
+}
+
+bool d3d8_get_render_state(void *data, INT32 state, DWORD *value)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+#ifdef __cplusplus
+ if (dev && dev->GetRenderState((D3DRENDERSTATETYPE)state, value) == D3D_OK)
+ return true;
+#else
+ if (dev && IDirect3DDevice8_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value) == D3D_OK)
+ return true;
+#endif
+
+ return false;
+}
+
+void d3d8_set_render_state(void *data, INT32 state, DWORD value)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->SetRenderState((D3DRENDERSTATETYPE)state, value);
+#else
+ IDirect3DDevice8_SetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
+#endif
+}
+
+void d3d8_enable_blend_func(void *data)
+{
+ if (!data)
+ return;
+
+ d3d8_set_render_state(data, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
+ d3d8_set_render_state(data, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+ d3d8_set_render_state(data, D3DRS_ALPHABLENDENABLE, true);
+}
+
+void d3d8_device_set_render_target(void *_dev, unsigned idx,
+ void *data)
+{
+ LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return;
+#ifdef __cplusplus
+ dev->SetRenderTarget(idx, surf);
+#else
+ IDirect3DDevice8_SetRenderTarget(dev, surf, NULL);
+#endif
+}
+
+void d3d8_enable_alpha_blend_texture_func(void *data)
+{
+ /* Also blend the texture with the set alpha value. */
+ d3d8_set_texture_stage_state(data, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
+ d3d8_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
+ d3d8_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
+}
+
+void d3d8_frame_postprocess(void *data)
+{
+#if defined(_XBOX)
+ global_t *global = global_get_ptr();
+#ifdef __cplusplus
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+ if (!dev)
+ return;
+
+ dev->SetFlickerFilter(global->console.screen.flicker_filter_index);
+ dev->SetSoftDisplayFilter(global->console.softfilter_enable);
+#else
+ D3DDevice_SetFlickerFilter(global->console.screen.flicker_filter_index);
+ D3DDevice_SetSoftDisplayFilter(global->console.softfilter_enable);
+#endif
+#endif
+}
+
+void d3d8_disable_blend_func(void *data)
+{
+ d3d8_set_render_state(data, D3DRS_ALPHABLENDENABLE, false);
+}
+
+static bool d3d8_reset_internal(void *data,
+ D3DPRESENT_PARAMETERS *d3dpp
+ )
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+ if (!dev)
+ return false;
+#ifdef __cplusplus
+ if ((dev->Reset(d3dpp) == D3D_OK))
+ return true;
+#else
+ if (IDirect3DDevice8_Reset(dev, d3dpp) == D3D_OK)
+ return true;
+#endif
+
+ return false;
+}
+
+static HRESULT d3d8_test_cooperative_level(void *data)
+{
+#ifdef _XBOX
+ return E_FAIL;
+#else
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+ if (!dev)
+ return E_FAIL;
+
+#ifdef __cplusplus
+ return dev->TestCooperativeLevel();
+#else
+ return IDirect3DDevice8_TestCooperativeLevel(dev);
+#endif
+#endif
+}
+
+static bool d3d8_create_device_internal(
+ void *data,
+ D3DPRESENT_PARAMETERS *d3dpp,
+ void *_d3d,
+ HWND focus_window,
+ unsigned cur_mon_id,
+ DWORD behavior_flags)
+{
+ LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
+ if (!dev)
+ return false;
+#ifdef __cplusplus
+ if (SUCCEEDED(d3d->CreateDevice(
+ cur_mon_id,
+ D3DDEVTYPE_HAL,
+ focus_window,
+ behavior_flags,
+ d3dpp,
+ (IDirect3DDevice8**)dev)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3D8_CreateDevice(d3d,
+ cur_mon_id,
+ D3DDEVTYPE_HAL,
+ focus_window,
+ behavior_flags,
+ d3dpp,
+ (IDirect3DDevice8**)dev)))
+ return true;
+#endif
+
+ return false;
+}
+
+bool d3d8_create_device(void *dev,
+ void *d3dpp,
+ void *d3d,
+ HWND focus_window,
+ unsigned cur_mon_id)
+{
+ if (!d3d8_create_device_internal(dev,
+ (D3DPRESENT_PARAMETERS*)d3dpp,
+ d3d,
+ focus_window,
+ cur_mon_id,
+ D3DCREATE_HARDWARE_VERTEXPROCESSING))
+ if (!d3d8_create_device_internal(
+ dev,
+ (D3DPRESENT_PARAMETERS*)d3dpp, d3d, focus_window,
+ cur_mon_id,
+ D3DCREATE_SOFTWARE_VERTEXPROCESSING))
+ return false;
+ return true;
+}
+
+bool d3d8_reset(void *dev, void *d3dpp)
+{
+ const char *err = NULL;
+
+ if (d3d8_reset_internal(dev, (D3DPRESENT_PARAMETERS*)d3dpp))
+ return true;
+
+ RARCH_WARN("[D3D]: Attempting to recover from dead state...\n");
+
+#ifndef _XBOX
+ /* Try to recreate the device completely. */
+ switch (d3d8_test_cooperative_level(dev))
+ {
+ case D3DERR_DEVICELOST:
+ err = "DEVICELOST";
+ break;
+
+ case D3DERR_DEVICENOTRESET:
+ err = "DEVICENOTRESET";
+ break;
+
+ case D3DERR_DRIVERINTERNALERROR:
+ err = "DRIVERINTERNALERROR";
+ break;
+
+ default:
+ err = "Unknown";
+ }
+ RARCH_WARN("[D3D]: recovering from dead state: (%s).\n", err);
+#endif
+
+ return false;
+}
+
+bool d3d8_device_get_backbuffer(void *_dev,
+ unsigned idx, unsigned swapchain_idx,
+ unsigned backbuffer_type, void **data)
+{
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (!dev)
+ return false;
+#ifdef __cplusplus
+ if (SUCCEEDED(dev->GetBackBuffer(idx,
+ (D3DBACKBUFFER_TYPE)backbuffer_type,
+ (LPDIRECT3DSURFACE8*)data)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice8_GetBackBuffer(dev, idx,
+ (D3DBACKBUFFER_TYPE)backbuffer_type,
+ (LPDIRECT3DSURFACE8*)data)))
+ return true;
+#endif
+
+ return false;
+}
+
+
+void d3d8_device_free(void *_dev, void *_pd3d)
+{
+ LPDIRECT3D8 pd3d = (LPDIRECT3D8)_pd3d;
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (dev)
+ {
+#ifdef __cplusplus
+ dev->Release();
+#else
+ IDirect3DDevice8_Release(dev);
+#endif
+ }
+
+ if (pd3d)
+ {
+#if defined(__cplusplus)
+ pd3d->Release();
+#else
+ IDirect3D8_Release(pd3d);
+#endif
+ }
+}
+
+INT32 d3d8_translate_filter(unsigned type)
+{
+ switch (type)
+ {
+ case RARCH_FILTER_UNSPEC:
+ {
+ settings_t *settings = config_get_ptr();
+ if (!settings->bools.video_smooth)
+ break;
+ }
+ /* fall-through */
+ case RARCH_FILTER_LINEAR:
+ return D3DTEXF_LINEAR;
+ case RARCH_FILTER_NEAREST:
+ break;
+ }
+
+ return D3DTEXF_POINT;
+}
+
+bool d3d8x_create_font_indirect(void *_dev,
+ void *desc, void **font_data)
+{
+#ifdef HAVE_D3DX
+ LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
+ if (SUCCEEDED(D3DCreateFontIndirect(
+ dev, (CONST LOGFONT*)desc,
+ (struct ID3DXFont**)font_data)))
+ return true;
+#endif
+
+ return false;
+}
+
+void d3d8x_font_draw_text(void *data, void *sprite_data, void *string_data,
+ unsigned count, void *rect_data, unsigned format, unsigned color)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->DrawText(font, (LPD3DXSPRITE)sprite_data,
+ (LPCTSTR)string_data, count, (LPRECT)rect_data,
+ (DWORD)format, (D3DCOLOR)color);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->DrawText((LPD3DXSPRITE)sprite_data,
+ (LPCTSTR)string_data, count, (LPRECT)rect_data,
+ (DWORD)format, (D3DCOLOR)color);
+#endif
+#endif
+}
+
+void d3d8x_font_release(void *data)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->Release(font);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->Release();
+#endif
+#endif
+}
+
+void d3d8x_font_get_text_metrics(void *data, void *metrics)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->GetTextMetrics(font, (TEXTMETRICA*)metrics);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->GetTextMetricsA((TEXTMETRICA*)metrics);
+#endif
+#endif
+}
+
+INT32 d3d8_get_rgb565_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_R5G6B5;
+#else
+ return D3DFMT_R5G6B5;
+#endif
+}
+
+INT32 d3d8_get_argb8888_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_A8R8G8B8;
+#else
+ return D3DFMT_A8R8G8B8;
+#endif
+}
+
+INT32 d3d8_get_xrgb8888_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_X8R8G8B8;
+#else
+ return D3DFMT_X8R8G8B8;
+#endif
+}
diff --git a/gfx/common/d3d8_common.h b/gfx/common/d3d8_common.h
new file mode 100644
index 0000000000..41260b7340
--- /dev/null
+++ b/gfx/common/d3d8_common.h
@@ -0,0 +1,212 @@
+/* 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 .
+ */
+
+#ifndef _D3D8_COMMON_H
+#define _D3D8_COMMON_H
+
+#include
+#include
+
+#include "../video_driver.h"
+
+RETRO_BEGIN_DECLS
+
+bool d3d8_swap(void *data, void *dev);
+
+void *d3d8_vertex_buffer_new(void *dev,
+ unsigned length, unsigned usage, unsigned fvf,
+ INT32 pool, void *handle);
+
+void *d3d8_vertex_buffer_lock(void *data);
+void d3d8_vertex_buffer_unlock(void *data);
+
+void d3d8_vertex_buffer_free(void *vertex_data, void *vertex_declaration);
+
+bool d3d8_texture_get_level_desc(void *tex,
+ unsigned idx, void *_ppsurface_level);
+
+bool d3d8_texture_get_surface_level(void *tex,
+ unsigned idx, void **_ppsurface_level);
+
+void *d3d8_texture_new(void *dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, INT32 format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info,
+ PALETTEENTRY *palette, bool want_mipmap);
+
+void d3d8_set_stream_source(void *dev, unsigned stream_no,
+ void *stream_vertbuf, unsigned offset_bytes,
+ unsigned stride);
+
+void d3d8_texture_free(void *tex);
+
+void d3d8_set_transform(void *dev,
+ INT32 state, const void *_matrix);
+
+void d3d8_set_sampler_address_u(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d8_set_sampler_address_v(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d8_set_sampler_minfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d8_set_sampler_magfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d8_set_sampler_mipfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+bool d3d8_begin_scene(void *dev);
+
+void d3d8_end_scene(void *dev);
+
+void d3d8_draw_primitive(void *dev,
+ INT32 type, unsigned start, unsigned count);
+
+void d3d8_clear(void *dev,
+ unsigned count, const void *rects, unsigned flags,
+ INT32 color, float z, unsigned stencil);
+
+bool d3d8_lock_rectangle(void *tex,
+ unsigned level, void *lock_rect, RECT *rect,
+ unsigned rectangle_height, unsigned flags);
+
+void d3d8_lock_rectangle_clear(void *tex,
+ unsigned level, void *lock_rect, RECT *rect,
+ unsigned rectangle_height, unsigned flags);
+
+void d3d8_unlock_rectangle(void *tex);
+
+void d3d8_set_texture(void *dev, unsigned sampler,
+ void *tex_data);
+
+bool d3d8_create_vertex_shader(void *dev,
+ const DWORD *a, void **b);
+
+bool d3d8_create_pixel_shader(void *dev,
+ const DWORD *a, void **b);
+
+void d3d8_free_vertex_shader(void *dev, void *data);
+
+bool d3d8_set_vertex_shader(void *dev, unsigned index,
+ void *data);
+
+void d3d8_texture_blit(unsigned pixel_size,
+ void *tex,
+ void *lr, const void *frame,
+ unsigned width, unsigned height, unsigned pitch);
+
+bool d3d8_vertex_declaration_new(void *dev,
+ const void *vertex_data, void **decl_data);
+
+void d3d8_vertex_declaration_free(void *data);
+
+void d3d8_set_viewports(void *dev, void *vp);
+
+void d3d8_enable_blend_func(void *data);
+
+void d3d8_disable_blend_func(void *data);
+
+void d3d8_set_vertex_declaration(void *data, void *vertex_data);
+
+void d3d8_enable_alpha_blend_texture_func(void *data);
+
+void d3d8_frame_postprocess(void *data);
+
+void d3d8_surface_free(void *data);
+
+bool d3d8_device_get_render_target_data(void *dev,
+ void *_src, void *_dst);
+
+bool d3d8_device_get_render_target(void *dev,
+ unsigned idx, void **data);
+
+void d3d8_device_set_render_target(void *dev, unsigned idx,
+ void *data);
+
+bool d3d8_get_render_state(void *data,
+ INT32 state, DWORD *value);
+
+void d3d8_set_render_state(void *data,
+ INT32 state, DWORD value);
+
+void d3d8_device_set_render_target(void *dev, unsigned idx,
+ void *data);
+
+bool d3d8_device_create_offscreen_plain_surface(
+ void *dev,
+ unsigned width,
+ unsigned height,
+ unsigned format,
+ unsigned pool,
+ void **surf_data,
+ void *data);
+
+bool d3d8_surface_lock_rect(void *data, void *data2);
+
+void d3d8_surface_unlock_rect(void *data);
+
+bool d3d8_get_adapter_display_mode(void *d3d,
+ unsigned idx,
+ void *display_mode);
+
+bool d3d8_create_device(void *dev,
+ void *d3dpp,
+ void *d3d,
+ HWND focus_window,
+ unsigned cur_mon_id);
+
+bool d3d8_reset(void *dev, void *d3dpp);
+
+bool d3d8_device_get_backbuffer(void *dev,
+ unsigned idx, unsigned swapchain_idx,
+ unsigned backbuffer_type, void **data);
+
+void d3d8_device_free(void *dev, void *pd3d);
+
+void *d3d8_create(void);
+
+bool d3d8_initialize_symbols(enum gfx_ctx_api api);
+
+void d3d8_deinitialize_symbols(void);
+
+bool d3d8_check_device_type(void *d3d,
+ unsigned idx,
+ INT32 disp_format,
+ INT32 backbuffer_format,
+ bool windowed_mode);
+
+bool d3d8x_create_font_indirect(void *dev,
+ void *desc, void **font_data);
+
+void d3d8x_font_draw_text(void *data, void *sprite_data, void *string_data,
+ unsigned count, void *rect_data, unsigned format, unsigned color);
+
+void d3d8x_font_get_text_metrics(void *data, void *metrics);
+
+void d3d8x_font_release(void *data);
+
+INT32 d3d8_translate_filter(unsigned type);
+
+INT32 d3d8_get_rgb565_format(void);
+INT32 d3d8_get_argb8888_format(void);
+INT32 d3d8_get_xrgb8888_format(void);
+
+RETRO_END_DECLS
+
+#endif
diff --git a/gfx/common/d3d9_common.c b/gfx/common/d3d9_common.c
new file mode 100644
index 0000000000..f46e5dea0b
--- /dev/null
+++ b/gfx/common/d3d9_common.c
@@ -0,0 +1,1571 @@
+/* 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 .
+ */
+
+/* For Xbox we will just link statically
+ * to Direct3D libraries instead. */
+
+#if !defined(_XBOX) && defined(HAVE_DYLIB)
+#define HAVE_DYNAMIC_D3D
+#endif
+
+#ifdef HAVE_DYNAMIC_D3D
+#include
+#endif
+
+#include "../../configuration.h"
+#include "../../verbosity.h"
+
+#include
+
+#ifdef HAVE_D3DX
+#ifdef _XBOX
+#include
+#include
+#else
+#include "../include/d3d9/d3dx9tex.h"
+#endif
+
+#endif
+
+#include "d3d9_common.h"
+
+#ifdef _XBOX
+#include
+#endif
+
+static UINT SDKVersion = 0;
+
+#ifdef HAVE_DYNAMIC_D3D
+static dylib_t g_d3d9_dll;
+#ifdef HAVE_D3DX
+static dylib_t g_d3d9x_dll;
+#endif
+static bool d3d9_dylib_initialized = false;
+#endif
+
+typedef IDirect3D9 *(__stdcall *D3DCreate_t)(UINT);
+#ifdef HAVE_D3DX
+typedef HRESULT (__stdcall
+ *D3DCompileShader_t)(
+ LPCSTR pSrcData,
+ UINT srcDataLen,
+ const D3DXMACRO *pDefines,
+ LPD3DXINCLUDE pInclude,
+ LPCSTR pFunctionName,
+ LPCSTR pProfile,
+ DWORD Flags,
+ LPD3DXBUFFER *ppShader,
+ LPD3DXBUFFER *ppErrorMsgs,
+ LPD3DXCONSTANTTABLE *ppConstantTable);
+typedef HRESULT (__stdcall
+ *D3DCompileShaderFromFile_t)(
+ LPCTSTR pSrcFile,
+ const D3DXMACRO *pDefines,
+ LPD3DXINCLUDE pInclude,
+ LPCSTR pFunctionName,
+ LPCSTR pProfile,
+ DWORD Flags,
+ LPD3DXBUFFER *ppShader,
+ LPD3DXBUFFER *ppErrorMsgs,
+ LPD3DXCONSTANTTABLE *ppConstantTable);
+
+typedef HRESULT (__stdcall
+ *D3DCreateTextureFromFile_t)(
+ LPDIRECT3DDEVICE9 pDevice,
+ LPCSTR pSrcFile,
+ UINT Width,
+ UINT Height,
+ UINT MipLevels,
+ DWORD Usage,
+ D3DFORMAT Format,
+ D3DPOOL Pool,
+ DWORD Filter,
+ DWORD MipFilter,
+ D3DCOLOR ColorKey,
+ D3DXIMAGE_INFO* pSrcInfo,
+ PALETTEENTRY* pPalette,
+ LPDIRECT3DTEXTURE9* ppTexture);
+
+typedef HRESULT (__stdcall
+ *D3DXCreateFontIndirect_t)(
+ LPDIRECT3DDEVICE9 pDevice,
+ D3DXFONT_DESC* pDesc,
+ LPD3DXFONT* ppFont);
+#endif
+
+
+#ifdef HAVE_D3DX
+static D3DXCreateFontIndirect_t D3DCreateFontIndirect;
+static D3DCreateTextureFromFile_t D3DCreateTextureFromFile;
+static D3DCompileShaderFromFile_t D3DCompileShaderFromFile;
+static D3DCompileShader_t D3DCompileShader;
+#endif
+static D3DCreate_t D3DCreate;
+
+void *d3d9_create(void)
+{
+ return D3DCreate(SDKVersion);
+}
+
+#ifdef HAVE_DYNAMIC_D3D
+
+#ifdef HAVE_D3DX
+static const char *d3dx9_dll_list[] =
+{
+ "d3dx9_24.dll",
+ "d3dx9_25.dll",
+ "d3dx9_26.dll",
+ "d3dx9_27.dll",
+ "d3dx9_28.dll",
+ "d3dx9_29.dll",
+ "d3dx9_30.dll",
+ "d3dx9_31.dll",
+ "d3dx9_32.dll",
+ "d3dx9_33.dll",
+ "d3dx9_34.dll",
+ "d3dx9_35.dll",
+ "d3dx9_36.dll",
+ "d3dx9_37.dll",
+ "d3dx9_38.dll",
+ "d3dx9_39.dll",
+ "d3dx9_40.dll",
+ "d3dx9_41.dll",
+ "d3dx9_42.dll",
+ "d3dx9_43.dll",
+ NULL
+};
+
+static dylib_t dylib_load_d3d9x(void)
+{
+ dylib_t dll = NULL;
+
+ const char **dll_name = d3dx9_dll_list;
+
+ while (!dll && *dll_name)
+ dll = dylib_load(*dll_name++);
+
+ return dll;
+}
+#endif
+
+#endif
+
+bool d3d9_initialize_symbols(enum gfx_ctx_api api)
+{
+#ifdef HAVE_DYNAMIC_D3D
+ if (d3d9_dylib_initialized)
+ return true;
+
+#if defined(DEBUG) || defined(_DEBUG)
+ g_d3d9_dll = dylib_load("d3d9d.dll");
+ if(!g_d3d9_dll)
+#endif
+ g_d3d9_dll = dylib_load("d3d9.dll");
+#ifdef HAVE_D3DX
+ g_d3d9x_dll = dylib_load_d3d9x();
+
+ if (!g_d3d9x_dll)
+ return false;
+#endif
+
+ if (!g_d3d9_dll)
+ return false;
+#endif
+
+ SDKVersion = 31;
+#ifdef HAVE_DYNAMIC_D3D
+ D3DCreate = (D3DCreate_t)dylib_proc(g_d3d9_dll, "Direct3DCreate9");
+#ifdef HAVE_D3DX
+ D3DCompileShaderFromFile = (D3DCompileShaderFromFile_t)dylib_proc(g_d3d9x_dll, "D3DXCompileShaderFromFile");
+ D3DCompileShader = (D3DCompileShader_t)dylib_proc(g_d3d9x_dll, "D3DXCompileShader");
+#ifdef UNICODE
+ D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3d9x_dll, "D3DXCreateFontIndirectW");
+#else
+ D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3d9x_dll, "D3DXCreateFontIndirectA");
+#endif
+ D3DCreateTextureFromFile = (D3DCreateTextureFromFile_t)dylib_proc(g_d3d9x_dll, "D3DXCreateTextureFromFileExA");
+#endif
+#else
+ D3DCreate = Direct3DCreate9;
+#ifdef HAVE_D3DX
+ D3DCompileShaderFromFile = D3DXCompileShaderFromFile;
+ D3DCompileShader = D3DXCompileShader;
+ D3DCreateFontIndirect = D3DXCreateFontIndirect;
+ D3DCreateTextureFromFile = D3DXCreateTextureFromFileExA;
+#endif
+#endif
+
+ if (!D3DCreate)
+ goto error;
+
+#ifdef _XBOX
+ SDKVersion = 0;
+#endif
+#ifdef HAVE_DYNAMIC_D3D
+ d3d9_dylib_initialized = true;
+#endif
+
+ return true;
+
+error:
+ d3d9_deinitialize_symbols();
+ return false;
+}
+
+void d3d9_deinitialize_symbols(void)
+{
+#ifdef HAVE_DYNAMIC_D3D
+ if (g_d3d9_dll)
+ dylib_close(g_d3d9_dll);
+#ifdef HAVE_D3DX
+ if (g_d3d9x_dll)
+ dylib_close(g_d3d9x_dll);
+ g_d3d9x_dll = NULL;
+#endif
+ g_d3d9_dll = NULL;
+
+ d3d9_dylib_initialized = false;
+#endif
+}
+
+bool d3d9_check_device_type(void *_d3d,
+ unsigned idx,
+ INT32 disp_format,
+ INT32 backbuffer_format,
+ bool windowed_mode)
+{
+ LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
+ if (!d3d)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (FAILED(d3d->CheckDeviceType(
+ 0,
+ D3DDEVTYPE_HAL,
+ (D3DFORMAT)disp_format,
+ (D3DFORMAT)backbuffer_format,
+ windowed_mode)))
+ return false;
+#else
+ if (FAILED(IDirect3D9_CheckDeviceType(d3d,
+ 0,
+ D3DDEVTYPE_HAL,
+ (D3DFORMAT)disp_format,
+ (D3DFORMAT)backbuffer_format,
+ windowed_mode)))
+ return false;
+#endif
+
+ return true;
+}
+
+bool d3d9_get_adapter_display_mode(
+ void *_d3d,
+ unsigned idx,
+ void *display_mode)
+{
+ LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
+ if (!d3d)
+ return false;
+#ifdef _XBOX
+ return true;
+#elif defined(__cplusplus) && !defined(CINTERFACE)
+ if (FAILED(d3d->GetAdapterDisplayMode(idx, (D3DDISPLAYMODE*)display_mode)))
+ return false;
+#else
+ if (FAILED(IDirect3D9_GetAdapterDisplayMode(d3d, idx, (D3DDISPLAYMODE*)display_mode)))
+ return false;
+#endif
+
+ return true;
+}
+
+bool d3d9_swap(void *data, void *_dev)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+#ifdef _XBOX
+ dev->Present(NULL, NULL, NULL, NULL);
+#else
+ if (dev->Present(NULL, NULL, NULL, NULL) != D3D_OK)
+ return false;
+#endif
+#else
+#ifdef _XBOX
+ IDirect3DDevice9_Present(dev, NULL, NULL, NULL, NULL);
+#else
+ if (IDirect3DDevice9_Present(dev, NULL, NULL, NULL, NULL)
+ == D3DERR_DEVICELOST)
+ return false;
+#endif
+#endif
+ return true;
+}
+
+void d3d9_set_transform(void *_dev,
+ INT32 state, const void *_matrix)
+{
+#ifndef _XBOX
+ CONST D3DMATRIX *matrix = (CONST D3DMATRIX*)_matrix;
+ /* XBox 360 D3D9 does not support fixed-function pipeline. */
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetTransform((D3DTRANSFORMSTATETYPE)state, matrix);
+#else
+ IDirect3DDevice9_SetTransform(dev, (D3DTRANSFORMSTATETYPE)state, matrix);
+#endif
+#endif
+}
+
+bool d3d9_texture_get_level_desc(void *_tex,
+ unsigned idx, void *_ppsurface_level)
+{
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(tex->GetLevelDesc(idx, (D3DSURFACE_DESC*)_ppsurface_level)))
+ return true;
+#else
+#if defined(_XBOX)
+ D3DTexture_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level);
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DTexture9_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level)))
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+bool d3d9_texture_get_surface_level(void *_tex,
+ unsigned idx, void **_ppsurface_level)
+{
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
+ if (!tex)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(tex->GetSurfaceLevel(idx, (IDirect3DSurface9**)_ppsurface_level)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DTexture9_GetSurfaceLevel(tex, idx, (IDirect3DSurface9**)_ppsurface_level)))
+ return true;
+#endif
+
+ return false;
+}
+
+#ifdef HAVE_D3DX
+static void *d3d9_texture_new_from_file(
+ void *dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, D3DFORMAT format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info_data,
+ PALETTEENTRY *palette)
+{
+ void *buf = NULL;
+ HRESULT hr = D3DCreateTextureFromFile((LPDIRECT3DDEVICE9)dev,
+ path, width, height, miplevels, usage, format,
+ (D3DPOOL)pool, filter, mipfilter, color_key,
+ (D3DXIMAGE_INFO*)src_info_data,
+ palette, (struct IDirect3DTexture9**)&buf);
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+#endif
+
+void *d3d9_texture_new(void *_dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, INT32 format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info_data,
+ PALETTEENTRY *palette, bool want_mipmap)
+{
+ HRESULT hr = S_OK;
+ void *buf = NULL;
+
+ if (path)
+ {
+#ifdef HAVE_D3DX
+ return d3d9_texture_new_from_file(_dev,
+ path, width, height, miplevels,
+ usage, (D3DFORMAT)format,
+ (D3DPOOL)pool, filter, mipfilter,
+ color_key, src_info_data, palette);
+#else
+ return NULL;
+#endif
+ }
+
+ {
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#ifndef _XBOX
+ if (want_mipmap)
+ usage |= D3DUSAGE_AUTOGENMIPMAP;
+#endif
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ hr = dev->CreateTexture(
+ width, height, miplevels, usage,
+ (D3DFORMAT)format,
+ (D3DPOOL)pool,
+ (struct IDirect3DTexture9**)&buf, NULL);
+#else
+ hr = IDirect3DDevice9_CreateTexture(dev,
+ width, height, miplevels, usage,
+ (D3DFORMAT)format,
+ (D3DPOOL)pool,
+ (struct IDirect3DTexture9**)&buf, NULL);
+#endif
+ }
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+
+void d3d9_texture_free(void *_tex)
+{
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
+ if (!tex)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ tex->Release();
+#else
+ IDirect3DTexture9_Release(tex);
+#endif
+}
+
+bool d3d9_surface_lock_rect(void *data, void *data2)
+{
+ LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
+ if (!surf)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (FAILED(surf->LockRect((D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
+ return false;
+#else
+#if defined(_XBOX)
+ IDirect3DSurface9_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY);
+#else
+ if (FAILED(IDirect3DSurface9_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
+ return false;
+#endif
+#endif
+
+ return true;
+}
+
+void d3d9_surface_unlock_rect(void *data)
+{
+ LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
+ if (!surf)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ surf->UnlockRect();
+#else
+ IDirect3DSurface9_UnlockRect(surf);
+#endif
+}
+
+void d3d9_surface_free(void *data)
+{
+ LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
+ if (!surf)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ surf->Release();
+#else
+ IDirect3DSurface9_Release(surf);
+#endif
+}
+
+void d3d9_vertex_declaration_free(void *data)
+{
+ if (!data)
+ return;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ {
+ LPDIRECT3DVERTEXDECLARATION9 vertex_decl =
+ (LPDIRECT3DVERTEXDECLARATION9)data;
+ if (vertex_decl)
+ vertex_decl->Release();
+ }
+#else
+ IDirect3DVertexDeclaration9_Release((LPDIRECT3DVERTEXDECLARATION9)data);
+#endif
+}
+
+bool d3d9_vertex_declaration_new(void *_dev,
+ const void *vertex_data, void **decl_data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ const D3DVERTEXELEMENT9 *vertex_elements = (const D3DVERTEXELEMENT9*)vertex_data;
+ LPDIRECT3DVERTEXDECLARATION9 **vertex_decl = (LPDIRECT3DVERTEXDECLARATION9**)decl_data;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(dev->CreateVertexDeclaration(vertex_elements,
+ (IDirect3DVertexDeclaration9**)vertex_decl)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice9_CreateVertexDeclaration(dev,
+ vertex_elements, (IDirect3DVertexDeclaration9**)vertex_decl)))
+ return true;
+#endif
+
+ return false;
+}
+
+void *d3d9_vertex_buffer_new(void *_dev,
+ unsigned length, unsigned usage,
+ unsigned fvf, INT32 pool, void *handle)
+{
+ HRESULT hr = S_OK;
+ void *buf = NULL;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+
+ if (usage == 0)
+ {
+#ifndef _XBOX
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->GetSoftwareVertexProcessing())
+ usage = D3DUSAGE_SOFTWAREPROCESSING;
+#else
+ if (IDirect3DDevice9_GetSoftwareVertexProcessing(dev))
+ usage = D3DUSAGE_SOFTWAREPROCESSING;
+#endif
+#endif
+ }
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ hr = dev->CreateVertexBuffer(length, usage, fvf,
+ (D3DPOOL)pool,
+ (LPDIRECT3DVERTEXBUFFER9*)&buf, NULL);
+#else
+ hr = IDirect3DDevice9_CreateVertexBuffer(dev, length, usage, fvf,
+ (D3DPOOL)pool,
+ (LPDIRECT3DVERTEXBUFFER9*)&buf, NULL);
+#endif
+
+ if (FAILED(hr))
+ return NULL;
+
+ return buf;
+}
+
+void d3d9_vertex_buffer_unlock(void *vertbuf_ptr)
+{
+ LPDIRECT3DVERTEXBUFFER9 vertbuf = (LPDIRECT3DVERTEXBUFFER9)vertbuf_ptr;
+
+ if (!vertbuf)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ vertbuf->Unlock();
+#else
+ IDirect3DVertexBuffer9_Unlock(vertbuf);
+#endif
+}
+
+void *d3d9_vertex_buffer_lock(void *vertbuf_ptr)
+{
+ void *buf = NULL;
+ LPDIRECT3DVERTEXBUFFER9 vertbuf = (LPDIRECT3DVERTEXBUFFER9)vertbuf_ptr;
+ if (!vertbuf)
+ return NULL;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ vertbuf->Lock(0, 0, &buf, 0);
+#else
+ IDirect3DVertexBuffer9_Lock(vertbuf, 0, 0, &buf, 0);
+#endif
+
+ if (!buf)
+ return NULL;
+
+ return buf;
+}
+
+void d3d9_vertex_buffer_free(void *vertex_data, void *vertex_declaration)
+{
+ if (vertex_data)
+ {
+ LPDIRECT3DVERTEXBUFFER9 buf = (LPDIRECT3DVERTEXBUFFER9)vertex_data;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ buf->Release();
+#else
+ IDirect3DVertexBuffer9_Release(buf);
+#endif
+ buf = NULL;
+ }
+
+ if (vertex_declaration)
+ {
+ LPDIRECT3DVERTEXDECLARATION9 vertex_decl = (LPDIRECT3DVERTEXDECLARATION9)vertex_declaration;
+ d3d9_vertex_declaration_free(vertex_decl);
+ vertex_decl = NULL;
+ }
+}
+
+void d3d9_set_stream_source(void *_dev, unsigned stream_no,
+ void *stream_vertbuf_ptr, unsigned offset_bytes,
+ unsigned stride)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ LPDIRECT3DVERTEXBUFFER9 stream_vertbuf = (LPDIRECT3DVERTEXBUFFER9)stream_vertbuf_ptr;
+ if (!stream_vertbuf)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetStreamSource(stream_no, stream_vertbuf, offset_bytes, stride);
+#else
+ IDirect3DDevice9_SetStreamSource(dev, stream_no, stream_vertbuf,
+ offset_bytes,
+ stride);
+#endif
+}
+
+bool d3d9_device_create_offscreen_plain_surface(
+ void *_dev,
+ unsigned width,
+ unsigned height,
+ unsigned format,
+ unsigned pool,
+ void **surf_data,
+ void *data)
+{
+#ifndef _XBOX
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(dev->CreateOffscreenPlainSurface(width, height,
+ (D3DFORMAT)format, (D3DPOOL)pool,
+ (LPDIRECT3DSURFACE9*)surf_data,
+ (HANDLE*)data)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice9_CreateOffscreenPlainSurface(dev,
+ width, height,
+ (D3DFORMAT)format, (D3DPOOL)pool,
+ (LPDIRECT3DSURFACE9*)surf_data,
+ (HANDLE*)data)))
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+static void d3d9_set_texture_stage_state(void *_dev,
+ unsigned sampler, unsigned type, unsigned value)
+{
+#ifndef _XBOX
+ /* XBox 360 has no fixed-function pipeline. */
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->SetTextureStageState(sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
+ RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
+#else
+ if (IDirect3DDevice9_SetTextureStageState(dev, sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
+ RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
+#endif
+#endif
+}
+
+void d3d9_set_sampler_address_u(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetSamplerState(sampler, D3DSAMP_ADDRESSU, value);
+#else
+ IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_ADDRESSU, value);
+#endif
+}
+
+void d3d9_set_sampler_address_v(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetSamplerState(sampler, D3DSAMP_ADDRESSV, value);
+#else
+ IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_ADDRESSV, value);
+#endif
+}
+
+void d3d9_set_sampler_minfilter(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetSamplerState(sampler, D3DSAMP_MINFILTER, value);
+#else
+ IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_MINFILTER, value);
+#endif
+}
+
+void d3d9_set_sampler_magfilter(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetSamplerState(sampler, D3DSAMP_MAGFILTER, value);
+#else
+ IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_MAGFILTER, value);
+#endif
+}
+
+void d3d9_set_sampler_mipfilter(void *_dev,
+ unsigned sampler, unsigned value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+ IDirect3DDevice9_SetSamplerState(dev, sampler,
+ D3DSAMP_MIPFILTER, value);
+}
+
+bool d3d9_begin_scene(void *_dev)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (FAILED(dev->BeginScene()))
+ return false;
+#else
+#if defined(_XBOX)
+ IDirect3DDevice9_BeginScene(dev);
+#else
+ if (FAILED(IDirect3DDevice9_BeginScene(dev)))
+ return false;
+#endif
+#endif
+
+ return true;
+}
+
+void d3d9_end_scene(void *_dev)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->EndScene();
+#else
+ IDirect3DDevice9_EndScene(dev);
+#endif
+}
+
+static void d3d9_draw_primitive_internal(void *_dev,
+ D3DPRIMITIVETYPE type, unsigned start, unsigned count)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->DrawPrimitive(type, start, count);
+#else
+ IDirect3DDevice9_DrawPrimitive(dev, type, start, count);
+#endif
+}
+
+void d3d9_draw_primitive(void *dev,
+ INT32 type, unsigned start, unsigned count)
+{
+ if (!d3d9_begin_scene(dev))
+ return;
+
+ d3d9_draw_primitive_internal(dev, (D3DPRIMITIVETYPE)type, start, count);
+ d3d9_end_scene(dev);
+}
+
+void d3d9_clear(void *_dev,
+ unsigned count, const void *rects, unsigned flags,
+ INT32 color, float z, unsigned stencil)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->Clear(count, (const D3DRECT*)rects, flags, color, z, stencil);
+#else
+ IDirect3DDevice9_Clear(dev, count, (const D3DRECT*)rects, flags,
+ color, z, stencil);
+#endif
+}
+
+bool d3d9_device_get_render_target_data(void *_dev,
+ void *_src, void *_dst)
+{
+#ifndef _XBOX
+ LPDIRECT3DSURFACE9 src = (LPDIRECT3DSURFACE9)_src;
+ LPDIRECT3DSURFACE9 dst = (LPDIRECT3DSURFACE9)_dst;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(dev->GetRenderTargetData(src, dst)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice9_GetRenderTargetData(
+ dev, src, dst)))
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+bool d3d9_device_get_render_target(void *_dev,
+ unsigned idx, void **data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(dev->GetRenderTarget(idx,
+ (LPDIRECT3DSURFACE9*)data)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice9_GetRenderTarget(dev,
+ idx, (LPDIRECT3DSURFACE9*)data)))
+ return true;
+#endif
+
+ return false;
+}
+
+
+bool d3d9_lock_rectangle(void *_tex,
+ unsigned level, void *_lr, RECT *rect,
+ unsigned rectangle_height, unsigned flags)
+{
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
+ if (!tex)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (FAILED(tex->LockRect(level, lr, rect, flags)))
+ return false;
+#else
+#ifdef _XBOX
+ IDirect3DTexture9_LockRect(tex, level, lr, (const RECT*)rect, flags);
+#else
+ if (IDirect3DTexture9_LockRect(tex, level, lr, (const RECT*)rect, flags) != D3D_OK)
+ return false;
+#endif
+#endif
+
+ return true;
+}
+
+void d3d9_unlock_rectangle(void *_tex)
+{
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
+ if (!tex)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ tex->UnlockRect(0);
+#else
+ IDirect3DTexture9_UnlockRect(tex, 0);
+#endif
+}
+
+void d3d9_lock_rectangle_clear(void *tex,
+ unsigned level, void *_lr, RECT *rect,
+ unsigned rectangle_height, unsigned flags)
+{
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+#if defined(_XBOX)
+ level = 0;
+#endif
+ memset(lr->pBits, level, rectangle_height * lr->Pitch);
+ d3d9_unlock_rectangle(tex);
+}
+
+void d3d9_set_viewports(void *_dev, void *_vp)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ D3DVIEWPORT9 *vp = (D3DVIEWPORT9*)_vp;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetViewport(vp);
+#else
+ IDirect3DDevice9_SetViewport(dev, vp);
+#endif
+}
+
+void d3d9_set_texture(void *_dev, unsigned sampler,
+ void *tex_data)
+{
+ LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)tex_data;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev || !tex)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetTexture(sampler, tex);
+#else
+ IDirect3DDevice9_SetTexture(dev, sampler,
+ (IDirect3DBaseTexture9*)tex);
+#endif
+}
+
+void d3d9_free_vertex_shader(void *_dev, void *data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ IDirect3DVertexShader9 *vs = (IDirect3DVertexShader9*)data;
+ if (!dev || !vs)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ vs->Release();
+#else
+ IDirect3DVertexShader9_Release(vs);
+#endif
+}
+
+void d3d9_free_pixel_shader(void *_dev, void *data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ IDirect3DPixelShader9 *ps = (IDirect3DPixelShader9*)data;
+ if (!dev || !ps)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ ps->Release();
+#else
+ IDirect3DPixelShader9_Release(ps);
+#endif
+}
+
+bool d3d9_create_vertex_shader(void *_dev, const DWORD *a, void **b)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->CreateVertexShader(a, (IDirect3DVertexShader9**)b) == D3D_OK)
+ return true;
+#else
+ if (IDirect3DDevice9_CreateVertexShader(dev, a,
+ (LPDIRECT3DVERTEXSHADER9*)b) == D3D_OK)
+ return true;
+#endif
+
+ return false;
+}
+
+bool d3d9_create_pixel_shader(void *_dev, const DWORD *a, void **b)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->CreatePixelShader(a, (IDirect3DPixelShader9**)b) == D3D_OK)
+ return true;
+#else
+ if (IDirect3DDevice9_CreatePixelShader(dev, a,
+ (LPDIRECT3DPIXELSHADER9*)b) == D3D_OK)
+ return true;
+#endif
+
+ return false;
+}
+
+bool d3d9_set_pixel_shader(void *_dev, void *data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ LPDIRECT3DPIXELSHADER9 d3dps = (LPDIRECT3DPIXELSHADER9)data;
+ if (!dev || !d3dps)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->SetPixelShader(d3dps) == D3D_OK)
+ return true;
+#else
+#ifdef _XBOX
+ /* Returns void on Xbox */
+ IDirect3DDevice9_SetPixelShader(dev, d3dps);
+ return true;
+#else
+ if (IDirect3DDevice9_SetPixelShader(dev, d3dps) == D3D_OK)
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+bool d3d9_set_vertex_shader(void *_dev, unsigned index,
+ void *data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ LPDIRECT3DVERTEXSHADER9 shader = (LPDIRECT3DVERTEXSHADER9)data;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->SetVertexShader(shader) != D3D_OK)
+ return false;
+#else
+#ifdef _XBOX
+ IDirect3DDevice9_SetVertexShader(dev, shader);
+#else
+ if (IDirect3DDevice9_SetVertexShader(dev, shader) != D3D_OK)
+ return false;
+#endif
+#endif
+
+ return true;
+}
+
+bool d3d9_set_vertex_shader_constantf(void *_dev,
+ UINT start_register,const float* constant_data,
+ unsigned vector4f_count)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+#ifdef _XBOX
+ dev->SetVertexShaderConstantF(
+ start_register, constant_data, vector4f_count);
+#else
+ if (dev->SetVertexShaderConstantF(
+ start_register, constant_data, vector4f_count) == D3D_OK)
+ return true;
+#endif
+#else
+#ifdef _XBOX
+ IDirect3DDevice9_SetVertexShaderConstantF(dev,
+ start_register, constant_data, vector4f_count);
+ return true;
+#else
+ if (IDirect3DDevice9_SetVertexShaderConstantF(dev,
+ start_register, constant_data, vector4f_count) == D3D_OK)
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+void d3d9_texture_blit(unsigned pixel_size,
+ void *tex,
+ void *_lr, const void *frame,
+ unsigned width, unsigned height, unsigned pitch)
+{
+ unsigned y;
+ D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
+
+ for (y = 0; y < height; y++)
+ {
+ const uint8_t *in = (const uint8_t*)frame + y * pitch;
+ uint8_t *out = (uint8_t*)lr->pBits + y * lr->Pitch;
+ memcpy(out, in, width * pixel_size);
+ }
+}
+
+bool d3d9_get_render_state(void *data, INT32 state, DWORD *value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (dev->GetRenderState((D3DRENDERSTATETYPE)state, value) == D3D_OK)
+ return true;
+#else
+#ifdef _XBOX
+ IDirect3DDevice9_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
+ return true;
+#else
+ if (IDirect3DDevice9_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value) == D3D_OK)
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+void d3d9_set_render_state(void *data, INT32 state, DWORD value)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetRenderState((D3DRENDERSTATETYPE)state, value);
+#else
+ IDirect3DDevice9_SetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
+#endif
+}
+
+void d3d9_enable_blend_func(void *data)
+{
+ if (!data)
+ return;
+
+ d3d9_set_render_state(data, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
+ d3d9_set_render_state(data, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+ d3d9_set_render_state(data, D3DRS_ALPHABLENDENABLE, true);
+}
+
+void d3d9_device_set_render_target(void *_dev, unsigned idx,
+ void *data)
+{
+ LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetRenderTarget(idx, surf);
+#else
+ IDirect3DDevice9_SetRenderTarget(dev, idx, surf);
+#endif
+}
+
+void d3d9_enable_alpha_blend_texture_func(void *data)
+{
+ /* Also blend the texture with the set alpha value. */
+ d3d9_set_texture_stage_state(data, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
+ d3d9_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
+ d3d9_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
+}
+
+void d3d9_disable_blend_func(void *data)
+{
+ d3d9_set_render_state(data, D3DRS_ALPHABLENDENABLE, false);
+}
+
+void d3d9_set_vertex_declaration(void *data, void *vertex_data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->SetVertexDeclaration((LPDIRECT3DVERTEXDECLARATION9)vertex_data);
+#else
+ IDirect3DDevice9_SetVertexDeclaration(dev, (LPDIRECT3DVERTEXDECLARATION9)vertex_data);
+#endif
+}
+
+static bool d3d9_reset_internal(void *data,
+ D3DPRESENT_PARAMETERS *d3dpp
+ )
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if ((dev->Reset(d3dpp) == D3D_OK))
+ return true;
+#else
+ if (IDirect3DDevice9_Reset(dev, d3dpp) == D3D_OK)
+ return true;
+#endif
+
+ return false;
+}
+
+static HRESULT d3d9_test_cooperative_level(void *data)
+{
+#ifdef _XBOX
+ return E_FAIL;
+#else
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return E_FAIL;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ return dev->TestCooperativeLevel();
+#else
+ return IDirect3DDevice9_TestCooperativeLevel(dev);
+#endif
+#endif
+}
+
+static bool d3d9_create_device_internal(
+ void *data,
+ D3DPRESENT_PARAMETERS *d3dpp,
+ void *_d3d,
+ HWND focus_window,
+ unsigned cur_mon_id,
+ DWORD behavior_flags)
+{
+ LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(d3d->CreateDevice(
+ cur_mon_id,
+ D3DDEVTYPE_HAL,
+ focus_window,
+ behavior_flags,
+ d3dpp,
+ (IDirect3DDevice9**)dev)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3D9_CreateDevice(d3d,
+ cur_mon_id,
+ D3DDEVTYPE_HAL,
+ focus_window,
+ behavior_flags,
+ d3dpp,
+ (IDirect3DDevice9**)dev)))
+ return true;
+#endif
+
+ return false;
+}
+
+bool d3d9_create_device(void *dev,
+ void *d3dpp,
+ void *d3d,
+ HWND focus_window,
+ unsigned cur_mon_id)
+{
+ if (!d3d9_create_device_internal(dev,
+ (D3DPRESENT_PARAMETERS*)d3dpp,
+ d3d,
+ focus_window,
+ cur_mon_id,
+ D3DCREATE_HARDWARE_VERTEXPROCESSING))
+ if (!d3d9_create_device_internal(
+ dev,
+ (D3DPRESENT_PARAMETERS*)d3dpp, d3d, focus_window,
+ cur_mon_id,
+ D3DCREATE_SOFTWARE_VERTEXPROCESSING))
+ return false;
+ return true;
+}
+
+bool d3d9_reset(void *dev, void *d3dpp)
+{
+ const char *err = NULL;
+
+ if (d3d9_reset_internal(dev, (D3DPRESENT_PARAMETERS*)d3dpp))
+ return true;
+
+ RARCH_WARN("[D3D]: Attempting to recover from dead state...\n");
+
+#ifndef _XBOX
+ /* Try to recreate the device completely. */
+ switch (d3d9_test_cooperative_level(dev))
+ {
+ case D3DERR_DEVICELOST:
+ err = "DEVICELOST";
+ break;
+
+ case D3DERR_DEVICENOTRESET:
+ err = "DEVICENOTRESET";
+ break;
+
+ case D3DERR_DRIVERINTERNALERROR:
+ err = "DRIVERINTERNALERROR";
+ break;
+
+ default:
+ err = "Unknown";
+ }
+ RARCH_WARN("[D3D]: recovering from dead state: (%s).\n", err);
+#endif
+
+ return false;
+}
+
+bool d3d9_device_get_backbuffer(void *_dev,
+ unsigned idx, unsigned swapchain_idx,
+ unsigned backbuffer_type, void **data)
+{
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (!dev)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (SUCCEEDED(dev->GetBackBuffer(
+ swapchain_idx, idx,
+ (D3DBACKBUFFER_TYPE)backbuffer_type,
+ (LPDIRECT3DSURFACE9*)data)))
+ return true;
+#else
+ if (SUCCEEDED(IDirect3DDevice9_GetBackBuffer(dev,
+ swapchain_idx, idx,
+ (D3DBACKBUFFER_TYPE)backbuffer_type,
+ (LPDIRECT3DSURFACE9*)data)))
+ return true;
+#endif
+
+ return false;
+}
+
+
+void d3d9_device_free(void *_dev, void *_pd3d)
+{
+ LPDIRECT3D9 pd3d = (LPDIRECT3D9)_pd3d;
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+ if (dev)
+ {
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ dev->Release();
+#else
+ IDirect3DDevice9_Release(dev);
+#endif
+ }
+
+ if (pd3d)
+ {
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ pd3d->Release();
+#else
+ IDirect3D9_Release(pd3d);
+#endif
+ }
+}
+
+INT32 d3d9_translate_filter(unsigned type)
+{
+ switch (type)
+ {
+ case RARCH_FILTER_UNSPEC:
+ {
+ settings_t *settings = config_get_ptr();
+ if (!settings->bools.video_smooth)
+ break;
+ }
+ /* fall-through */
+ case RARCH_FILTER_LINEAR:
+ return D3DTEXF_LINEAR;
+ case RARCH_FILTER_NEAREST:
+ break;
+ }
+
+ return D3DTEXF_POINT;
+}
+
+bool d3d9x_create_font_indirect(void *_dev,
+ void *desc, void **font_data)
+{
+#ifdef HAVE_D3DX
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
+#ifdef __cplusplus
+ if (SUCCEEDED(D3DCreateFontIndirect(
+ dev, (D3DXFONT_DESC*)desc,
+ (struct ID3DXFont**)font_data)))
+ return true;
+#else
+ if (SUCCEEDED(D3DCreateFontIndirect(
+ dev, (D3DXFONT_DESC*)desc,
+ (struct ID3DXFont**)font_data)))
+ return true;
+#endif
+#endif
+
+ return false;
+}
+
+void d3dxbuffer_release(void *data)
+{
+#ifdef HAVE_D3DX
+#ifdef __cplusplus
+ ID3DXBuffer *p = (ID3DXBuffer*)data;
+#else
+ LPD3DXBUFFER p = (LPD3DXBUFFER)data;
+#endif
+ if (!p)
+ return;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ p->Release();
+#else
+ p->lpVtbl->Release(p);
+#endif
+#endif
+}
+
+bool d3d9x_compile_shader(
+ const char *src,
+ unsigned src_data_len,
+ const void *pdefines,
+ void *pinclude,
+ const char *pfunctionname,
+ const char *pprofile,
+ unsigned flags,
+ void *ppshader,
+ void *pperrormsgs,
+ void *ppconstanttable)
+{
+#if defined(HAVE_D3DX)
+ if (D3DCompileShader)
+ if (D3DCompileShader(
+ (LPCTSTR)src,
+ (UINT)src_data_len,
+ (const D3DXMACRO*)pdefines,
+ (LPD3DXINCLUDE)pinclude,
+ (LPCSTR)pfunctionname,
+ (LPCSTR)pprofile,
+ (DWORD)flags,
+ (LPD3DXBUFFER*)ppshader,
+ (LPD3DXBUFFER*)pperrormsgs,
+ (LPD3DXCONSTANTTABLE*)ppconstanttable) >= 0)
+ return true;
+#endif
+ return false;
+}
+
+void d3d9x_font_draw_text(void *data, void *sprite_data, void *string_data,
+ unsigned count, void *rect_data, unsigned format, unsigned color)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->DrawText(font, (LPD3DXSPRITE)sprite_data,
+ (LPCTSTR)string_data, count, (LPRECT)rect_data,
+ (DWORD)format, (D3DCOLOR)color);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->DrawText((LPD3DXSPRITE)sprite_data,
+ (LPCTSTR)string_data, count, (LPRECT)rect_data,
+ (DWORD)format, (D3DCOLOR)color);
+#endif
+#endif
+}
+
+void d3d9x_font_release(void *data)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->Release(font);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->Release();
+#endif
+#endif
+}
+
+void d3d9x_font_get_text_metrics(void *data, void *metrics)
+{
+#ifdef HAVE_D3DX
+#if !defined(__cplusplus) || defined(CINTERFACE)
+ ID3DXFont *font = (ID3DXFont*)data;
+ if (!font)
+ return;
+ font->lpVtbl->GetTextMetrics(font, (TEXTMETRICA*)metrics);
+#else
+ LPD3DXFONT font = (LPD3DXFONT)data;
+ if (!font)
+ return;
+ font->GetTextMetricsA((TEXTMETRICA*)metrics);
+#endif
+#endif
+}
+
+bool d3d9x_compile_shader_from_file(
+ const char *src,
+ const void *pdefines,
+ void *pinclude,
+ const char *pfunctionname,
+ const char *pprofile,
+ unsigned flags,
+ void *ppshader,
+ void *pperrormsgs,
+ void *ppconstanttable)
+{
+#if defined(HAVE_D3DX)
+ if (D3DCompileShaderFromFile)
+ if (D3DCompileShaderFromFile(
+ (LPCTSTR)src,
+ (const D3DXMACRO*)pdefines,
+ (LPD3DXINCLUDE)pinclude,
+ (LPCSTR)pfunctionname,
+ (LPCSTR)pprofile,
+ (DWORD)flags,
+ (LPD3DXBUFFER*)ppshader,
+ (LPD3DXBUFFER*)pperrormsgs,
+ (LPD3DXCONSTANTTABLE*)ppconstanttable) >= 0)
+ return true;
+#endif
+ return false;
+}
+
+INT32 d3d9_get_rgb565_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_R5G6B5;
+#else
+ return D3DFMT_R5G6B5;
+#endif
+}
+
+INT32 d3d9_get_argb8888_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_A8R8G8B8;
+#else
+ return D3DFMT_A8R8G8B8;
+#endif
+}
+
+INT32 d3d9_get_xrgb8888_format(void)
+{
+#ifdef _XBOX
+ return D3DFMT_LIN_X8R8G8B8;
+#else
+ return D3DFMT_X8R8G8B8;
+#endif
+}
+
+const void *d3d9x_get_buffer_ptr(void *data)
+{
+#if defined(HAVE_D3DX)
+ ID3DXBuffer *listing = (ID3DXBuffer*)data;
+ if (!listing)
+ return NULL;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ return listing->GetBufferPointer();
+#else
+ return listing->lpVtbl->GetBufferPointer(listing);
+#endif
+#else
+ return NULL;
+#endif
+}
+
+const bool d3d9x_constant_table_set_float(void *p,
+ void *a,
+ const void *b, float val)
+{
+#if defined(HAVE_D3DX)
+ LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)a;
+ D3DXHANDLE handle = (D3DXHANDLE)b;
+ LPD3DXCONSTANTTABLE consttbl = (LPD3DXCONSTANTTABLE)p;
+ if (!consttbl || !dev || !handle)
+ return false;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ if (consttbl->SetFloat(dev, handle, val) == D3D_OK)
+ return true;
+#else
+ if (consttbl->lpVtbl->SetFloat(consttbl, dev, handle, val) == D3D_OK)
+ return true;
+#endif
+#endif
+ return false;
+}
diff --git a/gfx/common/d3d9_common.h b/gfx/common/d3d9_common.h
new file mode 100644
index 0000000000..008ae8cde3
--- /dev/null
+++ b/gfx/common/d3d9_common.h
@@ -0,0 +1,249 @@
+/* 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 .
+ */
+
+#ifndef _D3D9_COMMON_H
+#define _D3D9_COMMON_H
+
+#include
+#include
+
+#include "../video_driver.h"
+
+RETRO_BEGIN_DECLS
+
+bool d3d9_swap(void *data, void *dev);
+
+void *d3d9_vertex_buffer_new(void *dev,
+ unsigned length, unsigned usage, unsigned fvf,
+ INT32 pool, void *handle);
+
+void *d3d9_vertex_buffer_lock(void *data);
+void d3d9_vertex_buffer_unlock(void *data);
+
+void d3d9_vertex_buffer_free(void *vertex_data, void *vertex_declaration);
+
+bool d3d9_texture_get_level_desc(void *tex,
+ unsigned idx, void *_ppsurface_level);
+
+bool d3d9_texture_get_surface_level(void *tex,
+ unsigned idx, void **_ppsurface_level);
+
+void *d3d9_texture_new(void *dev,
+ const char *path, unsigned width, unsigned height,
+ unsigned miplevels, unsigned usage, INT32 format,
+ INT32 pool, unsigned filter, unsigned mipfilter,
+ INT32 color_key, void *src_info,
+ PALETTEENTRY *palette, bool want_mipmap);
+
+void d3d9_set_stream_source(void *dev, unsigned stream_no,
+ void *stream_vertbuf, unsigned offset_bytes,
+ unsigned stride);
+
+void d3d9_texture_free(void *tex);
+
+void d3d9_set_transform(void *dev,
+ INT32 state, const void *_matrix);
+
+void d3d9_set_sampler_address_u(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d9_set_sampler_address_v(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d9_set_sampler_minfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d9_set_sampler_magfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+void d3d9_set_sampler_mipfilter(void *dev,
+ unsigned sampler, unsigned value);
+
+bool d3d9_begin_scene(void *dev);
+
+void d3d9_end_scene(void *dev);
+
+void d3d9_draw_primitive(void *dev,
+ INT32 type, unsigned start, unsigned count);
+
+void d3d9_clear(void *dev,
+ unsigned count, const void *rects, unsigned flags,
+ INT32 color, float z, unsigned stencil);
+
+bool d3d9_lock_rectangle(void *tex,
+ unsigned level, void *lock_rect, RECT *rect,
+ unsigned rectangle_height, unsigned flags);
+
+void d3d9_lock_rectangle_clear(void *tex,
+ unsigned level, void *lock_rect, RECT *rect,
+ unsigned rectangle_height, unsigned flags);
+
+void d3d9_unlock_rectangle(void *tex);
+
+void d3d9_set_texture(void *dev, unsigned sampler,
+ void *tex_data);
+
+bool d3d9_create_vertex_shader(void *dev,
+ const DWORD *a, void **b);
+
+bool d3d9_create_pixel_shader(void *dev,
+ const DWORD *a, void **b);
+
+void d3d9_free_pixel_shader(void *dev, void *data);
+
+void d3d9_free_vertex_shader(void *dev, void *data);
+
+bool d3d9_set_pixel_shader(void *dev, void *data);
+
+bool d3d9_set_vertex_shader(void *dev, unsigned index,
+ void *data);
+
+bool d3d9_set_vertex_shader_constantf(void *dev,
+ UINT start_register,const float* constant_data, unsigned vector4f_count);
+
+void d3d9_texture_blit(unsigned pixel_size,
+ void *tex,
+ void *lr, const void *frame,
+ unsigned width, unsigned height, unsigned pitch);
+
+bool d3d9_vertex_declaration_new(void *dev,
+ const void *vertex_data, void **decl_data);
+
+void d3d9_vertex_declaration_free(void *data);
+
+void d3d9_set_viewports(void *dev, void *vp);
+
+void d3d9_enable_blend_func(void *data);
+
+void d3d9_disable_blend_func(void *data);
+
+void d3d9_set_vertex_declaration(void *data, void *vertex_data);
+
+void d3d9_enable_alpha_blend_texture_func(void *data);
+
+void d3d9_frame_postprocess(void *data);
+
+void d3d9_surface_free(void *data);
+
+bool d3d9_device_get_render_target_data(void *dev,
+ void *_src, void *_dst);
+
+bool d3d9_device_get_render_target(void *dev,
+ unsigned idx, void **data);
+
+void d3d9_device_set_render_target(void *dev, unsigned idx,
+ void *data);
+
+bool d3d9_get_render_state(void *data,
+ INT32 state, DWORD *value);
+
+void d3d9_set_render_state(void *data,
+ INT32 state, DWORD value);
+
+void d3d9_device_set_render_target(void *dev, unsigned idx,
+ void *data);
+
+bool d3d9_device_create_offscreen_plain_surface(
+ void *dev,
+ unsigned width,
+ unsigned height,
+ unsigned format,
+ unsigned pool,
+ void **surf_data,
+ void *data);
+
+bool d3d9_surface_lock_rect(void *data, void *data2);
+
+void d3d9_surface_unlock_rect(void *data);
+
+bool d3d9_get_adapter_display_mode(void *d3d,
+ unsigned idx,
+ void *display_mode);
+
+bool d3d9_create_device(void *dev,
+ void *d3dpp,
+ void *d3d,
+ HWND focus_window,
+ unsigned cur_mon_id);
+
+bool d3d9_reset(void *dev, void *d3dpp);
+
+bool d3d9_device_get_backbuffer(void *dev,
+ unsigned idx, unsigned swapchain_idx,
+ unsigned backbuffer_type, void **data);
+
+void d3d9_device_free(void *dev, void *pd3d);
+
+void *d3d9_create(void);
+
+bool d3d9_initialize_symbols(enum gfx_ctx_api api);
+
+void d3d9_deinitialize_symbols(void);
+
+bool d3d9_check_device_type(void *d3d,
+ unsigned idx,
+ INT32 disp_format,
+ INT32 backbuffer_format,
+ bool windowed_mode);
+
+bool d3d9x_create_font_indirect(void *dev,
+ void *desc, void **font_data);
+
+void d3d9x_font_draw_text(void *data, void *sprite_data, void *string_data,
+ unsigned count, void *rect_data, unsigned format, unsigned color);
+
+void d3d9x_font_get_text_metrics(void *data, void *metrics);
+
+void d3dxbuffer_release(void *data);
+
+void d3d9x_font_release(void *data);
+
+INT32 d3d9_translate_filter(unsigned type);
+
+bool d3d9x_compile_shader(
+ const char *src,
+ unsigned src_data_len,
+ const void *pdefines,
+ void *pinclude,
+ const char *pfunctionname,
+ const char *pprofile,
+ unsigned flags,
+ void *ppshader,
+ void *pperrormsgs,
+ void *ppconstanttable);
+
+bool d3d9x_compile_shader_from_file(
+ const char *src,
+ const void *pdefines,
+ void *pinclude,
+ const char *pfunctionname,
+ const char *pprofile,
+ unsigned flags,
+ void *ppshader,
+ void *pperrormsgs,
+ void *ppconstanttable);
+
+const void *d3d9x_get_buffer_ptr(void *data);
+
+const bool d3d9x_constant_table_set_float(void *p,
+ void *a, const void *b, float val);
+
+INT32 d3d9_get_rgb565_format(void);
+INT32 d3d9_get_argb8888_format(void);
+INT32 d3d9_get_xrgb8888_format(void);
+
+RETRO_END_DECLS
+
+#endif
diff --git a/gfx/common/d3d_common.c b/gfx/common/d3d_common.c
index 4d8fc4406b..6740f9c985 100644
--- a/gfx/common/d3d_common.c
+++ b/gfx/common/d3d_common.c
@@ -16,14 +16,6 @@
/* For Xbox we will just link statically
* to Direct3D libraries instead. */
-#if !defined(_XBOX) && defined(HAVE_DYLIB)
-#define HAVE_DYNAMIC_D3D
-#endif
-
-#ifdef HAVE_DYNAMIC_D3D
-#include
-#endif
-
#include "../../configuration.h"
#include "../../verbosity.h"
@@ -57,2678 +49,6 @@
#include "d3d_common.h"
-static enum gfx_ctx_api d3d_common_api = GFX_CTX_NONE;
-
-#ifdef _XBOX
-#include
-#endif
-
-static UINT SDKVersion = 0;
-
-#ifdef HAVE_DYNAMIC_D3D
-static dylib_t g_d3d_dll;
-#ifdef HAVE_D3DX
-static dylib_t g_d3dx_dll;
-#endif
-static bool dylib_initialized = false;
-#endif
-
-#if defined(HAVE_D3D9)
-typedef IDirect3D9 *(__stdcall *D3DCreate_t)(UINT);
-#ifdef HAVE_D3DX
-typedef HRESULT (__stdcall
- *D3DCompileShader_t)(
- LPCSTR pSrcData,
- UINT srcDataLen,
- const D3DXMACRO *pDefines,
- LPD3DXINCLUDE pInclude,
- LPCSTR pFunctionName,
- LPCSTR pProfile,
- DWORD Flags,
- LPD3DXBUFFER *ppShader,
- LPD3DXBUFFER *ppErrorMsgs,
- LPD3DXCONSTANTTABLE *ppConstantTable);
-typedef HRESULT (__stdcall
- *D3DCompileShaderFromFile_t)(
- LPCTSTR pSrcFile,
- const D3DXMACRO *pDefines,
- LPD3DXINCLUDE pInclude,
- LPCSTR pFunctionName,
- LPCSTR pProfile,
- DWORD Flags,
- LPD3DXBUFFER *ppShader,
- LPD3DXBUFFER *ppErrorMsgs,
- LPD3DXCONSTANTTABLE *ppConstantTable);
-
-typedef HRESULT (__stdcall
- *D3DCreateTextureFromFile_t)(
- LPDIRECT3DDEVICE9 pDevice,
- LPCSTR pSrcFile,
- UINT Width,
- UINT Height,
- UINT MipLevels,
- DWORD Usage,
- D3DFORMAT Format,
- D3DPOOL Pool,
- DWORD Filter,
- DWORD MipFilter,
- D3DCOLOR ColorKey,
- D3DXIMAGE_INFO* pSrcInfo,
- PALETTEENTRY* pPalette,
- LPDIRECT3DTEXTURE9* ppTexture);
-
-typedef HRESULT (__stdcall
- *D3DXCreateFontIndirect_t)(
- LPDIRECT3DDEVICE9 pDevice,
- D3DXFONT_DESC* pDesc,
- LPD3DXFONT* ppFont);
-#endif
-#elif defined(HAVE_D3D8)
-typedef IDirect3D8 *(__stdcall *D3DCreate_t)(UINT);
-#ifdef HAVE_D3DX
-typedef HRESULT (__stdcall
- *D3DCreateTextureFromFile_t)(
- LPDIRECT3DDEVICE8 pDevice,
- LPCSTR pSrcFile,
- UINT Width,
- UINT Height,
- UINT MipLevels,
- DWORD Usage,
- D3DFORMAT Format,
- D3DPOOL Pool,
- DWORD Filter,
- DWORD MipFilter,
- D3DCOLOR ColorKey,
- D3DXIMAGE_INFO* pSrcInfo,
- PALETTEENTRY* pPalette,
- LPDIRECT3DTEXTURE8* ppTexture);
-
-typedef HRESULT (__stdcall
- *D3DXCreateFontIndirect_t)(
- LPDIRECT3DDEVICE8 pDevice,
- CONST LOGFONT* pDesc,
- LPD3DXFONT* ppFont);
-#endif
-#endif
-
-
-#ifdef HAVE_D3DX
-static D3DXCreateFontIndirect_t D3DCreateFontIndirect;
-static D3DCreateTextureFromFile_t D3DCreateTextureFromFile;
-#ifdef HAVE_D3D9
-static D3DCompileShaderFromFile_t D3DCompileShaderFromFile;
-static D3DCompileShader_t D3DCompileShader;
-#endif
-#endif
-static D3DCreate_t D3DCreate;
-
-void *d3d_create(void)
-{
- return D3DCreate(SDKVersion);
-}
-
-#ifdef HAVE_DYNAMIC_D3D
-
-#ifdef HAVE_D3DX
-static const char *d3dx9_dll_list[] =
-{
- "d3dx9_24.dll",
- "d3dx9_25.dll",
- "d3dx9_26.dll",
- "d3dx9_27.dll",
- "d3dx9_28.dll",
- "d3dx9_29.dll",
- "d3dx9_30.dll",
- "d3dx9_31.dll",
- "d3dx9_32.dll",
- "d3dx9_33.dll",
- "d3dx9_34.dll",
- "d3dx9_35.dll",
- "d3dx9_36.dll",
- "d3dx9_37.dll",
- "d3dx9_38.dll",
- "d3dx9_39.dll",
- "d3dx9_40.dll",
- "d3dx9_41.dll",
- "d3dx9_42.dll",
- "d3dx9_43.dll",
- NULL
-};
-
-static dylib_t dylib_load_d3dx(void)
-{
- dylib_t dll = NULL;
-
-#if defined(HAVE_D3D9)
- const char **dll_name = d3dx9_dll_list;
-
- while (!dll && *dll_name)
- dll = dylib_load(*dll_name++);
-#endif
-
- return dll;
-}
-#endif
-
-#endif
-
-bool d3d_initialize_symbols(enum gfx_ctx_api api)
-{
-#ifdef HAVE_DYNAMIC_D3D
- if (dylib_initialized)
- return true;
-
- switch (api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#if defined(HAVE_D3D9)
-#if defined(DEBUG) || defined(_DEBUG)
- g_d3d_dll = dylib_load("d3d9d.dll");
- if(!g_d3d_dll)
-#endif
- g_d3d_dll = dylib_load("d3d9.dll");
-#ifdef HAVE_D3DX
- g_d3dx_dll = dylib_load_d3dx();
-
- if (!g_d3dx_dll)
- return false;
-#endif
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
-#if defined(HAVE_D3D8)
-#if defined(DEBUG) || defined(_DEBUG)
- g_d3d_dll = dylib_load("d3d8d.dll");
- if(!g_d3d_dll)
-#endif
- g_d3d_dll = dylib_load("d3d8.dll");
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- if (!g_d3d_dll)
- return false;
-#endif
-
- d3d_common_api = api;
-
- switch (api)
- {
- case GFX_CTX_DIRECT3D9_API:
- SDKVersion = 31;
-#ifdef HAVE_D3D9
-#ifdef HAVE_DYNAMIC_D3D
- D3DCreate = (D3DCreate_t)dylib_proc(g_d3d_dll, "Direct3DCreate9");
-#ifdef HAVE_D3DX
- D3DCompileShaderFromFile = (D3DCompileShaderFromFile_t)dylib_proc(g_d3dx_dll, "D3DXCompileShaderFromFile");
- D3DCompileShader = (D3DCompileShader_t)dylib_proc(g_d3dx_dll, "D3DXCompileShader");
-#ifdef UNICODE
- D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3dx_dll, "D3DXCreateFontIndirectW");
-#else
- D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3dx_dll, "D3DXCreateFontIndirectA");
-#endif
- D3DCreateTextureFromFile = (D3DCreateTextureFromFile_t)dylib_proc(g_d3dx_dll, "D3DXCreateTextureFromFileExA");
-#endif
-#else
- D3DCreate = Direct3DCreate9;
-#ifdef HAVE_D3DX
- D3DCompileShaderFromFile = D3DXCompileShaderFromFile;
- D3DCompileShader = D3DXCompileShader;
- D3DCreateFontIndirect = D3DXCreateFontIndirect;
- D3DCreateTextureFromFile = D3DXCreateTextureFromFileExA;
-#endif
-#endif
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- SDKVersion = 220;
-#ifdef HAVE_D3D8
-#ifdef HAVE_DYNAMIC_D3D
- D3DCreate = (D3DCreate_t)dylib_proc(g_d3d_dll, "Direct3DCreate8");
-#ifdef HAVE_D3DX
-#ifdef UNICODE
- D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3dx_dll, "D3DXCreateFontIndirectW");
-#else
- D3DCreateFontIndirect = (D3DXCreateFontIndirect_t)dylib_proc(g_d3dx_dll, "D3DXCreateFontIndirectA");
-#endif
- D3DCreateTextureFromFile = (D3DCreateTextureFromFile_t)dylib_proc(g_d3dx_dll, "D3DXCreateTextureFromFileExA");
-#endif
-#else
- D3DCreate = Direct3DCreate8;
-#ifdef HAVE_D3DX
- D3DCreateFontIndirect = D3DXCreateFontIndirect;
- D3DCreateTextureFromFile = D3DXCreateTextureFromFileExA;
-#endif
-#endif
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- if (!D3DCreate)
- goto error;
-
-#ifdef _XBOX
- SDKVersion = 0;
-#endif
-#ifdef HAVE_DYNAMIC_D3D
- dylib_initialized = true;
-#endif
-
- return true;
-
-error:
- d3d_deinitialize_symbols();
- return false;
-}
-
-void d3d_deinitialize_symbols(void)
-{
-#ifdef HAVE_DYNAMIC_D3D
- if (g_d3d_dll)
- dylib_close(g_d3d_dll);
-#ifdef HAVE_D3DX
- if (g_d3dx_dll)
- dylib_close(g_d3dx_dll);
- g_d3dx_dll = NULL;
-#endif
- g_d3d_dll = NULL;
-
- dylib_initialized = false;
-#endif
- d3d_common_api = GFX_CTX_NONE;
-}
-
-bool d3d_check_device_type(void *_d3d,
- unsigned idx,
- INT32 disp_format,
- INT32 backbuffer_format,
- bool windowed_mode)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
- if (!d3d)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (FAILED(d3d->CheckDeviceType(
- 0,
- D3DDEVTYPE_HAL,
- (D3DFORMAT)disp_format,
- (D3DFORMAT)backbuffer_format,
- windowed_mode)))
- return false;
-#else
- if (FAILED(IDirect3D9_CheckDeviceType(d3d,
- 0,
- D3DDEVTYPE_HAL,
- (D3DFORMAT)disp_format,
- (D3DFORMAT)backbuffer_format,
- windowed_mode)))
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
- if (!d3d)
- return false;
-#ifdef __cplusplus
- if (FAILED(d3d->CheckDeviceType(
- 0,
- D3DDEVTYPE_HAL,
- (D3DFORMAT)disp_format,
- (D3DFORMAT)backbuffer_format,
- windowed_mode)))
- return false;
-#else
- if (FAILED(IDirect3D8_CheckDeviceType(d3d,
- 0,
- D3DDEVTYPE_HAL,
- disp_format,
- backbuffer_format,
- windowed_mode)))
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- return false;
- }
-
- return true;
-}
-
-bool d3d_get_adapter_display_mode(
- void *_d3d,
- unsigned idx,
- void *display_mode)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
- if (!d3d)
- return false;
-#ifdef _XBOX
- return true;
-#elif defined(__cplusplus) && !defined(CINTERFACE)
- if (FAILED(d3d->GetAdapterDisplayMode(idx, (D3DDISPLAYMODE*)display_mode)))
- return false;
-#else
- if (FAILED(IDirect3D9_GetAdapterDisplayMode(d3d, idx, (D3DDISPLAYMODE*)display_mode)))
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
- if (!d3d)
- return false;
-#ifdef __cplusplus
- if (FAILED(d3d->GetAdapterDisplayMode(idx, (D3DDISPLAYMODE*)display_mode)))
- return false;
-#else
- if (FAILED(IDirect3D8_GetAdapterDisplayMode(d3d, idx, (D3DDISPLAYMODE*)display_mode)))
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- return false;
- }
-
- return true;
-}
-
-bool d3d_swap(void *data, void *_dev)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
-#ifdef _XBOX
- dev->Present(NULL, NULL, NULL, NULL);
-#else
- if (dev->Present(NULL, NULL, NULL, NULL) != D3D_OK)
- return false;
-#endif
-#else
-#ifdef _XBOX
- IDirect3DDevice9_Present(dev, NULL, NULL, NULL, NULL);
-#else
- if (IDirect3DDevice9_Present(dev, NULL, NULL, NULL, NULL)
- == D3DERR_DEVICELOST)
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- if (dev->Present(NULL, NULL, NULL, NULL) != D3D_OK)
- return false;
-#else
- if (IDirect3DDevice8_Present(dev, NULL, NULL, NULL, NULL)
- == D3DERR_DEVICELOST)
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
- return true;
-}
-
-void d3d_set_transform(void *_dev,
- INT32 state, const void *_matrix)
-{
- CONST D3DMATRIX *matrix = (CONST D3DMATRIX*)_matrix;
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
- /* XBox 360 D3D9 does not support fixed-function pipeline. */
-#ifdef HAVE_D3D9
-#ifndef _XBOX
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetTransform((D3DTRANSFORMSTATETYPE)state, matrix);
-#else
- IDirect3DDevice9_SetTransform(dev, (D3DTRANSFORMSTATETYPE)state, matrix);
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- dev->SetTransform((D3DTRANSFORMSTATETYPE)state, matrix);
-#else
- IDirect3DDevice8_SetTransform(dev, (D3DTRANSFORMSTATETYPE)state, matrix);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_texture_get_level_desc(void *_tex,
- unsigned idx, void *_ppsurface_level)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(tex->GetLevelDesc(idx, (D3DSURFACE_DESC*)_ppsurface_level)))
- return true;
-#else
-#if defined(_XBOX)
- D3DTexture_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level);
- return true;
-#else
- if (SUCCEEDED(IDirect3DTexture9_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level)))
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
-#ifdef __cplusplus
- if (SUCCEEDED(tex->GetLevelDesc(idx, (D3DSURFACE_DESC*)_ppsurface_level)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DTexture8_GetLevelDesc(tex, idx, (D3DSURFACE_DESC*)_ppsurface_level)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_texture_get_surface_level(void *_tex,
- unsigned idx, void **_ppsurface_level)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
- if (!tex)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(tex->GetSurfaceLevel(idx, (IDirect3DSurface9**)_ppsurface_level)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DTexture9_GetSurfaceLevel(tex, idx, (IDirect3DSurface9**)_ppsurface_level)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
- if (!tex)
- return false;
-#ifdef __cplusplus
- if (SUCCEEDED(tex->GetSurfaceLevel(idx, (IDirect3DSurface8**)_ppsurface_level)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DTexture8_GetSurfaceLevel(tex, idx, (IDirect3DSurface8**)_ppsurface_level)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-#ifdef HAVE_D3DX
-static void *d3d_texture_new_from_file(
- void *dev,
- const char *path, unsigned width, unsigned height,
- unsigned miplevels, unsigned usage, D3DFORMAT format,
- INT32 pool, unsigned filter, unsigned mipfilter,
- INT32 color_key, void *src_info_data,
- PALETTEENTRY *palette)
-{
- void *buf = NULL;
- HRESULT hr = E_FAIL;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#if defined(HAVE_D3D9)
- hr = D3DCreateTextureFromFile((LPDIRECT3DDEVICE9)dev,
- path, width, height, miplevels, usage, format,
- (D3DPOOL)pool, filter, mipfilter, color_key,
- (D3DXIMAGE_INFO*)src_info_data,
- palette, (struct IDirect3DTexture9**)&buf);
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
-#if defined(HAVE_D3D8)
- hr = D3DCreateTextureFromFile((LPDIRECT3DDEVICE8)dev,
- path, width, height, miplevels, usage, format,
- (D3DPOOL)pool, filter, mipfilter, color_key, src_info_data,
- palette, (struct IDirect3DTeture8**)&buf);
-#endif
- break;
- default:
- break;
- }
-
- if (FAILED(hr))
- return NULL;
-
- return buf;
-}
-#endif
-
-void *d3d_texture_new(void *_dev,
- const char *path, unsigned width, unsigned height,
- unsigned miplevels, unsigned usage, INT32 format,
- INT32 pool, unsigned filter, unsigned mipfilter,
- INT32 color_key, void *src_info_data,
- PALETTEENTRY *palette, bool want_mipmap)
-{
- HRESULT hr = S_OK;
- void *buf = NULL;
-
- if (path)
- {
-#ifdef HAVE_D3DX
- return d3d_texture_new_from_file(_dev,
- path, width, height, miplevels,
- usage, (D3DFORMAT)format,
- (D3DPOOL)pool, filter, mipfilter,
- color_key, src_info_data, palette);
-#else
- return NULL;
-#endif
- }
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#ifndef _XBOX
- if (want_mipmap)
- usage |= D3DUSAGE_AUTOGENMIPMAP;
-#endif
-#if defined(__cplusplus) && !defined(CINTERFACE)
- hr = dev->CreateTexture(
- width, height, miplevels, usage,
- (D3DFORMAT)format,
- (D3DPOOL)pool,
- (struct IDirect3DTexture9**)&buf, NULL);
-#else
- hr = IDirect3DDevice9_CreateTexture(dev,
- width, height, miplevels, usage,
- (D3DFORMAT)format,
- (D3DPOOL)pool,
- (struct IDirect3DTexture9**)&buf, NULL);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- hr = dev->CreateTexture(
- width, height, miplevels, usage,
- (D3DFORMAT)format, (D3DPOOL)pool, (IDirect3DTexture8**)&buf);
-#else
- hr = IDirect3DDevice8_CreateTexture(dev,
- width, height, miplevels, usage,
- (D3DFORMAT)format, (D3DPOOL)pool, (struct IDirect3DTexture8**)&buf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- if (FAILED(hr))
- return NULL;
-
- return buf;
-}
-
-void d3d_texture_free(void *_tex)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
- if (!tex)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- tex->Release();
-#else
- IDirect3DTexture9_Release(tex);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
- if (!tex)
- return;
-#ifdef __cplusplus
- tex->Release();
-#else
- IDirect3DTexture8_Release(tex);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_surface_lock_rect(void *data, void *data2)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
- if (!surf)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (FAILED(surf->LockRect((D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
- return false;
-#else
-#if defined(_XBOX)
- IDirect3DSurface9_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY);
-#else
- if (FAILED(IDirect3DSurface9_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
- if (!surf)
- return false;
-#ifdef __cplusplus
- if (FAILED(surf->LockRect((D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
- return false;
-#else
- if (FAILED(IDirect3DSurface8_LockRect(surf, (D3DLOCKED_RECT*)data2, NULL, D3DLOCK_READONLY)))
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return true;
-}
-
-void d3d_surface_unlock_rect(void *data)
-{
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
- if (!surf)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- surf->UnlockRect();
-#else
- IDirect3DSurface9_UnlockRect(surf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
- if (!surf)
- return;
-#ifdef __cplusplus
- surf->UnlockRect();
-#else
- IDirect3DSurface8_UnlockRect(surf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_surface_free(void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
- if (!surf)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- surf->Release();
-#else
- IDirect3DSurface9_Release(surf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
- if (!surf)
- return;
-#ifdef __cplusplus
- surf->Release();
-#else
- IDirect3DSurface8_Release(surf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_vertex_declaration_free(void *data)
-{
- if (!data)
- return;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
-#if defined(__cplusplus) && !defined(CINTERFACE)
- {
- LPDIRECT3DVERTEXDECLARATION9 vertex_decl =
- (LPDIRECT3DVERTEXDECLARATION9)data;
- if (vertex_decl)
- vertex_decl->Release();
- }
-#else
- IDirect3DVertexDeclaration9_Release((LPDIRECT3DVERTEXDECLARATION9)data);
-#endif
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_vertex_declaration_new(void *_dev,
- const void *vertex_data, void **decl_data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
- {
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- const D3DVERTEXELEMENT9 *vertex_elements = (const D3DVERTEXELEMENT9*)vertex_data;
- LPDIRECT3DVERTEXDECLARATION9 **vertex_decl = (LPDIRECT3DVERTEXDECLARATION9**)decl_data;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(dev->CreateVertexDeclaration(vertex_elements, (IDirect3DVertexDeclaration9**)vertex_decl)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice9_CreateVertexDeclaration(dev, vertex_elements, (IDirect3DVertexDeclaration9**)vertex_decl)))
- return true;
-#endif
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-void *d3d_vertex_buffer_new(void *_dev,
- unsigned length, unsigned usage,
- unsigned fvf, INT32 pool, void *handle)
-{
- HRESULT hr = S_OK;
- void *buf = NULL;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (usage == 0)
- {
-#ifndef _XBOX
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->GetSoftwareVertexProcessing())
- usage = D3DUSAGE_SOFTWAREPROCESSING;
-#else
- if (IDirect3DDevice9_GetSoftwareVertexProcessing(dev))
- usage = D3DUSAGE_SOFTWAREPROCESSING;
-#endif
-#endif
- }
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
- hr = dev->CreateVertexBuffer(length, usage, fvf,
- (D3DPOOL)pool,
- (LPDIRECT3DVERTEXBUFFER9*)&buf, NULL);
-#else
- hr = IDirect3DDevice9_CreateVertexBuffer(dev, length, usage, fvf,
- (D3DPOOL)pool,
- (LPDIRECT3DVERTEXBUFFER9*)&buf, NULL);
-#endif
-
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- hr = dev->CreateVertexBuffer(length, usage, fvf, (D3DPOOL)pool, (IDirect3DVertexBuffer8**)&buf);
-#else
- hr = IDirect3DDevice8_CreateVertexBuffer(dev, length, usage, fvf,
- (D3DPOOL)pool,
- (struct IDirect3DVertexBuffer8**)&buf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- if (FAILED(hr))
- return NULL;
-
- return buf;
-}
-
-void d3d_vertex_buffer_unlock(void *vertbuf_ptr)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DVERTEXBUFFER9 vertbuf = (LPDIRECT3DVERTEXBUFFER9)vertbuf_ptr;
-
- if (!vertbuf)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- vertbuf->Unlock();
-#else
- IDirect3DVertexBuffer9_Unlock(vertbuf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DVERTEXBUFFER8 vertbuf = (LPDIRECT3DVERTEXBUFFER8)vertbuf_ptr;
-
- if (!vertbuf)
- return;
-#ifdef __cplusplus
- vertbuf->Unlock();
-#else
- IDirect3DVertexBuffer8_Unlock(vertbuf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
-}
-
-void *d3d_vertex_buffer_lock(void *vertbuf_ptr)
-{
- void *buf = NULL;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DVERTEXBUFFER9 vertbuf = (LPDIRECT3DVERTEXBUFFER9)vertbuf_ptr;
- if (!vertbuf)
- return NULL;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- vertbuf->Lock(0, 0, &buf, 0);
-#else
- IDirect3DVertexBuffer9_Lock(vertbuf, 0, 0, &buf, 0);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DVERTEXBUFFER8 vertbuf = (LPDIRECT3DVERTEXBUFFER8)vertbuf_ptr;
- if (!vertbuf)
- return NULL;
-#ifdef __cplusplus
- vertbuf->Lock(0, 0, (BYTE**)&buf, 0);
-#else
- IDirect3DVertexBuffer8_Lock(vertbuf, 0, 0, (BYTE**)&buf, 0);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- if (!buf)
- return NULL;
-
- return buf;
-}
-
-void d3d_vertex_buffer_free(void *vertex_data, void *vertex_declaration)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
- if (vertex_data)
- {
- LPDIRECT3DVERTEXBUFFER9 buf = (LPDIRECT3DVERTEXBUFFER9)vertex_data;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- buf->Release();
-#else
- IDirect3DVertexBuffer9_Release(buf);
-#endif
- buf = NULL;
- }
-
- if (vertex_declaration)
- {
- LPDIRECT3DVERTEXDECLARATION9 vertex_decl = (LPDIRECT3DVERTEXDECLARATION9)vertex_declaration;
- d3d_vertex_declaration_free(vertex_decl);
- vertex_decl = NULL;
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
-#ifdef HAVE_D3D8
- if (vertex_data)
- {
- LPDIRECT3DVERTEXBUFFER8 buf = (LPDIRECT3DVERTEXBUFFER8)vertex_data;
-#ifdef __cplusplus
- buf->Release();
-#else
- IDirect3DVertexBuffer8_Release(buf);
-#endif
- buf = NULL;
- }
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_stream_source(void *_dev, unsigned stream_no,
- void *stream_vertbuf_ptr, unsigned offset_bytes,
- unsigned stride)
-{
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- LPDIRECT3DVERTEXBUFFER9 stream_vertbuf = (LPDIRECT3DVERTEXBUFFER9)stream_vertbuf_ptr;
- if (!stream_vertbuf)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetStreamSource(stream_no, stream_vertbuf, offset_bytes, stride);
-#else
- IDirect3DDevice9_SetStreamSource(dev, stream_no, stream_vertbuf,
- offset_bytes,
- stride);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- LPDIRECT3DVERTEXBUFFER8 stream_vertbuf = (LPDIRECT3DVERTEXBUFFER8)stream_vertbuf_ptr;
- if (!stream_vertbuf)
- return;
-#ifdef __cplusplus
- dev->SetStreamSource(stream_no, stream_vertbuf, offset_bytes, stride);
-#else
- IDirect3DDevice8_SetStreamSource(dev, stream_no, stream_vertbuf, stride);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_device_create_offscreen_plain_surface(
- void *_dev,
- unsigned width,
- unsigned height,
- unsigned format,
- unsigned pool,
- void **surf_data,
- void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifndef _XBOX
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(dev->CreateOffscreenPlainSurface(width, height,
- (D3DFORMAT)format, (D3DPOOL)pool,
- (LPDIRECT3DSURFACE9*)surf_data,
- (HANDLE*)data)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice9_CreateOffscreenPlainSurface(dev,
- width, height,
- (D3DFORMAT)format, (D3DPOOL)pool,
- (LPDIRECT3DSURFACE9*)surf_data,
- (HANDLE*)data)))
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-static void d3d_set_texture_stage_state(void *_dev,
- unsigned sampler, unsigned type, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
- /* XBox 360 has no fixed-function pipeline. */
-#ifndef _XBOX
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->SetTextureStageState(sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
- RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
-#else
- if (IDirect3DDevice9_SetTextureStageState(dev, sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
- RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- if (dev->SetTextureStageState(sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
- RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
-#else
- if (IDirect3DDevice8_SetTextureStageState(dev, sampler, (D3DTEXTURESTAGESTATETYPE)type, value) != D3D_OK)
- RARCH_ERR("SetTextureStageState call failed, sampler: %d, value: %d, type: %d\n", sampler, value, type);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_sampler_address_u(void *_dev,
- unsigned sampler, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetSamplerState(sampler, D3DSAMP_ADDRESSU, value);
-#else
- IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_ADDRESSU, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- d3d_set_texture_stage_state(dev, sampler, D3DTSS_ADDRESSU, value);
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_sampler_address_v(void *_dev,
- unsigned sampler, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetSamplerState(sampler, D3DSAMP_ADDRESSV, value);
-#else
- IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_ADDRESSV, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- d3d_set_texture_stage_state(dev, sampler, D3DTSS_ADDRESSV, value);
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_sampler_minfilter(void *_dev,
- unsigned sampler, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetSamplerState(sampler, D3DSAMP_MINFILTER, value);
-#else
- IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_MINFILTER, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
-#ifdef HAVE_D3D8
- d3d_set_texture_stage_state(_dev, sampler, D3DTSS_MINFILTER, value);
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_sampler_magfilter(void *_dev,
- unsigned sampler, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetSamplerState(sampler, D3DSAMP_MAGFILTER, value);
-#else
- IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_MAGFILTER, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
-#ifdef HAVE_D3D8
- d3d_set_texture_stage_state(_dev, sampler, D3DTSS_MAGFILTER, value);
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_sampler_mipfilter(void *_dev,
- unsigned sampler, unsigned value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
- IDirect3DDevice9_SetSamplerState(dev, sampler,
- D3DSAMP_MIPFILTER, value);
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_begin_scene(void *_dev)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (FAILED(dev->BeginScene()))
- return false;
-#else
-#if defined(_XBOX)
- IDirect3DDevice9_BeginScene(dev);
-#else
- if (FAILED(IDirect3DDevice9_BeginScene(dev)))
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return false;
-#ifdef __cplusplus
-#ifdef _XBOX
- dev->BeginScene();
-#else
- if (FAILED(dev->BeginScene()))
- return false;
-#endif
-#else
-#ifdef _XBOX
- IDirect3DDevice8_BeginScene(dev);
-#else
- if (FAILED(IDirect3DDevice8_BeginScene(dev)))
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return true;
-}
-
-void d3d_end_scene(void *_dev)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->EndScene();
-#else
- IDirect3DDevice9_EndScene(dev);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->EndScene();
-#else
- IDirect3DDevice8_EndScene(dev);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-static void d3d_draw_primitive_internal(void *_dev,
- D3DPRIMITIVETYPE type, unsigned start, unsigned count)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->DrawPrimitive(type, start, count);
-#else
- IDirect3DDevice9_DrawPrimitive(dev, type, start, count);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->DrawPrimitive(type, start, count);
-#else
- IDirect3DDevice8_DrawPrimitive(dev, type, start, count);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_draw_primitive(void *dev,
- INT32 type, unsigned start, unsigned count)
-{
- if (!d3d_begin_scene(dev))
- return;
-
- d3d_draw_primitive_internal(dev, (D3DPRIMITIVETYPE)type, start, count);
- d3d_end_scene(dev);
-}
-
-void d3d_clear(void *_dev,
- unsigned count, const void *rects, unsigned flags,
- INT32 color, float z, unsigned stencil)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->Clear(count, (const D3DRECT*)rects, flags, color, z, stencil);
-#else
- IDirect3DDevice9_Clear(dev, count, (const D3DRECT*)rects, flags,
- color, z, stencil);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->Clear(count, (const D3DRECT*)rects, flags, color, z, stencil);
-#else
- IDirect3DDevice8_Clear(dev, count, (const D3DRECT*)rects, flags,
- color, z, stencil);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_device_get_render_target_data(void *_dev,
- void *_src, void *_dst)
-{
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifndef _XBOX
-#ifdef HAVE_D3D9
- LPDIRECT3DSURFACE9 src = (LPDIRECT3DSURFACE9)_src;
- LPDIRECT3DSURFACE9 dst = (LPDIRECT3DSURFACE9)_dst;
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(dev->GetRenderTargetData(src, dst)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice9_GetRenderTargetData(
- dev, src, dst)))
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_device_get_render_target(void *_dev,
- unsigned idx, void **data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(dev->GetRenderTarget(idx,
- (LPDIRECT3DSURFACE9*)data)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice9_GetRenderTarget(dev,
- idx, (LPDIRECT3DSURFACE9*)data)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return false;
-#ifdef __cplusplus
- if (SUCCEEDED(dev->GetRenderTarget(
- (LPDIRECT3DSURFACE8*)data)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice8_GetRenderTarget(dev,
- (LPDIRECT3DSURFACE8*)data)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-
-bool d3d_lock_rectangle(void *_tex,
- unsigned level, void *_lr, RECT *rect,
- unsigned rectangle_height, unsigned flags)
-{
- D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
- if (!tex)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (FAILED(tex->LockRect(level, lr, rect, flags)))
- return false;
-#else
-#ifdef _XBOX
- IDirect3DTexture9_LockRect(tex, level, lr, (const RECT*)rect, flags);
-#else
- if (IDirect3DTexture9_LockRect(tex, level, lr, (const RECT*)rect, flags) != D3D_OK)
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
- if (!tex)
- return false;
-#ifdef __cplusplus
- if (FAILED(tex->LockRect(level, lr, rect, flags)))
- return false;
-#else
- if (IDirect3DTexture8_LockRect(tex, level, lr, rect, flags) != D3D_OK)
- return false;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return true;
-}
-
-void d3d_unlock_rectangle(void *_tex)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)_tex;
- if (!tex)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- tex->UnlockRect(0);
-#else
- IDirect3DTexture9_UnlockRect(tex, 0);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)_tex;
- if (!tex)
- return;
-#ifdef __cplusplus
- tex->UnlockRect(0);
-#else
- IDirect3DTexture8_UnlockRect(tex, 0);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_lock_rectangle_clear(void *tex,
- unsigned level, void *_lr, RECT *rect,
- unsigned rectangle_height, unsigned flags)
-{
- D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
-#if defined(_XBOX)
- level = 0;
-#endif
- memset(lr->pBits, level, rectangle_height * lr->Pitch);
- d3d_unlock_rectangle(tex);
-}
-
-void d3d_set_viewports(void *_dev, void *_vp)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- D3DVIEWPORT9 *vp = (D3DVIEWPORT9*)_vp;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetViewport(vp);
-#else
- IDirect3DDevice9_SetViewport(dev, vp);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- D3DVIEWPORT8 *vp = (D3DVIEWPORT8*)_vp;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->SetViewport(vp);
-#else
- IDirect3DDevice8_SetViewport(dev, vp);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_set_texture(void *_dev, unsigned sampler,
- void *tex_data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DTEXTURE9 tex = (LPDIRECT3DTEXTURE9)tex_data;
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev || !tex)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetTexture(sampler, tex);
-#else
- IDirect3DDevice9_SetTexture(dev, sampler,
- (IDirect3DBaseTexture9*)tex);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)tex_data;
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev || !tex)
- return;
-#ifdef __cplusplus
- dev->SetTexture(sampler, tex);
-#else
- IDirect3DDevice8_SetTexture(dev, sampler,
- (IDirect3DBaseTexture8*)tex);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_free_vertex_shader(void *_dev, void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
- {
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- IDirect3DVertexShader9 *vs = (IDirect3DVertexShader9*)data;
- if (!dev || !vs)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- vs->Release();
-#else
- IDirect3DVertexShader9_Release(vs);
-#endif
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_free_pixel_shader(void *_dev, void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
- {
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- IDirect3DPixelShader9 *ps = (IDirect3DPixelShader9*)data;
- if (!dev || !ps)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- ps->Release();
-#else
- IDirect3DPixelShader9_Release(ps);
-#endif
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3d_create_vertex_shader(void *_dev, const DWORD *a, void **b)
-{
- if (!_dev)
- return false;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->CreateVertexShader(a, (IDirect3DVertexShader9**)b) == D3D_OK)
- return true;
-#else
- if (IDirect3DDevice9_CreateVertexShader(dev, a,
- (LPDIRECT3DVERTEXSHADER9*)b) == D3D_OK)
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_create_pixel_shader(void *_dev, const DWORD *a, void **b)
-{
- if (!_dev)
- return false;
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->CreatePixelShader(a, (IDirect3DPixelShader9**)b) == D3D_OK)
- return true;
-#else
- if (IDirect3DDevice9_CreatePixelShader(dev, a,
- (LPDIRECT3DPIXELSHADER9*)b) == D3D_OK)
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_set_pixel_shader(void *_dev, void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#ifdef HAVE_D3D9
- {
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- LPDIRECT3DPIXELSHADER9 d3dps = (LPDIRECT3DPIXELSHADER9)data;
- if (!dev || !d3dps)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->SetPixelShader(d3dps) == D3D_OK)
- return true;
-#else
-#ifdef _XBOX
- /* Returns void on Xbox */
- IDirect3DDevice9_SetPixelShader(dev, d3dps);
- return true;
-#else
- if (IDirect3DDevice9_SetPixelShader(dev, d3dps) == D3D_OK)
- return true;
-#endif
-#endif
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_set_vertex_shader(void *_dev, unsigned index,
- void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- LPDIRECT3DVERTEXSHADER9 shader = (LPDIRECT3DVERTEXSHADER9)data;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev->SetVertexShader(shader) != D3D_OK)
- return false;
-#else
-#ifdef _XBOX
- IDirect3DDevice9_SetVertexShader(dev, shader);
-#else
- if (IDirect3DDevice9_SetVertexShader(dev, shader) != D3D_OK)
- return false;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
-#ifdef HAVE_D3D8
- {
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
-#ifdef __cplusplus
- LPDIRECT3DVERTEXSHADER8 shader = (LPDIRECT3DVERTEXSHADER8)data;
-
- if (dev->SetVertexShader(shader) != D3D_OK)
- return false;
-#else
- if (IDirect3DDevice8_SetVertexShader(dev, index) != D3D_OK)
- return false;
-#endif
- }
-#endif
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return true;
-}
-
-bool d3d_set_vertex_shader_constantf(void *_dev,
- UINT start_register,const float* constant_data,
- unsigned vector4f_count)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#if defined(HAVE_D3D9)
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#if defined(__cplusplus) && !defined(CINTERFACE)
-#ifdef _XBOX
- dev->SetVertexShaderConstantF(
- start_register, constant_data, vector4f_count);
-#else
- if (dev->SetVertexShaderConstantF(
- start_register, constant_data, vector4f_count) == D3D_OK)
- return true;
-#endif
-#else
-#ifdef _XBOX
- IDirect3DDevice9_SetVertexShaderConstantF(dev,
- start_register, constant_data, vector4f_count);
- return true;
-#else
- if (IDirect3DDevice9_SetVertexShaderConstantF(dev,
- start_register, constant_data, vector4f_count) == D3D_OK)
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-void d3d_texture_blit(unsigned pixel_size,
- void *tex,
- void *_lr, const void *frame,
- unsigned width, unsigned height, unsigned pitch)
-{
- unsigned y;
- D3DLOCKED_RECT *lr = (D3DLOCKED_RECT*)_lr;
-
- for (y = 0; y < height; y++)
- {
- const uint8_t *in = (const uint8_t*)frame + y * pitch;
- uint8_t *out = (uint8_t*)lr->pBits + y * lr->Pitch;
- memcpy(out, in, width * pixel_size);
- }
-}
-
-bool d3d_get_render_state(void *data, INT32 state, DWORD *value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (dev && dev->GetRenderState((D3DRENDERSTATETYPE)state, value) == D3D_OK)
- return true;
-#else
-#ifdef _XBOX
- if (!dev)
- return false;
- IDirect3DDevice9_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
- return true;
-#else
- if (dev && IDirect3DDevice9_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value) == D3D_OK)
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
-#ifdef __cplusplus
- if (dev && dev->GetRenderState((D3DRENDERSTATETYPE)state, value) == D3D_OK)
- return true;
-#else
- if (dev && IDirect3DDevice8_GetRenderState(dev, (D3DRENDERSTATETYPE)state, value) == D3D_OK)
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-void d3d_set_render_state(void *data, INT32 state, DWORD value)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetRenderState((D3DRENDERSTATETYPE)state, value);
-#else
- IDirect3DDevice9_SetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->SetRenderState((D3DRENDERSTATETYPE)state, value);
-#else
- IDirect3DDevice8_SetRenderState(dev, (D3DRENDERSTATETYPE)state, value);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_enable_blend_func(void *data)
-{
- if (!data)
- return;
-
- d3d_set_render_state(data, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
- d3d_set_render_state(data, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
- d3d_set_render_state(data, D3DRS_ALPHABLENDENABLE, true);
-}
-
-void d3d_device_set_render_target(void *_dev, unsigned idx,
- void *data)
-{
-
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DSURFACE9 surf = (LPDIRECT3DSURFACE9)data;
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetRenderTarget(idx, surf);
-#else
- IDirect3DDevice9_SetRenderTarget(dev, idx, surf);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DSURFACE8 surf = (LPDIRECT3DSURFACE8)data;
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return;
-#ifdef __cplusplus
- dev->SetRenderTarget(idx, surf);
-#else
- IDirect3DDevice8_SetRenderTarget(dev, surf, NULL);
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_enable_alpha_blend_texture_func(void *data)
-{
- /* Also blend the texture with the set alpha value. */
- d3d_set_texture_stage_state(data, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
- d3d_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
- d3d_set_texture_stage_state(data, 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
-}
-
-void d3d_frame_postprocess(void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D8_API:
-#ifdef HAVE_D3D8
- {
-#if defined(_XBOX)
- global_t *global = global_get_ptr();
-
-#ifdef __cplusplus
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
- if (!dev)
- return;
-
- dev->SetFlickerFilter(global->console.screen.flicker_filter_index);
- dev->SetSoftDisplayFilter(global->console.softfilter_enable);
-#else
- D3DDevice_SetFlickerFilter(global->console.screen.flicker_filter_index);
- D3DDevice_SetSoftDisplayFilter(global->console.softfilter_enable);
-#endif
-#endif
- }
-#endif
- break;
- case GFX_CTX_DIRECT3D9_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-void d3d_disable_blend_func(void *data)
-{
- d3d_set_render_state(data, D3DRS_ALPHABLENDENABLE, false);
-}
-
-void d3d_set_vertex_declaration(void *data, void *vertex_data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#if defined(HAVE_D3D9)
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
- if (!dev)
- return;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->SetVertexDeclaration((LPDIRECT3DVERTEXDECLARATION9)vertex_data);
-#else
- IDirect3DDevice9_SetVertexDeclaration(dev, (LPDIRECT3DVERTEXDECLARATION9)vertex_data);
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-static bool d3d_reset_internal(void *data,
- D3DPRESENT_PARAMETERS *d3dpp
- )
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if ((dev->Reset(d3dpp) == D3D_OK))
- return true;
-#else
- if (IDirect3DDevice9_Reset(dev, d3dpp) == D3D_OK)
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
- if (!dev)
- return false;
-#ifdef __cplusplus
- if ((dev->Reset(d3dpp) == D3D_OK))
- return true;
-#else
- if (IDirect3DDevice8_Reset(dev, d3dpp) == D3D_OK)
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-static HRESULT d3d_test_cooperative_level(void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifndef _XBOX
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
- if (!dev)
- return E_FAIL;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- return dev->TestCooperativeLevel();
-#else
- return IDirect3DDevice9_TestCooperativeLevel(dev);
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifndef _XBOX
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
- if (!dev)
- return E_FAIL;
-#ifdef __cplusplus
- return dev->TestCooperativeLevel();
-#else
- return IDirect3DDevice8_TestCooperativeLevel(dev);
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return E_FAIL;
-}
-
-static bool d3d_create_device_internal(
- void *data,
- D3DPRESENT_PARAMETERS *d3dpp,
- void *_d3d,
- HWND focus_window,
- unsigned cur_mon_id,
- DWORD behavior_flags)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3D9 d3d = (LPDIRECT3D9)_d3d;
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(d3d->CreateDevice(
- cur_mon_id,
- D3DDEVTYPE_HAL,
- focus_window,
- behavior_flags,
- d3dpp,
- (IDirect3DDevice9**)dev)))
- return true;
-#else
- if (SUCCEEDED(IDirect3D9_CreateDevice(d3d,
- cur_mon_id,
- D3DDEVTYPE_HAL,
- focus_window,
- behavior_flags,
- d3dpp,
- (IDirect3DDevice9**)dev)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3D8 d3d = (LPDIRECT3D8)_d3d;
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)data;
- if (!dev)
- return false;
-#ifdef __cplusplus
- if (SUCCEEDED(d3d->CreateDevice(
- cur_mon_id,
- D3DDEVTYPE_HAL,
- focus_window,
- behavior_flags,
- d3dpp,
- (IDirect3DDevice8**)dev)))
- return true;
-#else
- if (SUCCEEDED(IDirect3D8_CreateDevice(d3d,
- cur_mon_id,
- D3DDEVTYPE_HAL,
- focus_window,
- behavior_flags,
- d3dpp,
- (IDirect3DDevice8**)dev)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-bool d3d_create_device(void *dev,
- void *d3dpp,
- void *d3d,
- HWND focus_window,
- unsigned cur_mon_id)
-{
- if (!d3d_create_device_internal(dev,
- (D3DPRESENT_PARAMETERS*)d3dpp,
- d3d,
- focus_window,
- cur_mon_id,
- D3DCREATE_HARDWARE_VERTEXPROCESSING))
- if (!d3d_create_device_internal(
- dev,
- (D3DPRESENT_PARAMETERS*)d3dpp, d3d, focus_window,
- cur_mon_id,
- D3DCREATE_SOFTWARE_VERTEXPROCESSING))
- return false;
- return true;
-}
-
-bool d3d_reset(void *dev, void *d3dpp)
-{
- const char *err = NULL;
-
- if (d3d_reset_internal(dev, (D3DPRESENT_PARAMETERS*)d3dpp))
- return true;
-
- RARCH_WARN("[D3D]: Attempting to recover from dead state...\n");
-
-#ifndef _XBOX
- /* Try to recreate the device completely. */
- switch (d3d_test_cooperative_level(dev))
- {
- case D3DERR_DEVICELOST:
- err = "DEVICELOST";
- break;
-
- case D3DERR_DEVICENOTRESET:
- err = "DEVICENOTRESET";
- break;
-
- case D3DERR_DRIVERINTERNALERROR:
- err = "DRIVERINTERNALERROR";
- break;
-
- default:
- err = "Unknown";
- }
- RARCH_WARN("[D3D]: recovering from dead state: (%s).\n", err);
-#endif
-
- return false;
-}
-
-bool d3d_device_get_backbuffer(void *_dev,
- unsigned idx, unsigned swapchain_idx,
- unsigned backbuffer_type, void **data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (!dev)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (SUCCEEDED(dev->GetBackBuffer(
- swapchain_idx, idx,
- (D3DBACKBUFFER_TYPE)backbuffer_type,
- (LPDIRECT3DSURFACE9*)data)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice9_GetBackBuffer(dev,
- swapchain_idx, idx,
- (D3DBACKBUFFER_TYPE)backbuffer_type,
- (LPDIRECT3DSURFACE9*)data)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (!dev)
- return false;
-#ifdef __cplusplus
- if (SUCCEEDED(dev->GetBackBuffer(idx,
- (D3DBACKBUFFER_TYPE)backbuffer_type,
- (LPDIRECT3DSURFACE8*)data)))
- return true;
-#else
- if (SUCCEEDED(IDirect3DDevice8_GetBackBuffer(dev, idx,
- (D3DBACKBUFFER_TYPE)backbuffer_type,
- (LPDIRECT3DSURFACE8*)data)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-
-void d3d_device_free(void *_dev, void *_pd3d)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
- LPDIRECT3D9 pd3d = (LPDIRECT3D9)_pd3d;
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
- if (dev)
- {
-#if defined(__cplusplus) && !defined(CINTERFACE)
- dev->Release();
-#else
- IDirect3DDevice9_Release(dev);
-#endif
- }
-
- if (pd3d)
- {
-#if defined(__cplusplus) && !defined(CINTERFACE)
- pd3d->Release();
-#else
- IDirect3D9_Release(pd3d);
-#endif
- }
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3D8
- LPDIRECT3D8 pd3d = (LPDIRECT3D8)_pd3d;
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (dev)
- {
-#ifdef __cplusplus
- dev->Release();
-#else
- IDirect3DDevice8_Release(dev);
-#endif
- }
-
- if (pd3d)
- {
-#if defined(__cplusplus)
- pd3d->Release();
-#else
- IDirect3D8_Release(pd3d);
-#endif
- }
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
-}
-
-INT32 d3d_translate_filter(unsigned type)
-{
- switch (type)
- {
- case RARCH_FILTER_UNSPEC:
- {
- settings_t *settings = config_get_ptr();
- if (!settings->bools.video_smooth)
- break;
- }
- /* fall-through */
- case RARCH_FILTER_LINEAR:
- return D3DTEXF_LINEAR;
- case RARCH_FILTER_NEAREST:
- break;
- }
-
- return D3DTEXF_POINT;
-}
-
-
void *d3d_matrix_transpose(void *_pout, const void *_pm)
{
unsigned i,j;
@@ -2794,7 +114,8 @@ void *d3d_matrix_multiply(void *_pout, const void *_pm1, const void *_pm2)
for (i=0; i<4; i++)
{
for (j=0; j<4; j++)
- pout->m[i][j] = pm1->m[i][0] * pm2->m[0][j] + pm1->m[i][1] * pm2->m[1][j] + pm1->m[i][2] * pm2->m[2][j] + pm1->m[i][3] * pm2->m[3][j];
+ pout->m[i][j] = pm1->m[i][0] * pm2->m[0][j] + pm1->m[i][1] * pm2->m[1][j] +
+ pm1->m[i][2] * pm2->m[2][j] + pm1->m[i][3] * pm2->m[3][j];
}
return pout;
}
@@ -2809,277 +130,3 @@ void *d3d_matrix_rotation_z(void *_pout, float angle)
pout->m[1][0] = -sin(angle);
return pout;
}
-
-bool d3dx_create_font_indirect(void *_dev,
- void *desc, void **font_data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3DX
-#ifdef HAVE_D3D9
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)_dev;
-#ifdef __cplusplus
- if (SUCCEEDED(D3DCreateFontIndirect(
- dev, (D3DXFONT_DESC*)desc,
- (struct ID3DXFont**)font_data)))
- return true;
-#else
- if (SUCCEEDED(D3DCreateFontIndirect(
- dev, (D3DXFONT_DESC*)desc,
- (struct ID3DXFont**)font_data)))
- return true;
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- {
-#ifdef HAVE_D3DX
-#ifdef HAVE_D3D8
- LPDIRECT3DDEVICE8 dev = (LPDIRECT3DDEVICE8)_dev;
- if (SUCCEEDED(D3DCreateFontIndirect(
- dev, (CONST LOGFONT*)desc,
- (struct ID3DXFont**)font_data)))
- return true;
-#endif
-#endif
- }
- break;
- case GFX_CTX_NONE:
- default:
- break;
- }
-
- return false;
-}
-
-void d3dxbuffer_release(void *data)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
- {
-#ifdef HAVE_D3D9
-#ifdef HAVE_D3DX
-#ifdef __cplusplus
- ID3DXBuffer *p = (ID3DXBuffer*)data;
-#else
- LPD3DXBUFFER p = (LPD3DXBUFFER)data;
-#endif
- if (!p)
- return;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
- p->Release();
-#else
- p->lpVtbl->Release(p);
-#endif
-#endif
-#endif
- }
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
-}
-
-bool d3dx_compile_shader(
- const char *src,
- unsigned src_data_len,
- const void *pdefines,
- void *pinclude,
- const char *pfunctionname,
- const char *pprofile,
- unsigned flags,
- void *ppshader,
- void *pperrormsgs,
- void *ppconstanttable)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#if defined(HAVE_D3DX) && defined(HAVE_D3D9)
- if (D3DCompileShader)
- if (D3DCompileShader(
- (LPCTSTR)src,
- (UINT)src_data_len,
- (const D3DXMACRO*)pdefines,
- (LPD3DXINCLUDE)pinclude,
- (LPCSTR)pfunctionname,
- (LPCSTR)pprofile,
- (DWORD)flags,
- (LPD3DXBUFFER*)ppshader,
- (LPD3DXBUFFER*)pperrormsgs,
- (LPD3DXCONSTANTTABLE*)ppconstanttable) >= 0)
- return true;
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
- return false;
-}
-
-void d3dx_font_draw_text(void *data, void *sprite_data, void *string_data,
- unsigned count, void *rect_data, unsigned format, unsigned color)
-{
-#ifdef HAVE_D3DX
-#if !defined(__cplusplus) || defined(CINTERFACE)
- ID3DXFont *font = (ID3DXFont*)data;
- if (!font)
- return;
- font->lpVtbl->DrawText(font, (LPD3DXSPRITE)sprite_data,
- (LPCTSTR)string_data, count, (LPRECT)rect_data,
- (DWORD)format, (D3DCOLOR)color);
-#else
- LPD3DXFONT font = (LPD3DXFONT)data;
- if (!font)
- return;
- font->DrawText((LPD3DXSPRITE)sprite_data,
- (LPCTSTR)string_data, count, (LPRECT)rect_data,
- (DWORD)format, (D3DCOLOR)color);
-#endif
-#endif
-}
-
-void d3dx_font_release(void *data)
-{
-#ifdef HAVE_D3DX
-#if !defined(__cplusplus) || defined(CINTERFACE)
- ID3DXFont *font = (ID3DXFont*)data;
- if (!font)
- return;
- font->lpVtbl->Release(font);
-#else
- LPD3DXFONT font = (LPD3DXFONT)data;
- if (!font)
- return;
- font->Release();
-#endif
-#endif
-}
-
-void d3dx_font_get_text_metrics(void *data, void *metrics)
-{
-#ifdef HAVE_D3DX
-#if !defined(__cplusplus) || defined(CINTERFACE)
- ID3DXFont *font = (ID3DXFont*)data;
- if (!font)
- return;
- font->lpVtbl->GetTextMetrics(font, (TEXTMETRICA*)metrics);
-#else
- LPD3DXFONT font = (LPD3DXFONT)data;
- if (!font)
- return;
- font->GetTextMetricsA((TEXTMETRICA*)metrics);
-#endif
-#endif
-}
-
-bool d3dx_compile_shader_from_file(
- const char *src,
- const void *pdefines,
- void *pinclude,
- const char *pfunctionname,
- const char *pprofile,
- unsigned flags,
- void *ppshader,
- void *pperrormsgs,
- void *ppconstanttable)
-{
- switch (d3d_common_api)
- {
- case GFX_CTX_DIRECT3D9_API:
-#if defined(HAVE_D3DX) && defined(HAVE_D3D9)
- if (D3DCompileShaderFromFile)
- if (D3DCompileShaderFromFile(
- (LPCTSTR)src,
- (const D3DXMACRO*)pdefines,
- (LPD3DXINCLUDE)pinclude,
- (LPCSTR)pfunctionname,
- (LPCSTR)pprofile,
- (DWORD)flags,
- (LPD3DXBUFFER*)ppshader,
- (LPD3DXBUFFER*)pperrormsgs,
- (LPD3DXCONSTANTTABLE*)ppconstanttable) >= 0)
- return true;
-#endif
- break;
- case GFX_CTX_DIRECT3D8_API:
- case GFX_CTX_NONE:
- default:
- break;
- }
- return false;
-}
-
-INT32 d3d_get_rgb565_format(void)
-{
-#ifdef _XBOX
- return D3DFMT_LIN_R5G6B5;
-#else
- return D3DFMT_R5G6B5;
-#endif
-}
-
-INT32 d3d_get_argb8888_format(void)
-{
-#ifdef _XBOX
- return D3DFMT_LIN_A8R8G8B8;
-#else
- return D3DFMT_A8R8G8B8;
-#endif
-}
-
-INT32 d3d_get_xrgb8888_format(void)
-{
-#ifdef _XBOX
- return D3DFMT_LIN_X8R8G8B8;
-#else
- return D3DFMT_X8R8G8B8;
-#endif
-}
-
-const void *d3dx_get_buffer_ptr(void *data)
-{
-#if defined(HAVE_D3DX) && defined(HAVE_D3D9)
- ID3DXBuffer *listing = (ID3DXBuffer*)data;
- if (!listing)
- return NULL;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- return listing->GetBufferPointer();
-#else
- return listing->lpVtbl->GetBufferPointer(listing);
-#endif
-#else
- return NULL;
-#endif
-}
-
-const bool d3dx_constant_table_set_float(void *p,
- void *a,
- const void *b, float val)
-{
-#if defined(HAVE_D3DX) && defined(HAVE_D3D9)
- LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)a;
- D3DXHANDLE handle = (D3DXHANDLE)b;
- LPD3DXCONSTANTTABLE consttbl = (LPD3DXCONSTANTTABLE)p;
- if (!consttbl || !dev || !handle)
- return false;
-#if defined(__cplusplus) && !defined(CINTERFACE)
- if (consttbl->SetFloat(dev, handle, val) == D3D_OK)
- return true;
-#else
- if (consttbl->lpVtbl->SetFloat(consttbl, dev, handle, val) == D3D_OK)
- return true;
-#endif
-#endif
- return false;
-}
diff --git a/gfx/common/d3d_common.h b/gfx/common/d3d_common.h
index 173f26be77..083cfd7fa1 100644
--- a/gfx/common/d3d_common.h
+++ b/gfx/common/d3d_common.h
@@ -29,6 +29,10 @@ typedef struct d3d_texture
INT32 pool;
} d3d_texture_t;
+#ifndef BYTE_CLAMP
+#define BYTE_CLAMP(i) (int) ((((i) > 255) ? 255 : (((i) < 0) ? 0 : (i))))
+#endif
+
#ifndef D3DCOLOR_ARGB
#define D3DCOLOR_ARGB(_a, _r, _g, _b) ( (DWORD)( ( ( (_a)&0xff)<<24)|( ( (_r)&0xff)<<16)|( ( (_g)&0xff)<<8)|( (_b)&0xff) ) )
#endif
diff --git a/gfx/drivers/d3d.h b/gfx/drivers/d3d.h
index f2225096e9..d914729a54 100644
--- a/gfx/drivers/d3d.h
+++ b/gfx/drivers/d3d.h
@@ -108,7 +108,5 @@ typedef struct d3d_video
overlay_t *overlays;
} d3d_video_t;
-void d3d_make_d3dpp(void *data, const video_info_t *info, void *_d3dpp);
-
#endif
diff --git a/gfx/drivers/d3d8.c b/gfx/drivers/d3d8.c
index a66c92bde8..31a24a1887 100644
--- a/gfx/drivers/d3d8.c
+++ b/gfx/drivers/d3d8.c
@@ -31,6 +31,7 @@
#include "d3d.h"
#include "../../defines/d3d_defines.h"
+#include "../common/d3d8_common.h"
#include "../common/d3d_common.h"
#include "../video_coord_array.h"
#include "../../configuration.h"
@@ -93,13 +94,13 @@ static void d3d8_renderchain_set_mvp(
d3d_matrix_identity(&matrix);
- d3d_set_transform(d3d->dev, D3DTS_PROJECTION, &matrix);
- d3d_set_transform(d3d->dev, D3DTS_VIEW, &matrix);
+ d3d8_set_transform(d3d->dev, D3DTS_PROJECTION, &matrix);
+ d3d8_set_transform(d3d->dev, D3DTS_VIEW, &matrix);
if (mat_data)
d3d_matrix_transpose(&matrix, mat_data);
- d3d_set_transform(d3d->dev, D3DTS_WORLD, &matrix);
+ d3d8_set_transform(d3d->dev, D3DTS_WORLD, &matrix);
}
static bool d3d8_renderchain_create_first_pass(void *data,
@@ -109,7 +110,7 @@ static bool d3d8_renderchain_create_first_pass(void *data,
LPDIRECT3DDEVICE8 d3dr = (LPDIRECT3DDEVICE8)d3d->dev;
d3d8_renderchain_t *chain = (d3d8_renderchain_t*)d3d->renderchain_data;
- chain->vertex_buf = (LPDIRECT3DVERTEXBUFFER8)d3d_vertex_buffer_new(d3dr, 4 * sizeof(Vertex),
+ chain->vertex_buf = (LPDIRECT3DVERTEXBUFFER8)d3d8_vertex_buffer_new(d3dr, 4 * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
D3DPOOL_MANAGED,
@@ -118,22 +119,22 @@ static bool d3d8_renderchain_create_first_pass(void *data,
if (!chain->vertex_buf)
return false;
- chain->tex = (LPDIRECT3DTEXTURE8)d3d_texture_new(d3dr, NULL,
+ chain->tex = (LPDIRECT3DTEXTURE8)d3d8_texture_new(d3dr, NULL,
chain->tex_w, chain->tex_h, 1, 0,
info->rgb32
?
- d3d_get_xrgb8888_format() : d3d_get_rgb565_format(),
+ d3d8_get_xrgb8888_format() : d3d8_get_rgb565_format(),
D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL,
false);
if (!chain->tex)
return false;
- d3d_set_sampler_address_u(d3dr, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(d3dr, 0, D3DTADDRESS_BORDER);
- d3d_set_render_state(d3dr, D3DRS_LIGHTING, 0);
- d3d_set_render_state(d3dr, D3DRS_CULLMODE, D3DCULL_NONE);
- d3d_set_render_state(d3dr, D3DRS_ZENABLE, FALSE);
+ d3d8_set_sampler_address_u(d3dr, 0, D3DTADDRESS_BORDER);
+ d3d8_set_sampler_address_v(d3dr, 0, D3DTADDRESS_BORDER);
+ d3d8_set_render_state(d3dr, D3DRS_LIGHTING, 0);
+ d3d8_set_render_state(d3dr, D3DRS_CULLMODE, D3DCULL_NONE);
+ d3d8_set_render_state(d3dr, D3DRS_ZENABLE, FALSE);
return true;
}
@@ -199,9 +200,9 @@ static void d3d8_renderchain_set_vertices(void *data, unsigned pass,
vert[2].color = 0xFFFFFFFF;
vert[3].color = 0xFFFFFFFF;
- verts = d3d_vertex_buffer_lock(chain->vertex_buf);
+ verts = d3d8_vertex_buffer_lock(chain->vertex_buf);
memcpy(verts, vert, sizeof(vert));
- d3d_vertex_buffer_unlock(chain->vertex_buf);
+ d3d8_vertex_buffer_unlock(chain->vertex_buf);
}
}
@@ -212,24 +213,24 @@ static void d3d8_renderchain_blit_to_texture(void *data, const void *frame,
d3d8_renderchain_t *chain = (d3d8_renderchain_t*)data;
LPDIRECT3DDEVICE8 d3dr = (LPDIRECT3DDEVICE8)chain->dev;
- d3d_frame_postprocess(chain);
+ d3d8_frame_postprocess(chain);
if (chain->last_width != width || chain->last_height != height)
{
- d3d_lock_rectangle(chain->tex,
+ d3d8_lock_rectangle(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
- d3d_lock_rectangle_clear(chain->tex,
+ d3d8_lock_rectangle_clear(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
}
/* Set the texture to NULL so D3D doesn't complain about it being in use... */
- d3d_set_texture(d3dr, 0, NULL);
+ d3d8_set_texture(d3dr, 0, NULL);
- if (d3d_lock_rectangle(chain->tex, 0, &d3dlr, NULL, 0, 0))
+ if (d3d8_lock_rectangle(chain->tex, 0, &d3dlr, NULL, 0, 0))
{
- d3d_texture_blit(chain->pixel_size, chain->tex,
+ d3d8_texture_blit(chain->pixel_size, chain->tex,
&d3dlr, frame, width, height, pitch);
- d3d_unlock_rectangle(chain->tex);
+ d3d8_unlock_rectangle(chain->tex);
}
}
@@ -241,8 +242,8 @@ static void d3d8_renderchain_free(void *data)
return;
if (chain->tex)
- d3d_texture_free(chain->tex);
- d3d_vertex_buffer_free(chain->vertex_buf, chain->vertex_decl);
+ d3d8_texture_free(chain->tex);
+ d3d8_vertex_buffer_free(chain->vertex_buf, chain->vertex_decl);
free(chain);
}
@@ -276,19 +277,19 @@ static void d3d8_renderchain_render_pass(
settings_t *settings = config_get_ptr();
bool video_smooth = settings->bools.video_smooth;
- d3d_set_texture(d3dr, 0, chain->tex);
- d3d_set_sampler_magfilter(d3dr, pass_index, video_smooth ?
+ d3d8_set_texture(d3dr, 0, chain->tex);
+ d3d8_set_sampler_magfilter(d3dr, pass_index, video_smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
- d3d_set_sampler_minfilter(d3dr, pass_index, video_smooth ?
+ d3d8_set_sampler_minfilter(d3dr, pass_index, video_smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
- d3d_set_viewports(chain->dev, (D3DVIEWPORT8*)&d3d->final_viewport);
- d3d_set_vertex_shader(d3dr,
+ d3d8_set_viewports(chain->dev, (D3DVIEWPORT8*)&d3d->final_viewport);
+ d3d8_set_vertex_shader(d3dr,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
NULL);
- d3d_set_stream_source(d3dr, 0, chain->vertex_buf, 0, sizeof(Vertex));
+ d3d8_set_stream_source(d3dr, 0, chain->vertex_buf, 0, sizeof(Vertex));
d3d8_renderchain_set_mvp(d3d, chain, NULL, &d3d->mvp_rotate);
- d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
+ d3d8_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
}
static bool d3d8_renderchain_render(void *data, const void *frame,
@@ -452,7 +453,7 @@ static void d3d8_overlay_render(d3d_video_t *d3d,
if (!overlay->vert_buf)
{
- overlay->vert_buf = d3d_vertex_buffer_new(
+ overlay->vert_buf = d3d8_vertex_buffer_new(
d3d->dev, sizeof(vert), D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
D3DPOOL_MANAGED, NULL);
@@ -487,16 +488,16 @@ static void d3d8_overlay_render(d3d_video_t *d3d,
vert[2].v = overlay->tex_coords[1] + overlay->tex_coords[3];
vert[3].v = overlay->tex_coords[1] + overlay->tex_coords[3];
- verts = d3d_vertex_buffer_lock(overlay->vert_buf);
+ verts = d3d8_vertex_buffer_lock(overlay->vert_buf);
memcpy(verts, vert, sizeof(vert));
- d3d_vertex_buffer_unlock(overlay->vert_buf);
+ d3d8_vertex_buffer_unlock(overlay->vert_buf);
- d3d_enable_blend_func(d3d->dev);
- d3d_set_vertex_shader(d3d->dev,
+ d3d8_enable_blend_func(d3d->dev);
+ d3d8_set_vertex_shader(d3d->dev,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
NULL);
- d3d_set_stream_source(d3d->dev, 0, overlay->vert_buf,
+ d3d8_set_stream_source(d3d->dev, 0, overlay->vert_buf,
0, sizeof(*vert));
if (overlay->fullscreen)
@@ -508,21 +509,21 @@ static void d3d8_overlay_render(d3d_video_t *d3d,
vp_full.Height = height;
vp_full.MinZ = 0.0f;
vp_full.MaxZ = 1.0f;
- d3d_set_viewports(d3d->dev, &vp_full);
+ d3d8_set_viewports(d3d->dev, &vp_full);
}
/* Render overlay. */
- d3d_set_texture(d3d->dev, 0, overlay->tex);
- d3d_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_LINEAR);
- d3d_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_LINEAR);
- d3d_draw_primitive(d3d->dev, D3DPT_TRIANGLESTRIP, 0, 2);
+ d3d8_set_texture(d3d->dev, 0, overlay->tex);
+ d3d8_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_BORDER);
+ d3d8_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_BORDER);
+ d3d8_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_LINEAR);
+ d3d8_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_LINEAR);
+ d3d8_draw_primitive(d3d->dev, D3DPT_TRIANGLESTRIP, 0, 2);
/* Restore previous state. */
- d3d_disable_blend_func(d3d->dev);
+ d3d8_disable_blend_func(d3d->dev);
- d3d_set_viewports(d3d->dev, &d3d->final_viewport);
+ d3d8_set_viewports(d3d->dev, &d3d->final_viewport);
}
static void d3d8_free_overlay(d3d_video_t *d3d, overlay_t *overlay)
@@ -530,8 +531,8 @@ static void d3d8_free_overlay(d3d_video_t *d3d, overlay_t *overlay)
if (!d3d)
return;
- d3d_texture_free(overlay->tex);
- d3d_vertex_buffer_free(overlay->vert_buf, NULL);
+ d3d8_texture_free(overlay->tex);
+ d3d8_vertex_buffer_free(overlay->vert_buf, NULL);
}
static void d3d8_deinit_chain(d3d_video_t *d3d)
@@ -549,7 +550,7 @@ static void d3d8_deinitialize(d3d_video_t *d3d)
font_driver_free_osd();
d3d8_deinit_chain(d3d);
- d3d_vertex_buffer_free(d3d->menu_display.buffer, d3d->menu_display.decl);
+ d3d8_vertex_buffer_free(d3d->menu_display.buffer, d3d->menu_display.decl);
d3d->menu_display.buffer = NULL;
d3d->menu_display.decl = NULL;
}
@@ -561,12 +562,12 @@ static D3DFORMAT d3d8_get_color_format_backbuffer(bool rgb32, bool windowed)
D3DFORMAT fmt = D3DFMT_X8R8G8B8;
#ifdef _XBOX
if (!rgb32)
- fmt = d3d_get_rgb565_format();
+ fmt = d3d8_get_rgb565_format();
#else
if (windowed)
{
D3DDISPLAYMODE display_mode;
- if (d3d_get_adapter_display_mode(g_pD3D8, 0, &display_mode))
+ if (d3d8_get_adapter_display_mode(g_pD3D8, 0, &display_mode))
fmt = display_mode.Format;
}
#endif
@@ -649,7 +650,7 @@ static void d3d8_get_video_size(d3d_video_t *d3d,
}
#endif
-void d3d8_make_d3dpp(void *data,
+static void d3d8_make_d3dpp(void *data,
const video_info_t *info, void *_d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
@@ -760,7 +761,7 @@ static bool d3d8_init_base(void *data, const video_info_t *info)
memset(&d3dpp, 0, sizeof(d3dpp));
- g_pD3D8 = (LPDIRECT3D8)d3d_create();
+ g_pD3D8 = (LPDIRECT3D8)d3d8_create();
/* this needs g_pD3D created first */
d3d8_make_d3dpp(d3d, info, &d3dpp);
@@ -771,7 +772,7 @@ static bool d3d8_init_base(void *data, const video_info_t *info)
return false;
}
- if (!d3d_create_device(&d3d->dev, &d3dpp,
+ if (!d3d8_create_device(&d3d->dev, &d3dpp,
g_pD3D8,
focus_window,
d3d->cur_mon_id)
@@ -920,10 +921,10 @@ static bool d3d8_initialize(d3d_video_t *d3d, const video_info_t *info)
* font objects and free/realloc them around the d3d_reset call */
menu_driver_ctl(RARCH_MENU_CTL_DEINIT, NULL);
- if (!d3d_reset(d3d->dev, &d3dpp))
+ if (!d3d8_reset(d3d->dev, &d3dpp))
{
d3d8_deinitialize(d3d);
- d3d_device_free(NULL, g_pD3D8);
+ d3d8_device_free(NULL, g_pD3D8);
g_pD3D8 = NULL;
ret = d3d8_init_base(d3d, info);
@@ -948,11 +949,11 @@ static bool d3d8_initialize(d3d_video_t *d3d, const video_info_t *info)
font_driver_init_osd(d3d, false,
info->is_threaded,
- FONT_DRIVER_RENDER_DIRECT3D_API);
+ FONT_DRIVER_RENDER_D3D8_API);
d3d->menu_display.offset = 0;
d3d->menu_display.size = 1024;
- d3d->menu_display.buffer = d3d_vertex_buffer_new(
+ d3d->menu_display.buffer = d3d8_vertex_buffer_new(
d3d->dev, d3d->menu_display.size * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
@@ -965,12 +966,12 @@ static bool d3d8_initialize(d3d_video_t *d3d, const video_info_t *info)
d3d_matrix_ortho_off_center_lh(&d3d->mvp_transposed, 0, 1, 0, 1, 0, 1);
d3d_matrix_transpose(&d3d->mvp, &d3d->mvp_transposed);
- d3d_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
+ d3d8_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
return true;
}
-static bool d3d_restore(void *data)
+static bool d3d8_restore(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
@@ -1002,13 +1003,13 @@ static void d3d8_set_nonblock_state(void *data, bool state)
d3d->video_info.vsync = !state;
#ifdef _XBOX
- d3d_set_render_state(d3d->dev, D3D8_PRESENTATIONINTERVAL,
+ d3d8_set_render_state(d3d->dev, D3D8_PRESENTATIONINTERVAL,
interval ?
D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
);
#else
d3d->needs_restore = true;
- d3d_restore(d3d);
+ d3d8_restore(d3d);
#endif
}
@@ -1051,7 +1052,7 @@ static bool d3d8_alive(void *data)
{
d3d->should_resize = true;
d3d8_set_resize(d3d, temp_width, temp_height);
- d3d_restore(d3d);
+ d3d8_restore(d3d);
}
ret = !quit;
@@ -1117,9 +1118,9 @@ static void d3d8_set_osd_msg(void *data,
{
d3d_video_t *d3d = (d3d_video_t*)data;
- d3d_begin_scene(d3d->dev);
+ d3d8_begin_scene(d3d->dev);
font_driver_render_msg(video_info, font, msg, params);
- d3d_end_scene(d3d->dev);
+ d3d8_end_scene(d3d->dev);
}
static void d3d8_input_driver(
@@ -1273,7 +1274,7 @@ static void *d3d8_init(const video_info_t *info,
if (!d3d)
return NULL;
- if (!d3d_initialize_symbols(GFX_CTX_DIRECT3D8_API))
+ if (!d3d8_initialize_symbols(GFX_CTX_DIRECT3D8_API))
{
free(d3d);
return NULL;
@@ -1348,11 +1349,11 @@ static void d3d8_free(void *data)
free(d3d->shader_path);
d3d->shader_path = NULL;
- d3d_device_free(d3d->dev, g_pD3D8);
+ d3d8_device_free(d3d->dev, g_pD3D8);
d3d->dev = NULL;
g_pD3D8 = NULL;
- d3d_deinitialize_symbols();
+ d3d8_deinitialize_symbols();
#ifndef _XBOX
win32_monitor_from_window();
@@ -1425,10 +1426,10 @@ static bool d3d8_overlay_load(void *data,
unsigned height = images[i].height;
overlay_t *overlay = (overlay_t*)&d3d->overlays[i];
- overlay->tex = d3d_texture_new(d3d->dev, NULL,
+ overlay->tex = d3d8_texture_new(d3d->dev, NULL,
width, height, 1,
0,
- d3d_get_argb8888_format(),
+ d3d8_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0,
NULL, NULL, false);
@@ -1438,7 +1439,7 @@ static bool d3d8_overlay_load(void *data,
return false;
}
- if (d3d_lock_rectangle(overlay->tex, 0, &d3dlr,
+ if (d3d8_lock_rectangle(overlay->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
uint32_t *dst = (uint32_t*)(d3dlr.pBits);
@@ -1447,7 +1448,7 @@ static bool d3d8_overlay_load(void *data,
for (y = 0; y < height; y++, dst += pitch, src += width)
memcpy(dst, src, width << 2);
- d3d_unlock_rectangle(overlay->tex);
+ d3d8_unlock_rectangle(overlay->tex);
}
overlay->tex_w = width;
@@ -1568,7 +1569,7 @@ static bool d3d8_frame(void *data, const void *frame,
return true;
#endif
- if (!d3d_restore(d3d))
+ if (!d3d8_restore(d3d))
{
RARCH_ERR("[D3D]: Failed to restore.\n");
return false;
@@ -1589,8 +1590,8 @@ static bool d3d8_frame(void *data, const void *frame,
screen_vp.MaxZ = 1;
screen_vp.Width = width;
screen_vp.Height = height;
- d3d_set_viewports(d3d->dev, &screen_vp);
- d3d_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
+ d3d8_set_viewports(d3d->dev, &screen_vp);
+ d3d8_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
/* Insert black frame first, so we
* can screenshot, etc. */
@@ -1637,14 +1638,14 @@ static bool d3d8_frame(void *data, const void *frame,
if (!string_is_empty(msg))
{
- d3d_set_viewports(d3d->dev, &screen_vp);
- d3d_begin_scene(d3d->dev);
+ d3d8_set_viewports(d3d->dev, &screen_vp);
+ d3d8_begin_scene(d3d->dev);
font_driver_render_msg(video_info, NULL, msg, NULL);
- d3d_end_scene(d3d->dev);
+ d3d8_end_scene(d3d->dev);
}
d3d8_update_title(video_info);
- d3d_swap(d3d, d3d->dev);
+ d3d8_swap(d3d, d3d->dev);
return true;
}
@@ -1679,11 +1680,11 @@ static void d3d8_set_menu_texture_frame(void *data,
d3d->menu->tex_h != height)
{
if (d3d->menu)
- d3d_texture_free(d3d->menu->tex);
+ d3d8_texture_free(d3d->menu->tex);
- d3d->menu->tex = d3d_texture_new(d3d->dev, NULL,
+ d3d->menu->tex = d3d8_texture_new(d3d->dev, NULL,
width, height, 1,
- 0, d3d_get_argb8888_format(),
+ 0, d3d8_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL, false);
if (!d3d->menu->tex)
@@ -1702,7 +1703,7 @@ static void d3d8_set_menu_texture_frame(void *data,
d3d->menu->alpha_mod = alpha;
- if (d3d_lock_rectangle(d3d->menu->tex, 0, &d3dlr,
+ if (d3d8_lock_rectangle(d3d->menu->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
unsigned h, w;
@@ -1743,7 +1744,7 @@ static void d3d8_set_menu_texture_frame(void *data,
if (d3d->menu)
- d3d_unlock_rectangle(d3d->menu->tex);
+ d3d8_unlock_rectangle(d3d->menu->tex);
}
}
@@ -1774,9 +1775,9 @@ static void d3d8_video_texture_load_d3d(
unsigned usage = 0;
d3d_video_t *d3d = (d3d_video_t*)info->userdata;
struct texture_image *ti = (struct texture_image*)info->data;
- LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)d3d_texture_new(d3d->dev, NULL,
+ LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)d3d8_texture_new(d3d->dev, NULL,
ti->width, ti->height, 0,
- usage, d3d_get_argb8888_format(),
+ usage, d3d8_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0,
NULL, NULL, false);
@@ -1786,7 +1787,7 @@ static void d3d8_video_texture_load_d3d(
return;
}
- if (d3d_lock_rectangle(tex, 0, &d3dlr,
+ if (d3d8_lock_rectangle(tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
unsigned i;
@@ -1796,7 +1797,7 @@ static void d3d8_video_texture_load_d3d(
for (i = 0; i < ti->height; i++, dst += pitch, src += ti->width)
memcpy(dst, src, ti->width << 2);
- d3d_unlock_rectangle(tex);
+ d3d8_unlock_rectangle(tex);
}
*id = (uintptr_t)tex;
@@ -1837,7 +1838,7 @@ static void d3d8_unload_texture(void *data, uintptr_t id)
return;
texid = (LPDIRECT3DTEXTURE8)id;
- d3d_texture_free(texid);
+ d3d8_texture_free(texid);
}
static void d3d8_set_video_mode(void *data,
diff --git a/gfx/drivers/d3d9.c b/gfx/drivers/d3d9.c
index d166eb1d52..31112e9b26 100644
--- a/gfx/drivers/d3d9.c
+++ b/gfx/drivers/d3d9.c
@@ -32,6 +32,7 @@
#include "d3d.h"
#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"
@@ -407,7 +408,7 @@ static void d3d9_set_mvp(void *data,
const void *mat_data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
- d3d_set_vertex_shader_constantf(d3d->dev, 0, (const float*)mat_data, 4);
+ d3d9_set_vertex_shader_constantf(d3d->dev, 0, (const float*)mat_data, 4);
}
static void d3d9_overlay_render(d3d_video_t *d3d,
@@ -436,7 +437,7 @@ static void d3d9_overlay_render(d3d_video_t *d3d,
if (!overlay->vert_buf)
{
- overlay->vert_buf = d3d_vertex_buffer_new(
+ overlay->vert_buf = d3d9_vertex_buffer_new(
d3d->dev, sizeof(vert), D3DUSAGE_WRITEONLY,
#ifdef _XBOX
0,
@@ -475,18 +476,18 @@ static void d3d9_overlay_render(d3d_video_t *d3d,
vert[2].v = overlay->tex_coords[1] + overlay->tex_coords[3];
vert[3].v = overlay->tex_coords[1] + overlay->tex_coords[3];
- verts = d3d_vertex_buffer_lock(overlay->vert_buf);
+ verts = d3d9_vertex_buffer_lock(overlay->vert_buf);
memcpy(verts, vert, sizeof(vert));
- d3d_vertex_buffer_unlock(overlay->vert_buf);
+ d3d9_vertex_buffer_unlock(overlay->vert_buf);
- d3d_enable_blend_func(d3d->dev);
+ d3d9_enable_blend_func(d3d->dev);
/* set vertex declaration for overlay. */
- d3d_vertex_declaration_new(d3d->dev, &vElems, (void**)&vertex_decl);
- d3d_set_vertex_declaration(d3d->dev, vertex_decl);
- d3d_vertex_declaration_free(vertex_decl);
+ d3d9_vertex_declaration_new(d3d->dev, &vElems, (void**)&vertex_decl);
+ d3d9_set_vertex_declaration(d3d->dev, vertex_decl);
+ d3d9_vertex_declaration_free(vertex_decl);
- d3d_set_stream_source(d3d->dev, 0, overlay->vert_buf,
+ d3d9_set_stream_source(d3d->dev, 0, overlay->vert_buf,
0, sizeof(*vert));
if (overlay->fullscreen)
@@ -499,20 +500,20 @@ static void d3d9_overlay_render(d3d_video_t *d3d,
vp_full.Height = height;
vp_full.MinZ = 0.0f;
vp_full.MaxZ = 1.0f;
- d3d_set_viewports(d3d->dev, &vp_full);
+ d3d9_set_viewports(d3d->dev, &vp_full);
}
/* Render overlay. */
- d3d_set_texture(d3d->dev, 0, overlay->tex);
- d3d_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_LINEAR);
- d3d_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_LINEAR);
- d3d_draw_primitive(d3d->dev, D3DPT_TRIANGLESTRIP, 0, 2);
+ d3d9_set_texture(d3d->dev, 0, overlay->tex);
+ d3d9_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_LINEAR);
+ d3d9_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_LINEAR);
+ d3d9_draw_primitive(d3d->dev, D3DPT_TRIANGLESTRIP, 0, 2);
/* Restore previous state. */
- d3d_disable_blend_func(d3d->dev);
- d3d_set_viewports(d3d->dev, &d3d->final_viewport);
+ d3d9_disable_blend_func(d3d->dev);
+ d3d9_set_viewports(d3d->dev, &d3d->final_viewport);
}
static void d3d9_free_overlay(d3d_video_t *d3d, overlay_t *overlay)
@@ -520,11 +521,11 @@ static void d3d9_free_overlay(d3d_video_t *d3d, overlay_t *overlay)
if (!d3d)
return;
- d3d_texture_free(overlay->tex);
- d3d_vertex_buffer_free(overlay->vert_buf, NULL);
+ d3d9_texture_free(overlay->tex);
+ d3d9_vertex_buffer_free(overlay->vert_buf, NULL);
}
-static void d3d_deinit_chain(d3d_video_t *d3d)
+static void d3d9_deinit_chain(d3d_video_t *d3d)
{
if (!d3d || !d3d->renderchain_driver)
return;
@@ -536,30 +537,30 @@ static void d3d_deinit_chain(d3d_video_t *d3d)
d3d->renderchain_data = NULL;
}
-static void d3d_deinitialize(d3d_video_t *d3d)
+static void d3d9_deinitialize(d3d_video_t *d3d)
{
if (!d3d)
return;
font_driver_free_osd();
- d3d_deinit_chain(d3d);
- d3d_vertex_buffer_free(d3d->menu_display.buffer, d3d->menu_display.decl);
+ d3d9_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 D3DFORMAT d3d_get_color_format_backbuffer(bool rgb32, bool windowed)
+static D3DFORMAT d3d9_get_color_format_backbuffer(bool rgb32, bool windowed)
{
D3DFORMAT fmt = D3DFMT_X8R8G8B8;
#ifdef _XBOX
if (!rgb32)
- fmt = d3d_get_rgb565_format();
+ fmt = d3d9_get_rgb565_format();
#else
if (windowed)
{
D3DDISPLAYMODE display_mode;
- if (d3d_get_adapter_display_mode(g_pD3D9, 0, &display_mode))
+ if (d3d9_get_adapter_display_mode(g_pD3D9, 0, &display_mode))
fmt = display_mode.Format;
}
#endif
@@ -567,13 +568,13 @@ static D3DFORMAT d3d_get_color_format_backbuffer(bool rgb32, bool windowed)
}
#ifdef _XBOX
-static D3DFORMAT d3d_get_color_format_front_buffer(void)
+static D3DFORMAT d3d9_get_color_format_front_buffer(void)
{
return D3DFMT_LE_X8R8G8B8;
}
#endif
-static bool d3d_is_windowed_enable(bool info_fullscreen)
+static bool d3d9_is_windowed_enable(bool info_fullscreen)
{
#ifndef _XBOX
settings_t *settings = config_get_ptr();
@@ -614,7 +615,7 @@ static void d3d9_get_video_size(d3d_video_t *d3d,
}
#endif
-void d3d_make_d3dpp(void *data,
+void d3d9_make_d3dpp(void *data,
const video_info_t *info, void *_d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
@@ -625,7 +626,7 @@ void d3d_make_d3dpp(void *data,
bool gamma_enable = global ?
global->console.screen.gamma_correction : false;
#endif
- bool windowed_enable = d3d_is_windowed_enable(info->fullscreen);
+ bool windowed_enable = d3d9_is_windowed_enable(info->fullscreen);
memset(d3dpp, 0, sizeof(*d3dpp));
@@ -656,11 +657,11 @@ void d3d_make_d3dpp(void *data,
d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp->BackBufferCount = 2;
- d3dpp->BackBufferFormat = d3d_get_color_format_backbuffer(
+ d3dpp->BackBufferFormat = d3d9_get_color_format_backbuffer(
info->rgb32, windowed_enable);
#ifdef _XBOX
- d3dpp->FrontBufferFormat = d3d_get_color_format_front_buffer();
+ d3dpp->FrontBufferFormat = d3d9_get_color_format_front_buffer();
if (gamma_enable)
{
@@ -706,10 +707,10 @@ static bool d3d9_init_base(void *data, const video_info_t *info)
memset(&d3dpp, 0, sizeof(d3dpp));
- g_pD3D9 = (LPDIRECT3D9)d3d_create();
+ g_pD3D9 = (LPDIRECT3D9)d3d9_create();
/* this needs g_pD3D9 created first */
- d3d_make_d3dpp(d3d, info, &d3dpp);
+ d3d9_make_d3dpp(d3d, info, &d3dpp);
if (!g_pD3D9)
{
@@ -717,7 +718,7 @@ static bool d3d9_init_base(void *data, const video_info_t *info)
return false;
}
- if (!d3d_create_device(&d3d->dev, &d3dpp,
+ if (!d3d9_create_device(&d3d->dev, &d3dpp,
g_pD3D9,
focus_window,
d3d->cur_mon_id)
@@ -730,7 +731,7 @@ static bool d3d9_init_base(void *data, const video_info_t *info)
return true;
}
-static void d3d_calculate_rect(void *data,
+static void d3d9_calculate_rect(void *data,
unsigned *width, unsigned *height,
int *x, int *y,
bool force_full,
@@ -818,7 +819,7 @@ static void d3d9_set_viewport(void *data,
int y = 0;
d3d_video_t *d3d = (d3d_video_t*)data;
- d3d_calculate_rect(data, &width, &height, &x, &y,
+ d3d9_calculate_rect(data, &width, &height, &x, &y,
force_full, allow_rotate);
/* D3D doesn't support negative X/Y viewports ... */
@@ -853,7 +854,7 @@ static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
{
D3DPRESENT_PARAMETERS d3dpp;
- d3d_make_d3dpp(d3d, info, &d3dpp);
+ d3d9_make_d3dpp(d3d, info, &d3dpp);
/* the D3DX font driver uses POOL_DEFAULT resources
* and will prevent a clean reset here
@@ -861,10 +862,10 @@ static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
* font objects and free/realloc them around the d3d_reset call */
menu_driver_ctl(RARCH_MENU_CTL_DEINIT, NULL);
- if (!d3d_reset(d3d->dev, &d3dpp))
+ if (!d3d9_reset(d3d->dev, &d3dpp))
{
- d3d_deinitialize(d3d);
- d3d_device_free(NULL, g_pD3D9);
+ d3d9_deinitialize(d3d);
+ d3d9_device_free(NULL, g_pD3D9);
g_pD3D9 = NULL;
ret = d3d9_init_base(d3d, info);
@@ -893,7 +894,7 @@ static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
#endif
font_driver_init_osd(d3d, false,
info->is_threaded,
- FONT_DRIVER_RENDER_DIRECT3D_API);
+ FONT_DRIVER_RENDER_D3D9_API);
{
static const D3DVERTEXELEMENT9 VertexElements[4] = {
@@ -905,14 +906,14 @@ static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
D3DDECLUSAGE_COLOR, 0},
D3DDECL_END()
};
- if (!d3d_vertex_declaration_new(d3d->dev,
+ 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 = d3d_vertex_buffer_new(
+ d3d->menu_display.buffer = d3d9_vertex_buffer_new(
d3d->dev, d3d->menu_display.size * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
#ifdef _XBOX
@@ -929,7 +930,7 @@ static bool d3d9_initialize(d3d_video_t *d3d, const video_info_t *info)
d3d_matrix_ortho_off_center_lh(&d3d->mvp_transposed, 0, 1, 0, 1, 0, 1);
d3d_matrix_transpose(&d3d->mvp, &d3d->mvp_transposed);
- d3d_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
+ d3d9_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
return true;
}
@@ -941,7 +942,7 @@ static bool d3d9_restore(void *data)
if (!d3d)
return false;
- d3d_deinitialize(d3d);
+ d3d9_deinitialize(d3d);
if (!d3d9_initialize(d3d, &d3d->video_info))
{
@@ -966,7 +967,7 @@ static void d3d9_set_nonblock_state(void *data, bool state)
d3d->video_info.vsync = !state;
#ifdef _XBOX
- d3d_set_render_state(d3d->dev,
+ d3d9_set_render_state(d3d->dev,
D3D9_PRESENTATIONINTERVAL,
interval ?
D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE
@@ -1070,9 +1071,9 @@ static void d3d9_set_osd_msg(void *data,
if (d3d->renderchain_driver->set_font_rect && params)
d3d->renderchain_driver->set_font_rect(d3d, params);
- d3d_begin_scene(d3d->dev);
+ d3d9_begin_scene(d3d->dev);
font_driver_render_msg(video_info, font, msg, params);
- d3d_end_scene(d3d->dev);
+ d3d9_end_scene(d3d->dev);
}
static void d3d9_input_driver(
@@ -1251,7 +1252,7 @@ static void *d3d9_init(const video_info_t *info,
if (!d3d)
return NULL;
- if (!d3d_initialize_symbols(GFX_CTX_DIRECT3D9_API))
+ if (!d3d9_initialize_symbols(GFX_CTX_DIRECT3D9_API))
{
free(d3d);
return NULL;
@@ -1320,17 +1321,17 @@ static void d3d9_free(void *data)
free(d3d->menu);
d3d->menu = NULL;
- d3d_deinitialize(d3d);
+ d3d9_deinitialize(d3d);
if (!string_is_empty(d3d->shader_path))
free(d3d->shader_path);
d3d->shader_path = NULL;
- d3d_device_free(d3d->dev, g_pD3D9);
+ d3d9_device_free(d3d->dev, g_pD3D9);
d3d->dev = NULL;
g_pD3D9 = NULL;
- d3d_deinitialize_symbols();
+ d3d9_deinitialize_symbols();
#ifndef _XBOX
win32_monitor_from_window();
@@ -1397,10 +1398,10 @@ static bool d3d9_overlay_load(void *data,
unsigned height = images[i].height;
overlay_t *overlay = (overlay_t*)&d3d->overlays[i];
- overlay->tex = d3d_texture_new(d3d->dev, NULL,
+ overlay->tex = d3d9_texture_new(d3d->dev, NULL,
width, height, 1,
0,
- d3d_get_argb8888_format(),
+ d3d9_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0,
NULL, NULL, false);
@@ -1410,7 +1411,7 @@ static bool d3d9_overlay_load(void *data,
return false;
}
- if (d3d_lock_rectangle(overlay->tex, 0, &d3dlr,
+ if (d3d9_lock_rectangle(overlay->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
uint32_t *dst = (uint32_t*)(d3dlr.pBits);
@@ -1419,7 +1420,7 @@ static bool d3d9_overlay_load(void *data,
for (y = 0; y < height; y++, dst += pitch, src += width)
memcpy(dst, src, width << 2);
- d3d_unlock_rectangle(overlay->tex);
+ d3d9_unlock_rectangle(overlay->tex);
}
overlay->tex_w = width;
@@ -1565,16 +1566,16 @@ static bool d3d9_frame(void *data, const void *frame,
screen_vp.MaxZ = 1;
screen_vp.Width = width;
screen_vp.Height = height;
- d3d_set_viewports(d3d->dev, &screen_vp);
- d3d_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
+ d3d9_set_viewports(d3d->dev, &screen_vp);
+ d3d9_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
/* Insert black frame first, so we
* can screenshot, etc. */
if (video_info->black_frame_insertion)
{
- if (!d3d_swap(d3d, d3d->dev) || d3d->needs_restore)
+ if (!d3d9_swap(d3d, d3d->dev) || d3d->needs_restore)
return true;
- d3d_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
+ d3d9_clear(d3d->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
}
if (!d3d->renderchain_driver->render(
@@ -1594,10 +1595,10 @@ static bool d3d9_frame(void *data, const void *frame,
d3d9_overlay_render(d3d, video_info, d3d->menu);
d3d->menu_display.offset = 0;
- d3d_set_vertex_declaration(d3d->dev, d3d->menu_display.decl);
- d3d_set_stream_source(d3d->dev, 0, d3d->menu_display.buffer, 0, sizeof(Vertex));
+ d3d9_set_vertex_declaration(d3d->dev, d3d->menu_display.decl);
+ d3d9_set_stream_source(d3d->dev, 0, d3d->menu_display.buffer, 0, sizeof(Vertex));
- d3d_set_viewports(d3d->dev, &screen_vp);
+ d3d9_set_viewports(d3d->dev, &screen_vp);
menu_driver_frame(video_info);
}
#endif
@@ -1613,14 +1614,14 @@ static bool d3d9_frame(void *data, const void *frame,
if (msg && *msg)
{
- d3d_set_viewports(d3d->dev, &screen_vp);
- d3d_begin_scene(d3d->dev);
+ d3d9_set_viewports(d3d->dev, &screen_vp);
+ d3d9_begin_scene(d3d->dev);
font_driver_render_msg(video_info, NULL, msg, NULL);
- d3d_end_scene(d3d->dev);
+ d3d9_end_scene(d3d->dev);
}
d3d9_update_title(video_info);
- d3d_swap(d3d, d3d->dev);
+ d3d9_swap(d3d, d3d->dev);
return true;
}
@@ -1693,11 +1694,11 @@ static void d3d9_set_menu_texture_frame(void *data,
d3d->menu->tex_h != height)
{
if (d3d->menu)
- d3d_texture_free(d3d->menu->tex);
+ d3d9_texture_free(d3d->menu->tex);
- d3d->menu->tex = d3d_texture_new(d3d->dev, NULL,
+ d3d->menu->tex = d3d9_texture_new(d3d->dev, NULL,
width, height, 1,
- 0, d3d_get_argb8888_format(),
+ 0, d3d9_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL, false);
if (!d3d->menu->tex)
@@ -1712,7 +1713,7 @@ static void d3d9_set_menu_texture_frame(void *data,
d3d->menu->alpha_mod = alpha;
- if (d3d_lock_rectangle(d3d->menu->tex, 0, &d3dlr,
+ if (d3d9_lock_rectangle(d3d->menu->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
unsigned h, w;
@@ -1753,7 +1754,7 @@ static void d3d9_set_menu_texture_frame(void *data,
if (d3d->menu)
- d3d_unlock_rectangle(d3d->menu->tex);
+ d3d9_unlock_rectangle(d3d->menu->tex);
}
}
@@ -1794,9 +1795,9 @@ static void d3d9_video_texture_load_d3d(
(info->type == TEXTURE_FILTER_MIPMAP_NEAREST))
want_mipmap = true;
- tex = (LPDIRECT3DTEXTURE9)d3d_texture_new(d3d->dev, NULL,
+ tex = (LPDIRECT3DTEXTURE9)d3d9_texture_new(d3d->dev, NULL,
ti->width, ti->height, 0,
- usage, d3d_get_argb8888_format(),
+ usage, d3d9_get_argb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0,
NULL, NULL, want_mipmap);
@@ -1806,7 +1807,7 @@ static void d3d9_video_texture_load_d3d(
return;
}
- if (d3d_lock_rectangle(tex, 0, &d3dlr,
+ if (d3d9_lock_rectangle(tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
{
unsigned i;
@@ -1816,7 +1817,7 @@ static void d3d9_video_texture_load_d3d(
for (i = 0; i < ti->height; i++, dst += pitch, src += ti->width)
memcpy(dst, src, ti->width << 2);
- d3d_unlock_rectangle(tex);
+ d3d9_unlock_rectangle(tex);
}
*id = (uintptr_t)tex;
@@ -1857,7 +1858,7 @@ static void d3d9_unload_texture(void *data, uintptr_t id)
return;
texid = (LPDIRECT3DTEXTURE9)id;
- d3d_texture_free(texid);
+ d3d9_texture_free(texid);
}
static void d3d9_set_video_mode(void *data,
diff --git a/gfx/drivers_font/d3d_w32_font.c b/gfx/drivers_font/d3d_w32_font.c
index c81f597b83..c26eff4180 100644
--- a/gfx/drivers_font/d3d_w32_font.c
+++ b/gfx/drivers_font/d3d_w32_font.c
@@ -24,6 +24,7 @@
#include "../drivers/d3d.h"
#include "../common/d3d_common.h"
+#include "../common/d3d9_common.h"
#include "../font_driver.h"
#include "../../configuration.h"
@@ -81,12 +82,12 @@ static void *d3dfonts_w32_init_font(void *video_data,
desc.Height = d3dfonts->font_size;
- if (!d3dx_create_font_indirect(d3dfonts->d3d->dev,
+ if (!d3d9x_create_font_indirect(d3dfonts->d3d->dev,
&desc, (void**)&d3dfonts->font))
goto error;
- d3dx_font_get_text_metrics(d3dfonts->font, &metrics);
+ d3d9x_font_get_text_metrics(d3dfonts->font, &metrics);
d3dfonts->ascent = metrics.tmAscent;
@@ -105,7 +106,7 @@ static void d3dfonts_w32_free_font(void *data, bool is_threaded)
return;
if (d3dfonts->font)
- d3dx_font_release(d3dfonts->font);
+ d3d9x_font_release(d3dfonts->font);
free(d3dfonts);
}
@@ -120,7 +121,7 @@ static int d3dfonts_w32_get_message_width(void* data, const char* msg,
if (!d3dfonts || !msg)
return 0;
- d3dx_font_draw_text(d3dfonts->font, NULL, (void*)msg,
+ d3d9x_font_draw_text(d3dfonts->font, NULL, (void*)msg,
msg_len? msg_len : -1, &box, DT_CALCRECT, 0);
return box.right - box.left;
@@ -213,12 +214,12 @@ static void d3dfonts_w32_render_msg(video_frame_info_t *video_info,
unsigned drop_g = g * drop_mod;
unsigned drop_b = b * drop_mod;
- d3dx_font_draw_text(d3dfonts->font, NULL,
+ d3d9x_font_draw_text(d3dfonts->font, NULL,
(void*)msg, -1, p_rect_shifted, format,
D3DCOLOR_ARGB(drop_a , drop_r, drop_g, drop_b));
}
- d3dx_font_draw_text(d3dfonts->font, NULL, (void*)msg, -1,
+ d3d9x_font_draw_text(d3dfonts->font, NULL, (void*)msg, -1,
p_rect, format, D3DCOLOR_ARGB(a, r, g, b));
}
diff --git a/gfx/drivers_font/xdk1_xfonts.c b/gfx/drivers_font/xdk1_xfonts.c
index d73079e161..a8c8dec2ea 100644
--- a/gfx/drivers_font/xdk1_xfonts.c
+++ b/gfx/drivers_font/xdk1_xfonts.c
@@ -22,6 +22,8 @@
#endif
#include "../drivers/d3d.h"
+#include "../drivers/d3d_common.h"
+#include "../drivers/d3d8_common.h"
#include "../font_driver.h"
@@ -96,7 +98,7 @@ static void xfonts_render_msg(
y = video_info->font_msg_pos_y;
}
- d3d_device_get_backbuffer(xfonts->d3d->dev, -1, 0, D3DBACKBUFFER_TYPE_MONO, &xfonts->surf);
+ d3d8_device_get_backbuffer(xfonts->d3d->dev, -1, 0, D3DBACKBUFFER_TYPE_MONO, &xfonts->surf);
mbstowcs(str, msg, sizeof(str) / sizeof(wchar_t));
@@ -105,7 +107,7 @@ static void xfonts_render_msg(
#else
XFONT_TextOut(xfonts->debug_font, xfonts->surf, str, (unsigned)-1, x, y);
#endif
- d3d_surface_free(xfonts->surf);
+ d3d8_surface_free(xfonts->surf);
}
font_renderer_t d3d_xdk1_font = {
diff --git a/gfx/drivers_font/xdk360_fonts.cpp b/gfx/drivers_font/xdk360_fonts.cpp
index 584144901d..f75f07081b 100644
--- a/gfx/drivers_font/xdk360_fonts.cpp
+++ b/gfx/drivers_font/xdk360_fonts.cpp
@@ -23,6 +23,7 @@
#include "../drivers/d3d.h"
#include "../common/d3d_common.h"
+#include "../common/d3d9_common.h"
#include "../font_driver.h"
#include "../drivers/d3d_shaders/font.hlsl.d3d9.h"
@@ -439,14 +440,14 @@ static bool xdk360_video_font_create_shaders(xdk360_video_font_t * font, void *d
return true;
}
- if (!d3d_vertex_declaration_new(dev, decl, (void**)&font->s_FontLocals.m_pFontVertexDecl))
+ if (!d3d9_vertex_declaration_new(dev, decl, (void**)&font->s_FontLocals.m_pFontVertexDecl))
goto error;
if (!d3dx_compile_shader( font_hlsl_d3d9_program, sizeof(font_hlsl_d3d9_program)-1 ,
NULL, NULL, "main_vertex", "vs.2.0", 0, &pShaderCode, NULL, NULL ))
goto error;
- if (!d3d_create_vertex_shader(dev, (const DWORD*)pShaderCode->GetBufferPointer(),
+ if (!d3d9_create_vertex_shader(dev, (const DWORD*)pShaderCode->GetBufferPointer(),
(void**)&font->s_FontLocals.m_pFontVertexShader ))
goto error;
@@ -456,7 +457,7 @@ static bool xdk360_video_font_create_shaders(xdk360_video_font_t * font, void *d
NULL, NULL, "main_fragment", "ps.2.0", 0,&pShaderCode, NULL, NULL ))
goto error;
- if (!d3d_create_pixel_shader(dev, (DWORD*)pShaderCode->GetBufferPointer(),
+ if (!d3d9_create_pixel_shader(dev, (DWORD*)pShaderCode->GetBufferPointer(),
(void**)&font->s_FontLocals.m_pFontPixelShader))
goto error;
@@ -467,9 +468,9 @@ static bool xdk360_video_font_create_shaders(xdk360_video_font_t * font, void *d
error:
if (pShaderCode)
d3dxbuffer_release(pShaderCode);
- d3d_free_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
- d3d_free_vertex_shader(font->d3d->dev, font->s_FontLocals.m_pFontVertexShader);
- d3d_vertex_declaration_free(font->s_FontLocals.m_pFontVertexDecl);
+ d3d9_free_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
+ d3d9_free_vertex_shader(font->d3d->dev, font->s_FontLocals.m_pFontVertexShader);
+ d3d9_vertex_declaration_free(font->s_FontLocals.m_pFontVertexDecl);
font->s_FontLocals.m_pFontPixelShader = NULL;
font->s_FontLocals.m_pFontVertexShader = NULL;
font->s_FontLocals.m_pFontVertexDecl = NULL;
@@ -565,9 +566,9 @@ static void xdk360_free_font(void *data, bool is_threaded)
font->m_cMaxGlyph = 0;
font->m_TranslatorTable = NULL;
- d3d_free_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
- d3d_free_vertex_shader(font->d3d->dev, font->s_FontLocals.m_pFontVertexShader);
- d3d_vertex_declaration_free(font->s_FontLocals.m_pFontVertexDecl);
+ d3d9_free_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
+ d3d9_free_vertex_shader(font->d3d->dev, font->s_FontLocals.m_pFontVertexShader);
+ d3d9_vertex_declaration_free(font->s_FontLocals.m_pFontVertexDecl);
font->s_FontLocals.m_pFontPixelShader = NULL;
font->s_FontLocals.m_pFontVertexShader = NULL;
@@ -585,11 +586,11 @@ static void xdk360_render_msg_post(xdk360_video_font_t * font)
if (!font || !font->d3d || !font->d3d->dev)
return;
- d3d_set_texture(font->d3d->dev, 0, NULL);
- d3d_set_vertex_declaration(font->d3d->dev, NULL);
- d3d_set_vertex_shader(font->d3d->dev, 0, NULL);
- d3d_set_pixel_shader(font->d3d->dev, NULL);
- d3d_set_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE, font->m_dwSavedState);
+ d3d9_set_texture(font->d3d->dev, 0, NULL);
+ d3d9_set_vertex_declaration(font->d3d->dev, NULL);
+ d3d9_set_vertex_shader(font->d3d->dev, 0, NULL);
+ d3d9_set_pixel_shader(font->d3d->dev, NULL);
+ d3d9_set_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE, font->m_dwSavedState);
}
static void xdk360_render_msg_pre(xdk360_video_font_t * font)
@@ -601,26 +602,26 @@ static void xdk360_render_msg_pre(xdk360_video_font_t * font)
return;
/* Save state. */
- d3d_get_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE,
+ d3d9_get_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE,
(DWORD*)&font->m_dwSavedState );
/* Set the texture scaling factor as a vertex shader constant. */
/* Get the description */
- d3d_texture_get_level_desc(font->m_pFontTexture, 0, &TextureDesc);
+ d3d9_texture_get_level_desc(font->m_pFontTexture, 0, &TextureDesc);
/* Set render state. */
- d3d_set_texture(font->d3d->dev, 0, font->m_pFontTexture);
+ d3d9_set_texture(font->d3d->dev, 0, font->m_pFontTexture);
vTexScale[0] = 1.0f / TextureDesc.Width;
vTexScale[1] = 1.0f / TextureDesc.Height;
vTexScale[2] = 0.0f;
vTexScale[3] = 0.0f;
- d3d_set_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE, FALSE);
- d3d_set_vertex_declaration(font->d3d->dev, font->s_FontLocals.m_pFontVertexDecl);
- d3d_set_vertex_shader(font->d3d->dev, 0, font->s_FontLocals.m_pFontVertexShader);
- d3d_set_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
- d3d_set_vertex_shader_constantf(font->d3d->dev, 2, vTexScale, 1);
+ d3d9_set_render_state(font->d3d->dev, D3DRS_VIEWPORTENABLE, FALSE);
+ d3d9_set_vertex_declaration(font->d3d->dev, font->s_FontLocals.m_pFontVertexDecl);
+ d3d9_set_vertex_shader(font->d3d->dev, 0, font->s_FontLocals.m_pFontVertexShader);
+ d3d9_set_pixel_shader(font->d3d->dev, font->s_FontLocals.m_pFontPixelShader);
+ d3d9_set_vertex_shader_constantf(font->d3d->dev, 2, vTexScale, 1);
}
static void xdk360_draw_text(xdk360_video_font_t *font,
@@ -637,7 +638,7 @@ static void xdk360_draw_text(xdk360_video_font_t *font,
vColor[2] = ((0xffffffff & 0x000000ff) >> 0L) / 255.0f;
vColor[3] = ((0xffffffff & 0xff000000) >> 24L) / 255.0f;
- d3d_set_vertex_shader_constantf(dev, 1, vColor, 1);
+ d3d9_set_vertex_shader_constantf(dev, 1, vColor, 1);
m_fCursorX = floorf(x);
m_fCursorY = floorf(y);
diff --git a/gfx/drivers_renderchain/d3d9_cg_renderchain.c b/gfx/drivers_renderchain/d3d9_cg_renderchain.c
index 178b699d43..ed8308e1a6 100644
--- a/gfx/drivers_renderchain/d3d9_cg_renderchain.c
+++ b/gfx/drivers_renderchain/d3d9_cg_renderchain.c
@@ -30,6 +30,7 @@
#include
#include "../common/d3d_common.h"
+#include "../common/d3d9_common.h"
#include "../drivers/d3d.h"
#include "../drivers/d3d_shaders/opaque.cg.d3d9.h"
@@ -434,7 +435,7 @@ static bool d3d9_cg_renderchain_init_shader_fvf(void *data, void *pass_data)
free(indices);
- return d3d_vertex_declaration_new(chain->dev,
+ return d3d9_vertex_declaration_new(chain->dev,
decl, (void**)&pass->vertex_decl);
}
@@ -460,13 +461,13 @@ static void d3d9_cg_renderchain_bind_orig(cg_renderchain_t *chain,
if (param)
{
index = cgGetParameterResourceIndex(param);
- d3d_set_texture(chain->dev, index, chain->passes->data[0].tex);
- d3d_set_sampler_magfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[0].info.pass->filter));
- d3d_set_sampler_minfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[0].info.pass->filter));
- d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, index, chain->passes->data[0].tex);
+ d3d9_set_sampler_magfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[0].info.pass->filter));
+ d3d9_set_sampler_minfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[0].info.pass->filter));
+ d3d9_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
unsigned_vector_list_append(chain->bound_tex, index);
}
@@ -477,7 +478,7 @@ static void d3d9_cg_renderchain_bind_orig(cg_renderchain_t *chain,
index = pass->attrib_map->data[cgGetParameterResourceIndex(param)];
- d3d_set_stream_source(chain->dev, index,
+ d3d9_set_stream_source(chain->dev, index,
vert_buf, 0, sizeof(struct CGVertex));
unsigned_vector_list_append(chain->bound_vert, index);
}
@@ -534,15 +535,15 @@ static void d3d9_cg_renderchain_bind_prev(void *data, const void *pass_data)
tex = (LPDIRECT3DTEXTURE9)
chain->prev.tex[(chain->prev.ptr - (i + 1)) & TEXTURESMASK];
- d3d_set_texture(chain->dev, index, tex);
+ d3d9_set_texture(chain->dev, index, tex);
unsigned_vector_list_append(chain->bound_tex, index);
- d3d_set_sampler_magfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[0].info.pass->filter));
- d3d_set_sampler_minfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[0].info.pass->filter));
- d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_magfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[0].info.pass->filter));
+ d3d9_set_sampler_minfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[0].info.pass->filter));
+ d3d9_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
}
param = cgGetNamedParameter(pass->vPrg, attr_coord);
@@ -553,7 +554,7 @@ static void d3d9_cg_renderchain_bind_prev(void *data, const void *pass_data)
index = pass->attrib_map->data[cgGetParameterResourceIndex(param)];
- d3d_set_stream_source(chain->dev, index,
+ d3d9_set_stream_source(chain->dev, index,
vert_buf, 0, sizeof(struct CGVertex));
unsigned_vector_list_append(chain->bound_vert, index);
}
@@ -567,13 +568,13 @@ static void d3d9_cg_renderchain_add_lut_internal(void *data,
if (!chain)
return;
- d3d_set_texture(chain->dev, index, chain->luts->data[i].tex);
- d3d_set_sampler_magfilter(chain->dev, index,
- d3d_translate_filter(chain->luts->data[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST));
- d3d_set_sampler_minfilter(chain->dev, index,
- d3d_translate_filter(chain->luts->data[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST));
- d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, index, chain->luts->data[i].tex);
+ d3d9_set_sampler_magfilter(chain->dev, index,
+ d3d9_translate_filter(chain->luts->data[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST));
+ d3d9_set_sampler_minfilter(chain->dev, index,
+ d3d9_translate_filter(chain->luts->data[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST));
+ d3d9_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
unsigned_vector_list_append(chain->bound_tex, index);
}
@@ -620,13 +621,13 @@ static void d3d9_cg_renderchain_bind_pass(
index = cgGetParameterResourceIndex(param);
unsigned_vector_list_append(chain->bound_tex, index);
- d3d_set_texture(chain->dev, index, chain->passes->data[i].tex);
- d3d_set_sampler_magfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[i].info.pass->filter));
- d3d_set_sampler_minfilter(chain->dev, index,
- d3d_translate_filter(chain->passes->data[i].info.pass->filter));
- d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, index, chain->passes->data[i].tex);
+ d3d9_set_sampler_magfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[i].info.pass->filter));
+ d3d9_set_sampler_minfilter(chain->dev, index,
+ d3d9_translate_filter(chain->passes->data[i].info.pass->filter));
+ d3d9_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
}
param = cgGetNamedParameter(pass->vPrg, attr_coord);
@@ -634,7 +635,7 @@ static void d3d9_cg_renderchain_bind_pass(
{
index = pass->attrib_map->data[cgGetParameterResourceIndex(param)];
- d3d_set_stream_source(chain->dev, index, chain->passes->data[i].vertex_buf,
+ d3d9_set_stream_source(chain->dev, index, chain->passes->data[i].vertex_buf,
0, sizeof(struct CGVertex));
unsigned_vector_list_append(chain->bound_vert, index);
}
@@ -653,14 +654,14 @@ static void d3d9_cg_deinit_progs(void *data)
if (cg_data->passes->count >= 1)
{
- d3d_vertex_buffer_free(NULL, cg_data->passes->data[0].vertex_decl);
+ d3d9_vertex_buffer_free(NULL, cg_data->passes->data[0].vertex_decl);
for (i = 1; i < cg_data->passes->count; i++)
{
if (cg_data->passes->data[i].tex)
- d3d_texture_free(cg_data->passes->data[i].tex);
+ d3d9_texture_free(cg_data->passes->data[i].tex);
cg_data->passes->data[i].tex = NULL;
- d3d_vertex_buffer_free(
+ d3d9_vertex_buffer_free(
cg_data->passes->data[i].vertex_buf,
cg_data->passes->data[i].vertex_decl);
@@ -685,9 +686,9 @@ static void d3d9_cg_destroy_resources(void *data)
for (i = 0; i < TEXTURES; i++)
{
if (cg_data->prev.tex[i])
- d3d_texture_free(cg_data->prev.tex[i]);
+ d3d9_texture_free(cg_data->prev.tex[i]);
if (cg_data->prev.vertex_buf[i])
- d3d_vertex_buffer_free(cg_data->prev.vertex_buf[i], NULL);
+ d3d9_vertex_buffer_free(cg_data->prev.vertex_buf[i], NULL);
}
d3d9_cg_deinit_progs(cg_data);
@@ -695,7 +696,7 @@ static void d3d9_cg_destroy_resources(void *data)
for (i = 0; i < cg_data->luts->count; i++)
{
if (cg_data->luts->data[i].tex)
- d3d_texture_free(cg_data->luts->data[i].tex);
+ d3d9_texture_free(cg_data->luts->data[i].tex);
}
if (cg_data->state_tracker)
@@ -852,8 +853,8 @@ static bool d3d9_cg_renderchain_create_first_pass(
d3d_matrix_identity(&ident);
- d3d_set_transform(chain->dev, D3DTS_WORLD, &ident);
- d3d_set_transform(chain->dev, D3DTS_VIEW, &ident);
+ d3d9_set_transform(chain->dev, D3DTS_WORLD, &ident);
+ d3d9_set_transform(chain->dev, D3DTS_VIEW, &ident);
pass.info = *info;
pass.last_width = 0;
@@ -867,7 +868,7 @@ static bool d3d9_cg_renderchain_create_first_pass(
chain->prev.last_width[i] = 0;
chain->prev.last_height[i] = 0;
chain->prev.vertex_buf[i] = (LPDIRECT3DVERTEXBUFFER9)
- d3d_vertex_buffer_new(
+ d3d9_vertex_buffer_new(
chain->dev, 4 * sizeof(struct CGVertex),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, NULL);
@@ -875,23 +876,23 @@ static bool d3d9_cg_renderchain_create_first_pass(
return false;
chain->prev.tex[i] = (LPDIRECT3DTEXTURE9)
- d3d_texture_new(chain->dev, NULL,
+ d3d9_texture_new(chain->dev, NULL,
info->tex_w, info->tex_h, 1, 0,
(fmt == RETRO_PIXEL_FORMAT_RGB565) ?
- d3d_get_rgb565_format() : d3d_get_xrgb8888_format(),
+ d3d9_get_rgb565_format() : d3d9_get_xrgb8888_format(),
D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL, false);
if (!chain->prev.tex[i])
return false;
- d3d_set_texture(chain->dev, 0, chain->prev.tex[i]);
- d3d_set_sampler_minfilter(chain->dev, 0,
- d3d_translate_filter(info->pass->filter));
- d3d_set_sampler_magfilter(chain->dev, 0,
- d3d_translate_filter(info->pass->filter));
- d3d_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_texture(chain->dev, 0, NULL);
+ d3d9_set_texture(chain->dev, 0, chain->prev.tex[i]);
+ d3d9_set_sampler_minfilter(chain->dev, 0,
+ d3d9_translate_filter(info->pass->filter));
+ d3d9_set_sampler_magfilter(chain->dev, 0,
+ d3d9_translate_filter(info->pass->filter));
+ d3d9_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, 0, NULL);
}
d3d9_cg_load_program(chain, &pass.fPrg,
@@ -950,27 +951,27 @@ static bool d3d9_cg_renderchain_set_pass_size(
if (width != pass->info.tex_w || height != pass->info.tex_h)
{
- d3d_texture_free(pass->tex);
+ d3d9_texture_free(pass->tex);
pass->info.tex_w = width;
pass->info.tex_h = height;
pass->pool = D3DPOOL_DEFAULT;
pass->tex = (LPDIRECT3DTEXTURE9)
- d3d_texture_new(chain->dev, NULL,
+ d3d9_texture_new(chain->dev, NULL,
width, height, 1,
D3DUSAGE_RENDERTARGET,
chain->passes->data[chain->passes->count - 1].info.pass->fbo.fp_fbo ?
- D3DFMT_A32B32G32R32F : d3d_get_argb8888_format(),
+ D3DFMT_A32B32G32R32F : d3d9_get_argb8888_format(),
D3DPOOL_DEFAULT, 0, 0, 0,
NULL, NULL, false);
if (!pass->tex)
return false;
- d3d_set_texture(chain->dev, 0, pass->tex);
- d3d_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_texture(chain->dev, 0, NULL);
+ d3d9_set_texture(chain->dev, 0, pass->tex);
+ d3d9_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, 0, NULL);
}
return true;
@@ -1104,14 +1105,14 @@ static bool d3d9_cg_renderchain_add_pass(
return false;
pass.vertex_buf = (LPDIRECT3DVERTEXBUFFER9)
- d3d_vertex_buffer_new(chain->dev,
+ d3d9_vertex_buffer_new(chain->dev,
4 * sizeof(struct CGVertex),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, NULL);
if (!pass.vertex_buf)
return false;
- pass.tex = (LPDIRECT3DTEXTURE9)d3d_texture_new(
+ pass.tex = (LPDIRECT3DTEXTURE9)d3d9_texture_new(
chain->dev,
NULL,
info->tex_w,
@@ -1119,16 +1120,16 @@ static bool d3d9_cg_renderchain_add_pass(
1,
D3DUSAGE_RENDERTARGET,
chain->passes->data[chain->passes->count - 1].info.pass->fbo.fp_fbo
- ? D3DFMT_A32B32G32R32F : d3d_get_argb8888_format(),
+ ? D3DFMT_A32B32G32R32F : d3d9_get_argb8888_format(),
D3DPOOL_DEFAULT, 0, 0, 0, NULL, NULL, false);
if (!pass.tex)
return false;
- d3d_set_texture(chain->dev, 0, pass.tex);
- d3d_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_texture(chain->dev, 0, NULL);
+ d3d9_set_texture(chain->dev, 0, pass.tex);
+ d3d9_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, 0, NULL);
pass_vector_list_append(chain->passes, pass);
@@ -1142,7 +1143,7 @@ static bool d3d9_cg_renderchain_add_lut(void *data,
struct lut_info info;
cg_renderchain_t *chain = (cg_renderchain_t*)data;
LPDIRECT3DTEXTURE9 lut = (LPDIRECT3DTEXTURE9)
- d3d_texture_new(
+ d3d9_texture_new(
chain->dev,
path,
D3D_DEFAULT_NONPOW2,
@@ -1167,10 +1168,10 @@ static bool d3d9_cg_renderchain_add_lut(void *data,
if (!lut)
return false;
- d3d_set_texture(chain->dev, 0, lut);
- d3d_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
- d3d_set_texture(chain->dev, 0, NULL);
+ d3d9_set_texture(chain->dev, 0, lut);
+ d3d9_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER);
+ d3d9_set_texture(chain->dev, 0, NULL);
lut_info_vector_list_append(chain->luts, info);
@@ -1307,9 +1308,9 @@ static void cg_d3d9_renderchain_set_vertices(
vert[i].y += 0.5f;
}
- verts = d3d_vertex_buffer_lock(pass->vertex_buf);
+ verts = d3d9_vertex_buffer_lock(pass->vertex_buf);
memcpy(verts, vert, sizeof(vert));
- d3d_vertex_buffer_unlock(pass->vertex_buf);
+ d3d9_vertex_buffer_unlock(pass->vertex_buf);
}
if (chain)
@@ -1337,17 +1338,17 @@ static void cg_d3d9_renderchain_blit_to_texture(
(first->last_width != width || first->last_height != height)
)
{
- d3d_lock_rectangle(first->tex, 0, &d3dlr,
+ d3d9_lock_rectangle(first->tex, 0, &d3dlr,
NULL, first->info.tex_h, D3DLOCK_NOSYSLOCK);
- d3d_lock_rectangle_clear(first->tex, 0, &d3dlr,
+ d3d9_lock_rectangle_clear(first->tex, 0, &d3dlr,
NULL, first->info.tex_h, D3DLOCK_NOSYSLOCK);
}
- if (d3d_lock_rectangle(first->tex, 0, &d3dlr, NULL, 0, 0))
+ if (d3d9_lock_rectangle(first->tex, 0, &d3dlr, NULL, 0, 0))
{
- d3d_texture_blit(chain->pixel_size, first->tex,
+ d3d9_texture_blit(chain->pixel_size, first->tex,
&d3dlr, frame, width, height, pitch);
- d3d_unlock_rectangle(first->tex);
+ d3d9_unlock_rectangle(first->tex);
}
}
@@ -1360,15 +1361,15 @@ static void cg_d3d9_renderchain_unbind_all(cg_renderchain_t *chain)
*/
for (i = 0; i < chain->bound_tex->count; i++)
{
- d3d_set_sampler_minfilter(chain->dev,
+ d3d9_set_sampler_minfilter(chain->dev,
chain->bound_tex->data[i], D3DTEXF_POINT);
- d3d_set_sampler_magfilter(chain->dev,
+ d3d9_set_sampler_magfilter(chain->dev,
chain->bound_tex->data[i], D3DTEXF_POINT);
- d3d_set_texture(chain->dev, chain->bound_tex->data[i], NULL);
+ d3d9_set_texture(chain->dev, chain->bound_tex->data[i], NULL);
}
for (i = 0; i < chain->bound_vert->count; i++)
- d3d_set_stream_source(chain->dev, chain->bound_vert->data[i], 0, 0, 0);
+ d3d9_set_stream_source(chain->dev, chain->bound_vert->data[i], 0, 0, 0);
if (chain->bound_tex)
{
@@ -1423,15 +1424,15 @@ static void cg_d3d9_renderchain_render_pass(
cgD3D9BindProgram(pass->fPrg);
cgD3D9BindProgram(pass->vPrg);
- d3d_set_texture(chain->dev, 0, pass->tex);
- d3d_set_sampler_minfilter(chain->dev, 0,
- d3d_translate_filter(pass->info.pass->filter));
- d3d_set_sampler_magfilter(chain->dev, 0,
- d3d_translate_filter(pass->info.pass->filter));
+ d3d9_set_texture(chain->dev, 0, pass->tex);
+ d3d9_set_sampler_minfilter(chain->dev, 0,
+ d3d9_translate_filter(pass->info.pass->filter));
+ d3d9_set_sampler_magfilter(chain->dev, 0,
+ d3d9_translate_filter(pass->info.pass->filter));
- d3d_set_vertex_declaration(chain->dev, pass->vertex_decl);
+ d3d9_set_vertex_declaration(chain->dev, pass->vertex_decl);
for (i = 0; i < 4; i++)
- d3d_set_stream_source(chain->dev, i,
+ d3d9_set_stream_source(chain->dev, i,
pass->vertex_buf, 0,
sizeof(struct CGVertex));
@@ -1471,12 +1472,12 @@ static void cg_d3d9_renderchain_render_pass(
cg_d3d9_renderchain_set_params(chain, pass, pass_index);
- d3d_draw_primitive(chain->dev, D3DPT_TRIANGLESTRIP, 0, 2);
+ d3d9_draw_primitive(chain->dev, D3DPT_TRIANGLESTRIP, 0, 2);
/* So we don't render with linear filter into render targets,
* which apparently looked odd (too blurry). */
- d3d_set_sampler_minfilter(chain->dev, 0, D3DTEXF_POINT);
- d3d_set_sampler_magfilter(chain->dev, 0, D3DTEXF_POINT);
+ d3d9_set_sampler_minfilter(chain->dev, 0, D3DTEXF_POINT);
+ d3d9_set_sampler_magfilter(chain->dev, 0, D3DTEXF_POINT);
cg_d3d9_renderchain_unbind_all(chain);
}
@@ -1505,7 +1506,7 @@ static bool d3d9_cg_renderchain_render(
frame_data, width, height, pitch);
/* Grab back buffer. */
- d3d_device_get_render_target(chain->dev, 0, (void**)&back_buffer);
+ d3d9_device_get_render_target(chain->dev, 0, (void**)&back_buffer);
/* In-between render target passes. */
for (i = 0; i < chain->passes->count - 1; i++)
@@ -1514,9 +1515,9 @@ static bool d3d9_cg_renderchain_render(
struct Pass *from_pass = (struct Pass*)&chain->passes->data[i];
struct Pass *to_pass = (struct Pass*)&chain->passes->data[i + 1];
- d3d_texture_get_surface_level(to_pass->tex, 0, (void**)&target);
+ d3d9_texture_get_surface_level(to_pass->tex, 0, (void**)&target);
- d3d_device_set_render_target(chain->dev, 0, (void*)target);
+ d3d9_device_set_render_target(chain->dev, 0, (void*)target);
d3d9_cg_renderchain_convert_geometry(chain, &from_pass->info,
&out_width, &out_height,
@@ -1528,13 +1529,13 @@ static bool d3d9_cg_renderchain_render(
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
- d3d_set_viewports(chain->dev, &viewport);
- d3d_clear(chain->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
+ d3d9_set_viewports(chain->dev, &viewport);
+ d3d9_clear(chain->dev, 0, 0, D3DCLEAR_TARGET, 0, 1, 0);
viewport.Width = out_width;
viewport.Height = out_height;
- d3d_set_viewports(chain->dev, &viewport);
+ d3d9_set_viewports(chain->dev, &viewport);
cg_d3d9_renderchain_set_vertices(chain, from_pass,
current_width, current_height,
@@ -1546,11 +1547,11 @@ static bool d3d9_cg_renderchain_render(
current_width = out_width;
current_height = out_height;
- d3d_surface_free(target);
+ d3d9_surface_free(target);
}
/* Final pass */
- d3d_device_set_render_target(chain->dev, 0, (void*)back_buffer);
+ d3d9_device_set_render_target(chain->dev, 0, (void*)back_buffer);
last_pass = (struct Pass*)&chain->passes->
data[chain->passes->count - 1];
@@ -1559,7 +1560,7 @@ static bool d3d9_cg_renderchain_render(
&out_width, &out_height,
current_width, current_height, chain->final_viewport);
- d3d_set_viewports(chain->dev, chain->final_viewport);
+ d3d9_set_viewports(chain->dev, chain->final_viewport);
cg_d3d9_renderchain_set_vertices(chain, last_pass,
current_width, current_height,
@@ -1573,7 +1574,7 @@ static bool d3d9_cg_renderchain_render(
chain->frame_count++;
- d3d_surface_free(back_buffer);
+ d3d9_surface_free(back_buffer);
if (chain)
{
@@ -1639,18 +1640,18 @@ static bool d3d9_cg_renderchain_read_viewport(
(void)buffer;
if (
- !d3d_device_get_render_target(d3dr, 0, (void**)&target) ||
- !d3d_device_create_offscreen_plain_surface(d3dr, width, height,
- d3d_get_xrgb8888_format(),
+ !d3d9_device_get_render_target(d3dr, 0, (void**)&target) ||
+ !d3d9_device_create_offscreen_plain_surface(d3dr, width, height,
+ d3d9_get_xrgb8888_format(),
D3DPOOL_SYSTEMMEM, (void**)&dest, NULL) ||
- !d3d_device_get_render_target_data(d3dr, (void*)target, (void*)dest)
+ !d3d9_device_get_render_target_data(d3dr, (void*)target, (void*)dest)
)
{
ret = false;
goto end;
}
- if (d3d_surface_lock_rect(dest, (void*)&rect))
+ if (d3d9_surface_lock_rect(dest, (void*)&rect))
{
unsigned x, y;
unsigned pitchpix = rect.Pitch / 4;
@@ -1670,16 +1671,16 @@ static bool d3d9_cg_renderchain_read_viewport(
}
}
- d3d_surface_unlock_rect((void*)dest);
+ d3d9_surface_unlock_rect((void*)dest);
}
else
ret = false;
end:
if (target)
- d3d_surface_free(target);
+ d3d9_surface_free(target);
if (dest)
- d3d_surface_free(dest);
+ d3d9_surface_free(dest);
return ret;
}
diff --git a/gfx/drivers_renderchain/d3d9_hlsl_renderchain.c b/gfx/drivers_renderchain/d3d9_hlsl_renderchain.c
index 4ea711895b..0f61b2b0b3 100644
--- a/gfx/drivers_renderchain/d3d9_hlsl_renderchain.c
+++ b/gfx/drivers_renderchain/d3d9_hlsl_renderchain.c
@@ -23,6 +23,7 @@
#include "../drivers/d3d.h"
#include "../../defines/d3d_defines.h"
#include "../common/d3d_common.h"
+#include "../common/d3d9_common.h"
#include "../video_driver.h"
@@ -47,8 +48,8 @@ static void hlsl_d3d9_renderchain_clear(void *data)
{
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)data;
- d3d_texture_free(chain->tex);
- d3d_vertex_buffer_free(chain->vertex_buf, chain->vertex_decl);
+ d3d9_texture_free(chain->tex);
+ d3d9_vertex_buffer_free(chain->vertex_buf, chain->vertex_decl);
}
static bool hlsl_d3d9_renderchain_init_shader_fvf(void *data, void *pass_data)
@@ -66,7 +67,7 @@ static bool hlsl_d3d9_renderchain_init_shader_fvf(void *data, void *pass_data)
(void)pass_data;
- return d3d_vertex_declaration_new(d3d->dev,
+ return d3d9_vertex_declaration_new(d3d->dev,
VertexElements, (void**)&chain->vertex_decl);
}
@@ -77,7 +78,7 @@ static bool hlsl_d3d9_renderchain_create_first_pass(void *data,
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)
d3d->renderchain_data;
- chain->vertex_buf = d3d_vertex_buffer_new(
+ chain->vertex_buf = d3d9_vertex_buffer_new(
d3d->dev, 4 * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
#ifdef _XBOX
@@ -91,19 +92,19 @@ static bool hlsl_d3d9_renderchain_create_first_pass(void *data,
if (!chain->vertex_buf)
return false;
- chain->tex = d3d_texture_new(d3d->dev, NULL,
+ chain->tex = d3d9_texture_new(d3d->dev, NULL,
chain->tex_w, chain->tex_h, 1, 0,
info->rgb32 ?
- d3d_get_xrgb8888_format() : d3d_get_rgb565_format(),
+ d3d9_get_xrgb8888_format() : d3d9_get_rgb565_format(),
0, 0, 0, 0, NULL, NULL, false);
if (!chain->tex)
return false;
- d3d_set_sampler_address_u(d3d->dev, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
- d3d_set_sampler_address_v(d3d->dev, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
- d3d_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
- d3d_set_render_state(d3d->dev, D3DRS_ZENABLE, FALSE);
+ d3d9_set_sampler_address_u(d3d->dev, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
+ d3d9_set_sampler_address_v(d3d->dev, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
+ d3d9_set_render_state(d3d->dev, D3DRS_CULLMODE, D3DCULL_NONE);
+ d3d9_set_render_state(d3d->dev, D3DRS_ZENABLE, FALSE);
if (!hlsl_d3d9_renderchain_init_shader_fvf(chain, chain))
return false;
@@ -168,9 +169,9 @@ static void hlsl_d3d9_renderchain_set_vertices(
vert[i].y += 0.5f / ((float)chain->tex_h);
}
- verts = d3d_vertex_buffer_lock(chain->vertex_buf);
+ verts = d3d9_vertex_buffer_lock(chain->vertex_buf);
memcpy(verts, vert, sizeof(vert));
- d3d_vertex_buffer_unlock(chain->vertex_buf);
+ d3d9_vertex_buffer_unlock(chain->vertex_buf);
}
shader_info.data = d3d;
@@ -205,20 +206,20 @@ static void hlsl_d3d9_renderchain_blit_to_texture(
if (chain->last_width != width || chain->last_height != height)
{
- d3d_lock_rectangle(chain->tex,
+ d3d9_lock_rectangle(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
- d3d_lock_rectangle_clear(chain->tex,
+ d3d9_lock_rectangle_clear(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
}
/* Set the texture to NULL so D3D doesn't complain about it being in use... */
- d3d_set_texture(chain->dev, 0, NULL);
+ d3d9_set_texture(chain->dev, 0, NULL);
- if (d3d_lock_rectangle(chain->tex, 0, &d3dlr, NULL, 0, 0))
+ if (d3d9_lock_rectangle(chain->tex, 0, &d3dlr, NULL, 0, 0))
{
- d3d_texture_blit(chain->pixel_size, chain->tex,
+ d3d9_texture_blit(chain->pixel_size, chain->tex,
&d3dlr, frame, width, height, pitch);
- d3d_unlock_rectangle(chain->tex);
+ d3d9_unlock_rectangle(chain->tex);
}
}
@@ -355,17 +356,17 @@ static bool hlsl_d3d9_renderchain_render(void *data, const void *frame,
hlsl_d3d9_renderchain_set_vertices(d3d,
1, frame_width, frame_height, chain->frame_count);
- d3d_set_texture(chain->dev, 0, chain->tex);
- d3d_set_viewports(chain->dev, &d3d->final_viewport);
- d3d_set_sampler_minfilter(chain->dev, 0,
+ d3d9_set_texture(chain->dev, 0, chain->tex);
+ d3d9_set_viewports(chain->dev, &d3d->final_viewport);
+ d3d9_set_sampler_minfilter(chain->dev, 0,
video_smooth ? D3DTEXF_LINEAR : D3DTEXF_POINT);
- d3d_set_sampler_magfilter(chain->dev, 0,
+ d3d9_set_sampler_magfilter(chain->dev, 0,
video_smooth ? D3DTEXF_LINEAR : D3DTEXF_POINT);
- d3d_set_vertex_declaration(chain->dev, chain->vertex_decl);
+ d3d9_set_vertex_declaration(chain->dev, chain->vertex_decl);
for (i = 0; i < 4; i++)
- d3d_set_stream_source(chain->dev, i, chain->vertex_buf, 0, sizeof(Vertex));
- d3d_draw_primitive(chain->dev, D3DPT_TRIANGLESTRIP, 0, 2);
+ d3d9_set_stream_source(chain->dev, i, chain->vertex_buf, 0, sizeof(Vertex));
+ d3d9_draw_primitive(chain->dev, D3DPT_TRIANGLESTRIP, 0, 2);
return true;
}
diff --git a/gfx/font_driver.c b/gfx/font_driver.c
index 3a0e4fb89d..8b11a68d4f 100644
--- a/gfx/font_driver.c
+++ b/gfx/font_driver.c
@@ -82,35 +82,67 @@ int font_renderer_create_default(const void **data, void **handle,
return 0;
}
-#ifdef HAVE_D3D
-static const font_renderer_t *d3d_font_backends[] = {
-#if defined(_XBOX360)
- &d3d_xbox360_font,
-#elif defined(_WIN32) && defined(HAVE_D3DX)
- &d3d_win32_font,
-#elif defined(_XBOX1)
+#ifdef HAVE_D3D8
+static const font_renderer_t *d3d8_font_backends[] = {
+#if defined(_XBOX1)
&d3d_xdk1_font,
#endif
NULL
};
-static bool d3d_font_init_first(
+static bool d3d8_font_init_first(
const void **font_driver, void **font_handle,
void *video_data, const char *font_path,
float font_size, bool is_threaded)
{
unsigned i;
- for (i = 0; i < ARRAY_SIZE(d3d_font_backends); i++)
+ for (i = 0; i < ARRAY_SIZE(d3d8_font_backends); i++)
{
- void *data = d3d_font_backends[i] ? d3d_font_backends[i]->init(
+ void *data = d3d8_font_backends[i] ? d3d8_font_backends[i]->init(
video_data, font_path, font_size,
is_threaded) : NULL;
if (!data)
continue;
- *font_driver = d3d_font_backends[i];
+ *font_driver = d3d8_font_backends[i];
+ *font_handle = data;
+
+ return true;
+ }
+
+ return false;
+}
+#endif
+
+#ifdef HAVE_D3D9
+static const font_renderer_t *d3d9_font_backends[] = {
+#if defined(_XBOX)
+ &d3d_xbox360_font,
+#elif defined(_WIN32) && defined(HAVE_D3DX)
+ &d3d_win32_font,
+#endif
+ NULL
+};
+
+static bool d3d9_font_init_first(
+ const void **font_driver, void **font_handle,
+ void *video_data, const char *font_path,
+ float font_size, bool is_threaded)
+{
+ unsigned i;
+
+ for (i = 0; i < ARRAY_SIZE(d3d9_font_backends); i++)
+ {
+ void *data = d3d9_font_backends[i] ? d3d9_font_backends[i]->init(
+ video_data, font_path, font_size,
+ is_threaded) : NULL;
+
+ if (!data)
+ continue;
+
+ *font_driver = d3d9_font_backends[i];
*font_handle = data;
return true;
@@ -441,11 +473,6 @@ static bool font_init_first(
switch (api)
{
-#ifdef HAVE_D3D
- case FONT_DRIVER_RENDER_DIRECT3D_API:
- return d3d_font_init_first(font_driver, font_handle,
- video_data, font_path, font_size, is_threaded);
-#endif
#ifdef HAVE_OPENGL
case FONT_DRIVER_RENDER_OPENGL_API:
return gl_font_init_first(font_driver, font_handle,
@@ -456,6 +483,16 @@ static bool font_init_first(
return vulkan_font_init_first(font_driver, font_handle,
video_data, font_path, font_size, is_threaded);
#endif
+#ifdef HAVE_D3D8
+ case FONT_DRIVER_RENDER_D3D8_API:
+ return d3d8_font_init_first(font_driver, font_handle,
+ video_data, font_path, font_size, is_threaded);
+#endif
+#ifdef HAVE_D3D9
+ case FONT_DRIVER_RENDER_D3D9_API:
+ return d3d9_font_init_first(font_driver, font_handle,
+ video_data, font_path, font_size, is_threaded);
+#endif
#ifdef HAVE_D3D11
case FONT_DRIVER_RENDER_D3D11_API:
return d3d11_font_init_first(font_driver, font_handle,
diff --git a/gfx/font_driver.h b/gfx/font_driver.h
index 2ae4030710..3f7edcaeef 100644
--- a/gfx/font_driver.h
+++ b/gfx/font_driver.h
@@ -30,7 +30,8 @@ enum font_driver_render_api
{
FONT_DRIVER_RENDER_DONT_CARE,
FONT_DRIVER_RENDER_OPENGL_API,
- FONT_DRIVER_RENDER_DIRECT3D_API,
+ FONT_DRIVER_RENDER_D3D8_API,
+ FONT_DRIVER_RENDER_D3D9_API,
FONT_DRIVER_RENDER_D3D11_API,
FONT_DRIVER_RENDER_D3D12_API,
FONT_DRIVER_RENDER_VITA2D,
diff --git a/griffin/griffin.c b/griffin/griffin.c
index 155008afc5..f802d71722 100644
--- a/griffin/griffin.c
+++ b/griffin/griffin.c
@@ -1158,8 +1158,12 @@ MENU
#include "../menu/drivers_display/menu_display_null.c"
-#if defined(HAVE_D3D)
-#include "../menu/drivers_display/menu_display_d3d.c"
+#if defined(HAVE_D3D8)
+#include "../menu/drivers_display/menu_display_d3d8.c"
+#endif
+
+#if defined(HAVE_D3D9)
+#include "../menu/drivers_display/menu_display_d3d9.c"
#endif
#if defined(HAVE_D3D11)
diff --git a/menu/drivers/xui.cpp b/menu/drivers/xui.cpp
index 4926bee1a8..0d4c8767d0 100644
--- a/menu/drivers/xui.cpp
+++ b/menu/drivers/xui.cpp
@@ -271,6 +271,8 @@ cleanup:
return hr;
}
+void d3d9_make_d3dpp(void *data, const video_info_t *info, void *_d3dpp);
+
static void* xui_init(void **userdata, bool video_is_threaded)
{
HRESULT hr;
@@ -296,7 +298,7 @@ static void* xui_init(void **userdata, bool video_is_threaded)
video_info.fullscreen = true;
video_info.rgb32 = false;
- d3d_make_d3dpp(d3d, &video_info, &d3dpp);
+ d3d9_make_d3dpp(d3d, &video_info, &d3dpp);
hr = app.InitShared((D3DDevice*)d3d->dev, &d3dpp,
(PFN_XUITEXTURELOADER)XuiTextureLoader);
diff --git a/menu/drivers_display/menu_display_d3d8.c b/menu/drivers_display/menu_display_d3d8.c
new file mode 100644
index 0000000000..01d4ea7c4e
--- /dev/null
+++ b/menu/drivers_display/menu_display_d3d8.c
@@ -0,0 +1,288 @@
+/* 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 .
+ */
+
+#include
+
+#include
+
+#ifdef HAVE_CONFIG_H
+#include "../../config.h"
+#endif
+
+#include "../menu_driver.h"
+
+#include "../../gfx/video_driver.h"
+#include "../../gfx/drivers/d3d.h"
+#include "../../gfx/common/d3d_common.h"
+#include "../../gfx/common/d3d8_common.h"
+
+static const float d3d8_vertexes[] = {
+ 0, 0,
+ 1, 0,
+ 0, 1,
+ 1, 1
+};
+
+static const float d3d8_tex_coords[] = {
+ 0, 1,
+ 1, 1,
+ 0, 0,
+ 1, 0
+};
+
+static const float *menu_display_d3d8_get_default_vertices(void)
+{
+ return &d3d8_vertexes[0];
+}
+
+static const float *menu_display_d3d8_get_default_tex_coords(void)
+{
+ return &d3d8_tex_coords[0];
+}
+
+static void *menu_display_d3d8_get_default_mvp(video_frame_info_t *video_info)
+{
+ static math_matrix_4x4 id;
+ matrix_4x4_identity(id);
+
+ return &id;
+}
+
+static INT32 menu_display_prim_to_d3d8_enum(
+ enum menu_display_prim_type prim_type)
+{
+ switch (prim_type)
+ {
+ case MENU_DISPLAY_PRIM_TRIANGLES:
+ case MENU_DISPLAY_PRIM_TRIANGLESTRIP:
+ return D3DPT_COMM_TRIANGLESTRIP;
+ case MENU_DISPLAY_PRIM_NONE:
+ default:
+ break;
+ }
+
+ /* TOD/FIXME - hack */
+ return 0;
+}
+
+static void menu_display_d3d8_blend_begin(video_frame_info_t *video_info)
+{
+ d3d_video_t *d3d = video_info ?
+ (d3d_video_t*)video_info->userdata : NULL;
+
+ if (!d3d)
+ return;
+
+ d3d8_enable_blend_func(d3d->dev);
+}
+
+static void menu_display_d3d8_blend_end(video_frame_info_t *video_info)
+{
+ d3d_video_t *d3d = video_info ?
+ (d3d_video_t*)video_info->userdata : NULL;
+
+ if (!d3d)
+ return;
+
+ d3d8_disable_blend_func(d3d->dev);
+}
+
+static void menu_display_d3d8_viewport(void *data, video_frame_info_t *video_info)
+{
+}
+
+static void menu_display_d3d8_bind_texture(void *data, d3d_video_t *d3d)
+{
+ menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
+
+ if (!d3d || !draw || !draw->texture)
+ return;
+
+ d3d8_set_texture(d3d->dev, 0, (void*)draw->texture);
+ d3d8_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
+ d3d8_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
+ d3d8_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+ d3d8_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+ d3d8_set_sampler_mipfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+}
+
+static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
+{
+ unsigned i;
+ video_shader_ctx_mvp_t mvp;
+ math_matrix_4x4 mop, m1, m2;
+ unsigned width, height;
+ d3d_video_t *d3d = video_info ? (d3d_video_t*)video_info->userdata : NULL;
+ menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_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;
+ if((d3d->menu_display.offset + draw->coords->vertices )
+ > (unsigned)d3d->menu_display.size)
+ return;
+
+ pv = (Vertex*)
+ d3d8_vertex_buffer_lock(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 = menu_display_d3d8_get_default_vertices();
+ if (!tex_coord)
+ tex_coord = menu_display_d3d8_get_default_tex_coords();
+
+ 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++;
+
+#if 1
+ if ((void*)draw->texture)
+ {
+ D3DSURFACE_DESC desc;
+ if (d3d8_texture_get_level_desc((void*)draw->texture, 0, &desc))
+ {
+ pv[i].u *= desc.Width;
+ pv[i].v *= desc.Height;
+ }
+ }
+#endif
+
+ pv[i].color =
+ D3DCOLOR_ARGB(
+ colors[3], /* A */
+ colors[0], /* R */
+ colors[1], /* G */
+ colors[2] /* B */
+ );
+ }
+ d3d8_vertex_buffer_unlock(d3d->menu_display.buffer);
+
+ if(!draw->matrix_data)
+ draw->matrix_data = menu_display_d3d8_get_default_mvp(video_info);
+
+ /* ugh */
+ video_driver_get_size(&width, &height);
+ 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) / width,
+ (draw->height / 2.0) / height, 0);
+ matrix_4x4_multiply(m2, mop, m1);
+ matrix_4x4_translate(mop,
+ (draw->x + (draw->width / 2.0)) / width,
+ (draw->y + (draw->height / 2.0)) / height,
+ 0);
+ matrix_4x4_multiply(m1, mop, m2);
+ matrix_4x4_multiply(m2, d3d->mvp_transposed, m1);
+ d3d_matrix_transpose(&m1, &m2);
+
+ mvp.data = d3d;
+ mvp.matrix = &m1;
+ video_driver_set_mvp(&mvp);
+ menu_display_d3d8_bind_texture(draw, (d3d_video_t*)video_info->userdata);
+ d3d8_draw_primitive(d3d->dev,
+ menu_display_prim_to_d3d8_enum(draw->prim_type),
+ d3d->menu_display.offset,
+ draw->coords->vertices -
+ ((draw->prim_type == MENU_DISPLAY_PRIM_TRIANGLESTRIP)
+ ? 2 : 0));
+
+ d3d->menu_display.offset += draw->coords->vertices;
+}
+
+static void menu_display_d3d8_draw_pipeline(void *data,
+ video_frame_info_t *video_info)
+{
+}
+
+static void menu_display_d3d8_restore_clear_color(void)
+{
+ /* not needed */
+}
+
+static void menu_display_d3d8_clear_color(
+ menu_display_ctx_clearcolor_t *clearcolor, video_frame_info_t *video_info)
+{
+ DWORD clear_color = 0;
+ d3d_video_t *d3d = video_info ?
+ (d3d_video_t*)video_info->userdata : NULL;
+
+ if (!d3d || !clearcolor)
+ return;
+
+ clear_color = D3DCOLOR_ARGB(
+ BYTE_CLAMP(clearcolor->a * 255.0f), /* A */
+ BYTE_CLAMP(clearcolor->r * 255.0f), /* R */
+ BYTE_CLAMP(clearcolor->g * 255.0f), /* G */
+ BYTE_CLAMP(clearcolor->b * 255.0f) /* B */
+ );
+
+ d3d8_clear(d3d->dev, 0, NULL, D3D_COMM_CLEAR_TARGET, clear_color, 0, 0);
+}
+
+static bool menu_display_d3d8_font_init_first(
+ void **font_handle, void *video_data,
+ const char *font_path, float font_size,
+ bool is_threaded)
+{
+ font_data_t **handle = (font_data_t**)font_handle;
+ if (!(*handle = font_driver_init_first(video_data,
+ font_path, font_size, true,
+ is_threaded,
+ FONT_DRIVER_RENDER_D3D8_API)))
+ return false;
+ return true;
+}
+
+menu_display_ctx_driver_t menu_display_ctx_d3d8 = {
+ menu_display_d3d8_draw,
+ menu_display_d3d8_draw_pipeline,
+ menu_display_d3d8_viewport,
+ menu_display_d3d8_blend_begin,
+ menu_display_d3d8_blend_end,
+ menu_display_d3d8_restore_clear_color,
+ menu_display_d3d8_clear_color,
+ menu_display_d3d8_get_default_mvp,
+ menu_display_d3d8_get_default_vertices,
+ menu_display_d3d8_get_default_tex_coords,
+ menu_display_d3d8_font_init_first,
+ MENU_VIDEO_DRIVER_DIRECT3D8,
+ "menu_display_d3d8",
+ false
+};
diff --git a/menu/drivers_display/menu_display_d3d.c b/menu/drivers_display/menu_display_d3d9.c
similarity index 69%
rename from menu/drivers_display/menu_display_d3d.c
rename to menu/drivers_display/menu_display_d3d9.c
index 6333a34264..cb62c95972 100644
--- a/menu/drivers_display/menu_display_d3d.c
+++ b/menu/drivers_display/menu_display_d3d9.c
@@ -26,34 +26,33 @@
#include "../../gfx/video_driver.h"
#include "../../gfx/drivers/d3d.h"
#include "../../gfx/common/d3d_common.h"
+#include "../../gfx/common/d3d9_common.h"
-#define BYTE_CLAMP(i) (int) ((((i) > 255) ? 255 : (((i) < 0) ? 0 : (i))))
-
-static const float d3d_vertexes[] = {
+static const float d3d9_vertexes[] = {
0, 0,
1, 0,
0, 1,
1, 1
};
-static const float d3d_tex_coords[] = {
+static const float d3d9_tex_coords[] = {
0, 1,
1, 1,
0, 0,
1, 0
};
-static const float *menu_display_d3d_get_default_vertices(void)
+static const float *menu_display_d3d9_get_default_vertices(void)
{
- return &d3d_vertexes[0];
+ return &d3d9_vertexes[0];
}
-static const float *menu_display_d3d_get_default_tex_coords(void)
+static const float *menu_display_d3d9_get_default_tex_coords(void)
{
- return &d3d_tex_coords[0];
+ return &d3d9_tex_coords[0];
}
-static void *menu_display_d3d_get_default_mvp(video_frame_info_t *video_info)
+static void *menu_display_d3d9_get_default_mvp(video_frame_info_t *video_info)
{
static math_matrix_4x4 id;
matrix_4x4_identity(id);
@@ -61,7 +60,7 @@ static void *menu_display_d3d_get_default_mvp(video_frame_info_t *video_info)
return &id;
}
-static INT32 menu_display_prim_to_d3d_enum(
+static INT32 menu_display_prim_to_d3d9_enum(
enum menu_display_prim_type prim_type)
{
switch (prim_type)
@@ -78,7 +77,7 @@ static INT32 menu_display_prim_to_d3d_enum(
return 0;
}
-static void menu_display_d3d_blend_begin(video_frame_info_t *video_info)
+static void menu_display_d3d9_blend_begin(video_frame_info_t *video_info)
{
d3d_video_t *d3d = video_info ?
(d3d_video_t*)video_info->userdata : NULL;
@@ -86,10 +85,10 @@ static void menu_display_d3d_blend_begin(video_frame_info_t *video_info)
if (!d3d)
return;
- d3d_enable_blend_func(d3d->dev);
+ d3d9_enable_blend_func(d3d->dev);
}
-static void menu_display_d3d_blend_end(video_frame_info_t *video_info)
+static void menu_display_d3d9_blend_end(video_frame_info_t *video_info)
{
d3d_video_t *d3d = video_info ?
(d3d_video_t*)video_info->userdata : NULL;
@@ -97,29 +96,29 @@ static void menu_display_d3d_blend_end(video_frame_info_t *video_info)
if (!d3d)
return;
- d3d_disable_blend_func(d3d->dev);
+ d3d9_disable_blend_func(d3d->dev);
}
-static void menu_display_d3d_viewport(void *data, video_frame_info_t *video_info)
+static void menu_display_d3d9_viewport(void *data, video_frame_info_t *video_info)
{
}
-static void menu_display_d3d_bind_texture(void *data, d3d_video_t *d3d)
+static void menu_display_d3d9_bind_texture(void *data, d3d_video_t *d3d)
{
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw || !draw->texture)
return;
- d3d_set_texture(d3d->dev, 0, (void*)draw->texture);
- d3d_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
- d3d_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
- d3d_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
- d3d_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
- d3d_set_sampler_mipfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+ d3d9_set_texture(d3d->dev, 0, (void*)draw->texture);
+ d3d9_set_sampler_address_u(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
+ d3d9_set_sampler_address_v(d3d->dev, 0, D3DTADDRESS_COMM_CLAMP);
+ d3d9_set_sampler_minfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+ d3d9_set_sampler_magfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
+ d3d9_set_sampler_mipfilter(d3d->dev, 0, D3DTEXF_COMM_LINEAR);
}
-static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
+static void menu_display_d3d9_draw(void *data, video_frame_info_t *video_info)
{
unsigned i;
video_shader_ctx_mvp_t mvp;
@@ -139,7 +138,7 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
return;
pv = (Vertex*)
- d3d_vertex_buffer_lock(d3d->menu_display.buffer);
+ d3d9_vertex_buffer_lock(d3d->menu_display.buffer);
if (!pv)
return;
@@ -150,9 +149,9 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
color = draw->coords->color;
if (!vertex)
- vertex = menu_display_d3d_get_default_vertices();
+ vertex = menu_display_d3d9_get_default_vertices();
if (!tex_coord)
- tex_coord = menu_display_d3d_get_default_tex_coords();
+ tex_coord = menu_display_d3d9_get_default_tex_coords();
for (i = 0; i < draw->coords->vertices; i++)
{
@@ -168,17 +167,6 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
pv[i].z = 0.5f;
pv[i].u = *tex_coord++;
pv[i].v = *tex_coord++;
-#ifdef HAVE_D3D8
- if ((void*)draw->texture)
- {
- D3DSURFACE_DESC desc;
- if (d3d_texture_get_level_desc((void*)draw->texture, 0, &desc))
- {
- pv[i].u *= desc.Width;
- pv[i].v *= desc.Height;
- }
- }
-#endif
pv[i].color =
D3DCOLOR_ARGB(
@@ -188,10 +176,10 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
colors[2] /* B */
);
}
- d3d_vertex_buffer_unlock(d3d->menu_display.buffer);
+ d3d9_vertex_buffer_unlock(d3d->menu_display.buffer);
if(!draw->matrix_data)
- draw->matrix_data = menu_display_d3d_get_default_mvp(video_info);
+ draw->matrix_data = menu_display_d3d9_get_default_mvp(video_info);
/* ugh */
video_driver_get_size(&width, &height);
@@ -215,9 +203,9 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
mvp.data = d3d;
mvp.matrix = &m1;
video_driver_set_mvp(&mvp);
- menu_display_d3d_bind_texture(draw, (d3d_video_t*)video_info->userdata);
- d3d_draw_primitive(d3d->dev,
- menu_display_prim_to_d3d_enum(draw->prim_type),
+ menu_display_d3d9_bind_texture(draw, (d3d_video_t*)video_info->userdata);
+ d3d9_draw_primitive(d3d->dev,
+ menu_display_prim_to_d3d9_enum(draw->prim_type),
d3d->menu_display.offset,
draw->coords->vertices -
((draw->prim_type == MENU_DISPLAY_PRIM_TRIANGLESTRIP)
@@ -226,7 +214,7 @@ static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
d3d->menu_display.offset += draw->coords->vertices;
}
-static void menu_display_d3d_draw_pipeline(void *data,
+static void menu_display_d3d9_draw_pipeline(void *data,
video_frame_info_t *video_info)
{
#if defined(HAVE_HLSL) || defined(HAVE_CG)
@@ -272,12 +260,12 @@ static void menu_display_d3d_draw_pipeline(void *data,
#endif
}
-static void menu_display_d3d_restore_clear_color(void)
+static void menu_display_d3d9_restore_clear_color(void)
{
/* not needed */
}
-static void menu_display_d3d_clear_color(
+static void menu_display_d3d9_clear_color(
menu_display_ctx_clearcolor_t *clearcolor, video_frame_info_t *video_info)
{
DWORD clear_color = 0;
@@ -294,10 +282,10 @@ static void menu_display_d3d_clear_color(
BYTE_CLAMP(clearcolor->b * 255.0f) /* B */
);
- d3d_clear(d3d->dev, 0, NULL, D3D_COMM_CLEAR_TARGET, clear_color, 0, 0);
+ d3d9_clear(d3d->dev, 0, NULL, D3D_COMM_CLEAR_TARGET, clear_color, 0, 0);
}
-static bool menu_display_d3d_font_init_first(
+static bool menu_display_d3d9_font_init_first(
void **font_handle, void *video_data,
const char *font_path, float font_size,
bool is_threaded)
@@ -306,24 +294,24 @@ static bool menu_display_d3d_font_init_first(
if (!(*handle = font_driver_init_first(video_data,
font_path, font_size, true,
is_threaded,
- FONT_DRIVER_RENDER_DIRECT3D_API)))
+ FONT_DRIVER_RENDER_D3D9_API)))
return false;
return true;
}
-menu_display_ctx_driver_t menu_display_ctx_d3d = {
- menu_display_d3d_draw,
- menu_display_d3d_draw_pipeline,
- menu_display_d3d_viewport,
- menu_display_d3d_blend_begin,
- menu_display_d3d_blend_end,
- menu_display_d3d_restore_clear_color,
- menu_display_d3d_clear_color,
- menu_display_d3d_get_default_mvp,
- menu_display_d3d_get_default_vertices,
- menu_display_d3d_get_default_tex_coords,
- menu_display_d3d_font_init_first,
- MENU_VIDEO_DRIVER_DIRECT3D,
- "menu_display_d3d",
+menu_display_ctx_driver_t menu_display_ctx_d3d9 = {
+ menu_display_d3d9_draw,
+ menu_display_d3d9_draw_pipeline,
+ menu_display_d3d9_viewport,
+ menu_display_d3d9_blend_begin,
+ menu_display_d3d9_blend_end,
+ menu_display_d3d9_restore_clear_color,
+ menu_display_d3d9_clear_color,
+ menu_display_d3d9_get_default_mvp,
+ menu_display_d3d9_get_default_vertices,
+ menu_display_d3d9_get_default_tex_coords,
+ menu_display_d3d9_font_init_first,
+ MENU_VIDEO_DRIVER_DIRECT3D9,
+ "menu_display_d3d9",
false
};
diff --git a/menu/menu_driver.c b/menu/menu_driver.c
index d6e4185133..afe4010343 100644
--- a/menu/menu_driver.c
+++ b/menu/menu_driver.c
@@ -87,8 +87,11 @@ static const menu_ctx_driver_t *menu_ctx_drivers[] = {
/* Menu display drivers */
static menu_display_ctx_driver_t *menu_display_ctx_drivers[] = {
-#ifdef HAVE_D3D
- &menu_display_ctx_d3d,
+#ifdef HAVE_D3D8
+ &menu_display_ctx_d3d8,
+#endif
+#ifdef HAVE_D3D9
+ &menu_display_ctx_d3d9,
#endif
#ifdef HAVE_D3D11
&menu_display_ctx_d3d11,
@@ -222,10 +225,12 @@ static bool menu_display_check_compatibility(
if (string_is_equal(video_driver, "vulkan"))
return true;
break;
- case MENU_VIDEO_DRIVER_DIRECT3D:
- if ( string_is_equal(video_driver, "d3d9") ||
- string_is_equal(video_driver, "d3d8")
- )
+ case MENU_VIDEO_DRIVER_DIRECT3D8:
+ if (string_is_equal(video_driver, "d3d8"))
+ return true;
+ break;
+ case MENU_VIDEO_DRIVER_DIRECT3D9:
+ if (string_is_equal(video_driver, "d3d9"))
return true;
break;
case MENU_VIDEO_DRIVER_DIRECT3D11:
diff --git a/menu/menu_driver.h b/menu/menu_driver.h
index 52dd7b80a3..bc545810f4 100644
--- a/menu/menu_driver.h
+++ b/menu/menu_driver.h
@@ -284,7 +284,8 @@ enum menu_display_driver_type
MENU_VIDEO_DRIVER_GENERIC = 0,
MENU_VIDEO_DRIVER_OPENGL,
MENU_VIDEO_DRIVER_VULKAN,
- MENU_VIDEO_DRIVER_DIRECT3D,
+ MENU_VIDEO_DRIVER_DIRECT3D8,
+ MENU_VIDEO_DRIVER_DIRECT3D9,
MENU_VIDEO_DRIVER_DIRECT3D11,
MENU_VIDEO_DRIVER_DIRECT3D12,
MENU_VIDEO_DRIVER_VITA2D,
@@ -754,7 +755,8 @@ extern uintptr_t menu_display_white_texture;
extern menu_display_ctx_driver_t menu_display_ctx_gl;
extern menu_display_ctx_driver_t menu_display_ctx_vulkan;
-extern menu_display_ctx_driver_t menu_display_ctx_d3d;
+extern menu_display_ctx_driver_t menu_display_ctx_d3d8;
+extern menu_display_ctx_driver_t menu_display_ctx_d3d9;
extern menu_display_ctx_driver_t menu_display_ctx_d3d11;
extern menu_display_ctx_driver_t menu_display_ctx_d3d12;
extern menu_display_ctx_driver_t menu_display_ctx_vita2d;