ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Get rid of inline functions in d3d8_common.h - simplify code

This commit is contained in:
libretroadmin 2022-05-15 05:48:09 +02:00
parent 927982e0d6
commit 7934e677ca
5 changed files with 124 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gfx/common/d3d8_common.c
View File

@ -216,15 +216,6 @@ void *d3d8_texture_new(LPDIRECT3DDEVICE8 dev,
return buf;
}
void d3d8_frame_postprocess(void *data)
{
#if defined(_XBOX)
global_t *global = global_get_ptr();
D3DDevice_SetFlickerFilter(global->console.screen.flicker_filter_index);
D3DDevice_SetSoftDisplayFilter(global->console.softfilter_enable);
#endif
}
static bool d3d8_reset_internal(LPDIRECT3DDEVICE8 dev,
D3DPRESENT_PARAMETERS *d3dpp
)

167
gfx/common/d3d8_common.h
View File

@ -73,76 +73,14 @@ typedef struct d3d8_video
overlay_t *overlays;
} d3d8_video_t;
static INLINE void *d3d8_vertex_buffer_new(
LPDIRECT3DDEVICE8 dev,
unsigned length, unsigned usage,
unsigned fvf, D3DPOOL pool, void *handle)
{
void *buf = NULL;
if (FAILED(IDirect3DDevice8_CreateVertexBuffer(
dev, length, usage, fvf,
pool,
(struct IDirect3DVertexBuffer8**)&buf)))
return NULL;
return buf;
}
static INLINE void *
d3d8_vertex_buffer_lock(LPDIRECT3DVERTEXBUFFER8 vertbuf)
{
void *buf = NULL;
if (!vertbuf)
return NULL;
void *buf = NULL;
IDirect3DVertexBuffer8_Lock(vertbuf, 0, 0, (BYTE**)&buf, 0);
if (!buf)
return NULL;
return buf;
}
static INLINE void d3d8_vertex_buffer_unlock(
LPDIRECT3DVERTEXBUFFER8 vertbuf)
{
if (vertbuf)
IDirect3DVertexBuffer8_Unlock(vertbuf);
}
static INLINE void d3d8_vertex_buffer_free(
LPDIRECT3DVERTEXBUFFER8 buf,
void *vertex_declaration)
{
if (buf)
{
IDirect3DVertexBuffer8_Release(buf);
buf = NULL;
}
}
static INLINE bool d3d8_texture_get_level_desc(
LPDIRECT3DTEXTURE8 tex,
unsigned idx, void *_ppsurface_level)
{
if (SUCCEEDED(IDirect3DTexture8_GetLevelDesc(
tex, idx, (D3DSURFACE_DESC*)_ppsurface_level)))
return true;
return false;
}
static INLINE bool d3d8_texture_get_surface_level(
LPDIRECT3DTEXTURE8 tex,
unsigned idx, void **_ppsurface_level)
{
if (tex &&
SUCCEEDED(
IDirect3DTexture8_GetSurfaceLevel(
tex, idx, (IDirect3DSurface8**)_ppsurface_level)))
return true;
return false;
}
void *d3d8_texture_new(LPDIRECT3DDEVICE8 dev,
const char *path, unsigned width, unsigned height,
unsigned miplevels, unsigned usage, INT32 format,
@ -150,87 +88,6 @@ void *d3d8_texture_new(LPDIRECT3DDEVICE8 dev,
INT32 color_key, void *src_info_data,
PALETTEENTRY *palette, bool want_mipmap);
static INLINE void d3d8_draw_primitive(LPDIRECT3DDEVICE8 dev,
D3DPRIMITIVETYPE type, unsigned start, unsigned count)
{
IDirect3DDevice8_BeginScene(dev);
IDirect3DDevice8_DrawPrimitive(dev, type, start, count);
IDirect3DDevice8_EndScene(dev);
}
static INLINE bool d3d8_lock_rectangle(
LPDIRECT3DTEXTURE8 tex,
unsigned level, D3DLOCKED_RECT *lr, RECT *rect,
unsigned rectangle_height, unsigned flags)
{
if (tex &&
IDirect3DTexture8_LockRect(tex,
level, lr, rect, flags) == D3D_OK)
return true;
return false;
}
static INLINE void d3d8_lock_rectangle_clear(
void *tex,
unsigned level, D3DLOCKED_RECT *lr, RECT *rect,
unsigned rectangle_height, unsigned flags)
{
#if defined(_XBOX)
level = 0;
#endif
memset(lr->pBits, level, rectangle_height * lr->Pitch);
IDirect3DTexture8_UnlockRect((LPDIRECT3DTEXTURE8)tex, 0);
}
static INLINE void d3d8_texture_blit(
unsigned pixel_size,
void *tex,
D3DLOCKED_RECT *lr,
const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
unsigned y;
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);
}
}
void d3d8_frame_postprocess(void *data);
static INLINE void d3d8_surface_free(LPDIRECT3DSURFACE8 surf)
{
if (surf)
IDirect3DSurface8_Release(surf);
}
static INLINE bool d3d8_surface_lock_rect(
LPDIRECT3DSURFACE8 surf, void *data2)
{
if (surf &&
SUCCEEDED(
IDirect3DSurface8_LockRect(
surf, (D3DLOCKED_RECT*)data2,
NULL, D3DLOCK_READONLY)))
return true;
return false;
}
static INLINE bool d3d8_get_adapter_display_mode(
LPDIRECT3D8 d3d,
unsigned idx,
void *display_mode)
{
if (d3d &&
SUCCEEDED(IDirect3D8_GetAdapterDisplayMode(
d3d, idx, (D3DDISPLAYMODE*)display_mode)))
return true;
return false;
}
bool d3d8_create_device(void *dev,
void *d3dpp,
LPDIRECT3D8 d3d,
@ -239,28 +96,6 @@ bool d3d8_create_device(void *dev,
bool d3d8_reset(void *dev, void *d3dpp);
static INLINE bool d3d8_device_get_backbuffer(
LPDIRECT3DDEVICE8 dev,
unsigned idx, unsigned swapchain_idx,
unsigned backbuffer_type, void **data)
{
if (dev &&
SUCCEEDED(IDirect3DDevice8_GetBackBuffer(dev, idx,
(D3DBACKBUFFER_TYPE)backbuffer_type,
(LPDIRECT3DSURFACE8*)data)))
return true;
return false;
}
static INLINE void d3d8_device_free(
LPDIRECT3DDEVICE8 dev, LPDIRECT3D8 pd3d)
{
if (dev)
IDirect3DDevice8_Release(dev);
if (pd3d)
IDirect3D8_Release(pd3d);
}
void *d3d8_create(void);
bool d3d8_initialize_symbols(enum gfx_ctx_api api);

173
gfx/drivers/d3d8.c
View File

@ -125,54 +125,55 @@ static void d3d8_set_vertices(
if (chain->last_width != vert_width || chain->last_height != vert_height)
{
Vertex vert[4];
float tex_w, tex_h;
void *verts = NULL;
float tex_w = vert_width;
float tex_h = vert_height;
chain->last_width = vert_width;
chain->last_height = vert_height;
tex_w = vert_width;
tex_h = vert_height;
if (chain->vertex_buf)
{
vert[0].x = 0.0f;
vert[0].y = 1.0f;
vert[0].z = 1.0f;
vert[0].x = 0.0f;
vert[0].y = 1.0f;
vert[0].z = 1.0f;
vert[1].x = 1.0f;
vert[1].y = 1.0f;
vert[1].z = 1.0f;
vert[1].x = 1.0f;
vert[1].y = 1.0f;
vert[1].z = 1.0f;
vert[2].x = 0.0f;
vert[2].y = 0.0f;
vert[2].z = 1.0f;
vert[2].x = 0.0f;
vert[2].y = 0.0f;
vert[2].z = 1.0f;
vert[3].x = 1.0f;
vert[3].y = 0.0f;
vert[3].z = 1.0f;
vert[3].x = 1.0f;
vert[3].y = 0.0f;
vert[3].z = 1.0f;
vert[0].u = 0.0f;
vert[0].v = 0.0f;
vert[1].v = 0.0f;
vert[2].u = 0.0f;
vert[1].u = tex_w;
vert[2].v = tex_h;
vert[3].u = tex_w;
vert[3].v = tex_h;
vert[0].u = 0.0f;
vert[0].v = 0.0f;
vert[1].v = 0.0f;
vert[2].u = 0.0f;
vert[1].u = tex_w;
vert[2].v = tex_h;
vert[3].u = tex_w;
vert[3].v = tex_h;
#ifndef _XBOX
vert[1].u /= chain->tex_w;
vert[2].v /= chain->tex_h;
vert[3].u /= chain->tex_w;
vert[3].v /= chain->tex_h;
vert[1].u /= chain->tex_w;
vert[2].v /= chain->tex_h;
vert[3].u /= chain->tex_w;
vert[3].v /= chain->tex_h;
#endif
vert[0].color = 0xFFFFFFFF;
vert[1].color = 0xFFFFFFFF;
vert[2].color = 0xFFFFFFFF;
vert[3].color = 0xFFFFFFFF;
vert[0].color = 0xFFFFFFFF;
vert[1].color = 0xFFFFFFFF;
vert[2].color = 0xFFFFFFFF;
vert[3].color = 0xFFFFFFFF;
verts = d3d8_vertex_buffer_lock(chain->vertex_buf);
memcpy(verts, vert, sizeof(vert));
d3d8_vertex_buffer_unlock(chain->vertex_buf);
verts = d3d8_vertex_buffer_lock(chain->vertex_buf);
memcpy(verts, vert, sizeof(vert));
IDirect3DVertexBuffer8_Unlock(chain->vertex_buf);
}
}
}
@ -182,26 +183,40 @@ static void d3d8_blit_to_texture(
unsigned width, unsigned height, unsigned pitch)
{
D3DLOCKED_RECT d3dlr;
D3DLOCKED_RECT *lr = &d3dlr;
LPDIRECT3DDEVICE8 d3dr = (LPDIRECT3DDEVICE8)chain->dev;
d3d8_frame_postprocess(chain);
LPDIRECT3DTEXTURE8 tex = (LPDIRECT3DTEXTURE8)chain->tex;
#ifdef _XBOX
global_t *global = global_get_ptr();
D3DDevice_SetFlickerFilter(global->console.screen.flicker_filter_index);
D3DDevice_SetSoftDisplayFilter(global->console.softfilter_enable);
#endif
if (chain->last_width != width || chain->last_height != height)
{
d3d8_lock_rectangle(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
d3d8_lock_rectangle_clear(chain->tex,
0, &d3dlr, NULL, chain->tex_h, D3DLOCK_NOSYSLOCK);
if (IDirect3DTexture8_LockRect(tex, level, lr, NULL, D3DLOCK_NOSYSLOCK) ==
D3D_OK)
{
memset(lr->pBits, 0, chain->tex_h * lr->Pitch);
IDirect3DTexture8_UnlockRect((LPDIRECT3DTEXTURE8)tex, 0);
}
}
/* Set the texture to NULL so D3D doesn't complain about it being in use... */
IDirect3DDevice8_SetTexture(d3dr, 0, NULL);
if (d3d8_lock_rectangle(chain->tex, 0, &d3dlr, NULL, 0, 0))
if (IDirect3DTexture8_LockRect(tex, 0, &d3dlr, NULL, 0) == D3D_OK)
{
d3d8_texture_blit(chain->pixel_size, chain->tex,
&d3dlr, frame, width, height, pitch);
IDirect3DTexture8_UnlockRect(chain->tex, 0);
unsigned y;
unsigned pixel_size = chain->pixel_size;
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);
}
IDirect3DTexture8_UnlockRect(tex, 0);
}
}
@ -243,6 +258,20 @@ static void d3d8_render(
chain->frame_count++;
}
static INLINE void *d3d8_vertex_buffer_new(
LPDIRECT3DDEVICE8 dev,
unsigned length, unsigned usage,
unsigned fvf, D3DPOOL pool, void *handle)
{
void *buf = NULL;
if (FAILED(IDirect3DDevice8_CreateVertexBuffer(
dev, length, usage, fvf,
pool,
(struct IDirect3DVertexBuffer8**)&buf)))
return NULL;
return buf;
}
static bool d3d8_setup_init(void *data,
const video_info_t *video_info,
void *dev_data,
@ -269,8 +298,7 @@ static bool d3d8_setup_init(void *data,
chain->vertex_buf = (LPDIRECT3DVERTEXBUFFER8)d3d8_vertex_buffer_new(d3dr, 4 * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
D3DPOOL_MANAGED,
NULL);
D3DPOOL_MANAGED);
if (!chain->vertex_buf)
return false;
@ -338,7 +366,6 @@ static void d3d8_overlay_render(d3d8_video_t *d3d,
{
D3DVIEWPORT8 vp_full;
struct video_viewport vp;
void *verts;
unsigned i;
Vertex vert[4];
enum D3DTEXTUREFILTERTYPE filter_type = D3DTEXF_LINEAR;
@ -351,7 +378,7 @@ static void d3d8_overlay_render(d3d8_video_t *d3d,
overlay->vert_buf = d3d8_vertex_buffer_new(
d3d->dev, sizeof(vert), D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
D3DPOOL_MANAGED, NULL);
D3DPOOL_MANAGED);
if (!overlay->vert_buf)
return;
@ -383,10 +410,12 @@ static void d3d8_overlay_render(d3d8_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 = d3d8_vertex_buffer_lock(overlay->vert_buf);
memcpy(verts, vert, sizeof(vert));
d3d8_vertex_buffer_unlock(overlay->vert_buf);
if (overlay->vert_buf)
{
void *verts = d3d8_vertex_buffer_lock(overlay->vert_buf);
memcpy(verts, vert, sizeof(vert));
IDirect3DVertexBuffer8_Unlock(overlay->vert_buf);
}
IDirect3DDevice8_SetRenderState(d3d->dev, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
IDirect3DDevice8_SetRenderState(d3d->dev, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
IDirect3DDevice8_SetRenderState(d3d->dev, D3DRS_ALPHABLENDENABLE, true);
@ -445,7 +474,9 @@ static void d3d8_free_overlay(d3d8_video_t *d3d, overlay_t *overlay)
tex = overlay->tex;
if (tex)
IDirect3DTexture8_Release(tex);
d3d8_vertex_buffer_free(overlay->vert_buf, NULL);
if (overlay->vert_buf)
IDirect3DVertexBuffer8_Release(overlay->vert_buf);
overlay->vert_buf = NULL;
}
static void d3d8_deinitialize(d3d8_video_t *d3d)
@ -468,13 +499,25 @@ static void d3d8_deinitialize(d3d8_video_t *d3d)
free(chain);
}
d3d->renderchain_data = NULL;
d3d8_vertex_buffer_free(d3d->menu_display.buffer, d3d->menu_display.decl);
IDirect3DVertexBuffer8_Release(d3d->menu_display.buffer);
d3d->menu_display.buffer = NULL;
d3d->menu_display.decl = NULL;
}
#define FS_PRESENTINTERVAL(pp) ((pp)->FullScreen_PresentationInterval)
static INLINE bool d3d8_get_adapter_display_mode(
LPDIRECT3D8 d3d,
unsigned idx,
void *display_mode)
{
if (d3d &&
SUCCEEDED(IDirect3D8_GetAdapterDisplayMode(
d3d, idx, (D3DDISPLAYMODE*)display_mode)))
return true;
return false;
}
static D3DFORMAT d3d8_get_color_format_backbuffer(bool rgb32, bool windowed)
{
D3DFORMAT fmt = D3DFMT_X8R8G8B8;
@ -840,7 +883,7 @@ static bool d3d8_initialize(d3d8_video_t *d3d, const video_info_t *info)
if (!d3d8_reset(d3d->dev, &d3dpp))
{
d3d8_deinitialize(d3d);
d3d8_device_free(NULL, g_pD3D8);
IDirect3D8_Release(g_pD3D8);
g_pD3D8 = NULL;
ret = d3d8_init_base(d3d, info);
@ -888,8 +931,7 @@ static bool d3d8_initialize(d3d8_video_t *d3d, const video_info_t *info)
d3d->dev, d3d->menu_display.size * sizeof(Vertex),
D3DUSAGE_WRITEONLY,
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE,
D3DPOOL_DEFAULT,
NULL);
D3DPOOL_DEFAULT);
if (!d3d->menu_display.buffer)
return false;
@ -1234,8 +1276,9 @@ static void d3d8_free(void *data)
if (!string_is_empty(d3d->shader_path))
free(d3d->shader_path);
IDirect3DDevice8_Release(d3d->dev);
IDirect3D8_Release(g_pD3D8);
d3d->shader_path = NULL;
d3d8_device_free(d3d->dev, g_pD3D8);
d3d->dev = NULL;
g_pD3D8 = NULL;
@ -1320,8 +1363,8 @@ static bool d3d8_overlay_load(void *data,
if (!overlay->tex)
return false;
if (d3d8_lock_rectangle(overlay->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
if (IDirect3DTexture8_LockRect(overlay->tex, 0,
&d3dlr, NULL, D3DLOCK_NOSYSLOCK) == D3D_OK)
{
uint32_t *dst = (uint32_t*)(d3dlr.pBits);
const uint32_t *src = images[i].pixels;
@ -1566,8 +1609,8 @@ static void d3d8_set_menu_texture_frame(void *data,
d3d->menu->alpha_mod = alpha;
if (d3d8_lock_rectangle(d3d->menu->tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
if (IDirect3DTexture8_LockRect(d3d->menu->tex,
0, &d3dlr, NULL, D3DLOCK_NOSYSLOCK) == D3D_OK)
{
unsigned h, w;
@ -1644,8 +1687,8 @@ static void d3d8_video_texture_load_d3d(
if (!tex)
return;
if (d3d8_lock_rectangle(tex, 0, &d3dlr,
NULL, 0, D3DLOCK_NOSYSLOCK))
if (IDirect3DTexture8_LockRect(tex, 0, &d3dlr, NULL, D3DLOCK_NOSYSLOCK) ==
D3D_OK)
{
unsigned i;
uint32_t *dst = (uint32_t*)(d3dlr.pBits);

21
gfx/drivers_display/gfx_display_d3d8.c
View File

@ -161,17 +161,16 @@ static void gfx_display_d3d8_draw(gfx_display_ctx_draw_t *draw,
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
{
D3DSURFACE_DESC desc;
if (SUCCEEDED(IDirect3DTexture8_GetLevelDesc(
(void*)draw->texture, 0, (D3DSURFACE_DESC*)&desc)))
{
pv[i].u *= desc.Width;
pv[i].v *= desc.Height;
}
}
pv[i].color =
D3DCOLOR_ARGB(
@ -181,7 +180,7 @@ static void gfx_display_d3d8_draw(gfx_display_ctx_draw_t *draw,
colors[2] /* B */
);
}
d3d8_vertex_buffer_unlock(d3d->menu_display.buffer);
IDirect3DVertexBuffer8_Unlock(d3d->menu_display.buffer);
if (!draw->matrix_data)
draw->matrix_data = &default_mvp;

8
gfx/drivers_font/xdk1_xfonts.c
View File

@ -85,6 +85,7 @@ static void xfonts_render_msg(
settings_t *settings = config_get_ptr();
float video_msg_pos_x = settings->floats.video_msg_pos_x;
float video_msg_pos_y = settings->floats.video_msg_pos_y;
LPDIRECT3DDEVICE8 dev = xfonts->d3d->dev;
if (params)
{
@ -97,8 +98,9 @@ static void xfonts_render_msg(
y = video_msg_pos_y;
}
d3d8_device_get_backbuffer(xfonts->d3d->dev,
-1, 0, D3DBACKBUFFER_TYPE_MONO, &xfonts->surf);
IDirect3DDevice8_GetBackBuffer(dev, -1,
D3DBACKBUFFER_TYPE_MONO,
(LPDIRECT3DSURFACE8*)&xfonts->surf);
wc = utf8_to_utf16_string_alloc(msg);
@ -113,7 +115,7 @@ static void xfonts_render_msg(
#endif
free(wc);
}
d3d8_surface_free(xfonts->surf);
IDirect3DSurface8_Release((LPDIRECT3DSURFACE8)xfonts->surf);
}
font_renderer_t d3d_xdk1_font = {